String Type & Methods

// ── Declaration ──────────────────────────────────────────────────
string s      = "Hello";         // initialized
string empty;                    // = "" (empty, not null)
string path   = "/top/dut/fifo";
 
// ── Concatenation ─────────────────────────────────────────────────
string full   = {s, " World"};  // "Hello World"
string padded = {"[", s, "]"};   // "[Hello]"
 
// ── $sformatf: format a string (returns string) ───────────────────
string msg = $sformatf("TID=%0d addr=0x%08h", 42, 32'hCAFE);
 
// ── len() — character count ───────────────────────────────────────
int n = s.len();              // 5 for "Hello"
 
// ── getc() / putc() — character access by index ──────────────────
byte ch  = s.getc(0);         // 72 = ASCII 'H'
s.putc(0, 8'h68);              // replaces s[0] with 'h': "hello"
 
// ── substr(i, j) — extract substring [i..j] inclusive ─────────────
string sub = s.substr(1, 3);  // "ell" (from "Hello")
string ch_s = s.substr(0, 0); // "H" — single character as string
 
// ── toupper() / tolower() — case conversion ───────────────────────
string up  = s.toupper();      // "HELLO"
string low = s.tolower();      // "hello"
 
// ── compare() / icompare() — comparison ──────────────────────────
int cmp = s.compare("Hello");  // 0 = equal, <0 = less, >0 = greater
int icmp = s.icompare("HELLO"); // 0 — case-insensitive equal
 
// ── atoi() / atohex() / atoreal() — string → number ──────────────
string num_s = "42";
int    num   = num_s.atoi();    // 42 (decimal)
string hex_s = "FF";
int    hex   = hex_s.atohex(); // 255 (hexadecimal)
string rl_s  = "3.14";
real   rl    = rl_s.atoreal(); // 3.14
 
// ── itoa() / hextoa() / realtoa() — number → string ──────────────
string s_int;
s_int.itoa(255);               // s_int = "255"
s_int.hextoa(255);             // s_int = "ff"
string s_real;
s_real.realtoa(3.14);          // s_real = "3.14"
 
// ── Comparison operators (lexicographic, case-sensitive) ──────────
"abc" == "abc"    // 1
"abc" != "ABC"    // 1 — case-sensitive
"abc" <  "abd"    // 1 — lexicographic: c < d
"B"   <  "a"      // 1 — 'B'=66, 'a'=97, uppercase < lowercase in ASCII

module tb_string_basics;
 
  string s = "SystemVerilog";
  string result;
  int    n;
 
  initial begin
 
    // ── Length ────────────────────────────────────────────────────
    $display("len = %0d", s.len());              // 13
 
    // ── Substring ─────────────────────────────────────────────────
    $display("[0,5]  = %s", s.substr(0, 5));    // System
    $display("[6,12] = %s", s.substr(6, 12));   // Verilog
 
    // ── Case conversion ────────────────────────────────────────────
    $display("upper = %s", s.toupper());        // SYSTEMVERILOG
    $display("lower = %s", s.tolower());        // systemverilog
 
    // ── getc / putc ────────────────────────────────────────────────
    $display("s[0] = %0d (ASCII)", s.getc(0));   // 83 = 'S'
    s.putc(0, "s");                              // replace 'S' with 's'
    $display("after putc: %s", s);               // systemVerilog
    s = "SystemVerilog";                          // reset
 
    // ── compare / icompare ─────────────────────────────────────────
    $display("compare(same): %0d",     s.compare("SystemVerilog"));  // 0
    $display("compare(diff case): %0d", s.compare("systemverilog"));  // non-zero
    $display("icompare(same): %0d",    s.icompare("SYSTEMVERILOG")); // 0
 
    // ── $sformatf — build formatted strings ───────────────────────
    string msg = $sformatf("TXN[%0d]: addr=0x%08h data=0x%04h",
                           42, 32'hA000_1234, 16'hABCD);
    $display("%s", msg);
 
    // ── Numeric conversions ────────────────────────────────────────
    string ns = "255";
    $display("atoi:   %0d", ns.atoi());    // 255
    ns = "FF";
    $display("atohex: %0d", ns.atohex()); // 255
    ns = "1010";
    $display("atobin: %0d", ns.atobin()); // 10
 
    string out;
    out.itoa(255);   $display("itoa:   %s", out);   // 255
    out.hextoa(255); $display("hextoa: %s", out);   // ff
 
    $finish;
  end
 
endmodule

module tb_string_parsing;
 
  // Build a structured log entry string
  function automatic string format_txn(
    input int           tid,
    input logic [31:0] addr,
    input logic [31:0] data,
    input bit           is_write
  );
    string op = is_write ? "WR" : "RD";
    return $sformatf("[%s] TID=%03d ADDR=0x%08h DATA=0x%08h",
                     op, tid, addr, data);
  endfunction
 
  // Check if a component path contains a specific substring
  function automatic bit path_contains(string full_path, sub);
    // Manual substring search — find sub in full_path
    int sub_len  = sub.len();
    int path_len = full_path.len();
    for (int i = 0; i <= path_len - sub_len; i++) begin
      if (full_path.substr(i, i + sub_len - 1) == sub)
        return 1;
    end
    return 0;
  endfunction
 
  // Extract test name from command-line style argument "test=my_test"
  function automatic string parse_arg(string arg);
    for (int i = 0; i < arg.len(); i++) begin
      if (arg.getc(i) == "=")
        return arg.substr(i+1, arg.len()-1);
    end
    return arg;   // no '=' found, return original
  endfunction
 
  initial begin
    $display("%s", format_txn(7, 32'hA000_0100, 32'hCAFE_BABE, 1));
    $display("%s", format_txn(8, 32'hB000_0200, 32'h1234_5678, 0));
 
    $display("path has 'fifo': %0b", path_contains("/top/dut/fifo/ctrl", "fifo"));
    $display("path has 'sram': %0b", path_contains("/top/dut/fifo/ctrl", "sram"));
 
    $display("test name: %s", parse_arg("test=axi_burst_test"));
 
    $finish;
  end
 
endmodule

[WR] TID=007 ADDR=0xA0000100 DATA=0xCAFEBABE
[RD] TID=008 ADDR=0xB0000200 DATA=0x12345678
path has 'fifo': 1
path has 'sram': 0
test name: axi_burst_test

class axi_scoreboard;
 
  string  comp_name  = "axi_sb";
  int     check_cnt  = 0;
  int     fail_cnt   = 0;
 
  function automatic string make_banner(string title);
    string line = "================================";
    return {"\n", line, "\n  ", title, "\n", line};
  endfunction
 
  task automatic check(
    input logic [31:0] exp, got,
    input string        context_str = ""
  );
    string loc;
    check_cnt++;
 
    // Build location tag from component and context
    loc = (context_str == "") ?
          $sformatf("[%s]", comp_name) :
          $sformatf("[%s::%s]", comp_name, context_str);
 
    if (^got === 1'bX) begin
      $error("%s X-VALUE: got contains X — DUT not reset?", loc);
      fail_cnt++;
    end else if (exp !== got) begin
      $error("%s MISMATCH: expected=0x%08h got=0x%08h", loc, exp, got);
      fail_cnt++;
    end else
      $display("%s PASS: 0x%08h", loc, got);
  endtask
 
  function void report();
    string status = (fail_cnt == 0) ? "PASSED" : "FAILED";
    $display("%s", make_banner($sformatf("%s Test %s",
             comp_name.toupper(), status)));
    $display("  Checks: %0d  Fail: %0d", check_cnt, fail_cnt);
  endfunction
 
endclass
 
module tb_sb_demo;
  initial begin
    axi_scoreboard sb = new();
    sb.check(32'hAABB, 32'hAABB, "beat0");
    sb.check(32'hCCDD, 32'hCCEE, "beat1");
    sb.report();
    $finish;
  end
endmodule

module tb_string_corners;
 
  initial begin
 
    // ── s[i] vs getc(i) vs substr(i,i) ───────────────────────────
    string s = "ABC";
    $display("s[0]         = %0d (byte/ASCII)",  s[0]);           // 65
    $display("s.getc(0)    = %0d (byte/ASCII)",  s.getc(0));       // 65
    $display("s.substr(0,0)= %s (string char)", s.substr(0,0));  // A
 
    // ── Empty string ─────────────────────────────────────────────
    string empty;
    $display("empty.len()  = %0d", empty.len());  // 0
    $display("empty == '' : %0b", empty == "");   // 1
 
    // ── Lexicographic vs numeric comparison ───────────────────────
    $display("'10' < '9' (string): %0b",   "10" < "9");             // 1 — trap!
    $display("10 > 9 (integer):    %0b",   "10".atoi() > "9".atoi()); // 1 — correct
 
    // ── $sformatf vs itoa ─────────────────────────────────────────
    string s1 = $sformatf("%0d", 42);    // "42" — formatted
    string s2; s2.itoa(42);              // "42" — same result
    $display("sformatf: '%s'  itoa: '%s'", s1, s2);  // same
 
    // ── Out-of-range index: tool-dependent behavior ───────────────
    // s.getc(100) on "ABC" — most tools return 0 or error
    // Always guard: if (i < s.len()) before accessing
 
    // ── Concatenation with {} ─────────────────────────────────────
    string prefix = "AXI";
    string suffix; suffix.itoa(3);
    string full = {prefix, "_", suffix};   // "AXI_3"
    $display("concat: %s", full);
 
    $finish;
  end
 
endmodule

// ── 1. UVM COMPONENT NAMING ───────────────────────────────────────
// All UVM components have a string name and hierarchical path
// get_full_name() → "/top/env/axi_agent/driver"
// Filtering by path prefix/substring is common in debug
 
// ── 2. SCOREBOARD MISMATCH MESSAGES ──────────────────────────────
function automatic string mismatch_msg(
  string field, logic[31:0] exp, got);
  return $sformatf("%s: expected=0x%08h got=0x%08h diff=0x%08h",
                   field, exp, got, exp ^ got);
endfunction
 
// ── 3. PLUSARG / TEST CONFIGURATION ──────────────────────────────
string test_name = "default_test";
initial begin
  if ($value$plusargs("TEST=%s", test_name))
    $display("Running test: %s", test_name);
end
 
// ── 4. REGISTER FIELD NAMES IN RAL ───────────────────────────────
string field_names [8] = '{"STATUS", "CTRL", "IRQ", "MASK",
                            "DATA0", "DATA1", "ADDR", "ID"};
// Access by name: field_names[reg_index].toupper() for display
 
// ── 5. ASSOCIATIVE ARRAY WITH STRING KEYS ────────────────────────
int    opcode_hits [string];   // count by opcode name
opcode_hits["AXI_WRITE"]++;
opcode_hits["AXI_READ"]++;
// foreach (opcode_hits[name])
//   $display("%-15s: %0d hits", name, opcode_hits[name]);
 
// ── 6. CSV REPORT GENERATION ─────────────────────────────────────
function automatic string to_csv(string name, int val, pct);
  return $sformatf("%s,%0d,%0d%%", name, val, pct);
endfunction
// Write to file: $fdisplay(fd, to_csv("AXI_WR", 1234, 75));

// ── SIMULATION ONLY ────────────────────────────────────────────────
string state_name = "IDLE";        // dynamic length, simulator-managed
$display("state = %s", state_name);
 
// ── SYNTHESIZABLE EQUIVALENT ───────────────────────────────────────
// A string LITERAL assigned to a packed vector is a sized constant.
// "IDLE" is four bytes -> 32 bits, MSB-first: 'I' 'D' 'L' 'E'.
localparam logic [31:0] TAG_IDLE = "IDLE";   // 32'h49444C45
localparam logic [31:0] TAG_BUSY = "BUSY";   // 32'h42555359
 
logic [31:0] tag_q;
always_ff @(posedge clk or negedge rst_n)
  if      (!rst_n)   tag_q <= TAG_IDLE;
  else if (start)    tag_q <= TAG_BUSY;
  else if (done)     tag_q <= TAG_IDLE;

string s = "PASS";
 
// BUGGY: expecting a string comparison, getting a byte comparison
if (s[0] == "P")              // s[0]=80 (byte), "P"=80 in ASCII — actually works!
  $display("starts with P");  // BUT: this is byte vs byte comparison, not string vs string
 
// The real trap: trying to use s[i] as a string fails type check
string first = s[0];           // COMPILE ERROR: cannot assign byte to string
 
// CORRECT: use substr for single-character string access
string first_ok = s.substr(0, 0);  // "P" — proper single-char string
if (first_ok == "P")
  $display("correct string comparison");

string test_name;
$value$plusargs("TEST=%s", test_name);   // user types: +TEST=AXI_TEST
 
// BUGGY: case-sensitive comparison — fails if user typed "axi_test" or "Axi_Test"
if (test_name == "AXI_TEST")
  $display("running AXI test");      // only matches exact "AXI_TEST"
 
// CORRECT option 1: normalize to uppercase before comparison
if (test_name.toupper() == "AXI_TEST")
  $display("running AXI test");      // matches AXI_TEST, axi_test, Axi_Test
 
// CORRECT option 2: use icompare() for case-insensitive
if (test_name.icompare("AXI_TEST") == 0)
  $display("running AXI test");

string test_ids [$] = '{"test_9", "test_10", "test_2"};
test_ids.sort();
$display("Sorted: %p", test_ids);
// Prints: "test_10", "test_2", "test_9"
// Lexicographic: '1'(49) < '2'(50) < '9'(57) → 10 sorts before 2!
 
// For numeric sort of test names, extract the number and sort by int
function automatic int get_num(string name);
  // Find the underscore and get everything after it
  for (int i = 0; i < name.len(); i++)
    if (name.getc(i) == "_")
      return name.substr(i+1, name.len()-1).atoi();
  return 0;
endfunction
// Now sort by get_num(): test_2, test_9, test_10 — correct

// BUGGY: treating itoa like a function that returns a string
string s;
if (s.itoa(42) == "42")   // COMPILE ERROR: itoa returns void, not string
  $display("match");
 
// CORRECT: call itoa, then use the string
s.itoa(42);              // modifies s to "42"
if (s == "42")
  $display("match");    // works
 
// PREFERRED: use $sformatf instead — cleaner, works anywhere in an expression
string s2 = $sformatf("%0d", 42);   // "42" — directly usable in expression
if (s2 == "42") $display("match");

// string_semantics_proof.sv
//
// Self-checking proof of: copy-by-value assignment, which methods mutate,
// indexing returning a byte, and lexicographic vs numeric comparison.
module string_semantics_proof;
 
  int errors = 0;
 
  task automatic chk_s(string name, string got, string exp);
    if (got != exp) begin
      errors++;
      $display("FAIL %-46s got=\"%s\" exp=\"%s\"", name, got, exp);
    end else
      $display("pass %-46s = \"%s\"", name, got);
  endtask
 
  task automatic chk_i(string name, int got, int exp);
    if (got != exp) begin
      errors++;
      $display("FAIL %-46s got=%0d exp=%0d", name, got, exp);
    end else
      $display("pass %-46s = %0d", name, got);
  endtask
 
  initial begin
    // ================================================================
    // 1. ASSIGNMENT COPIES THE CONTENT, NOT A REFERENCE
    // ================================================================
    begin
      string s1 = "hello";
      string s2;
      s2 = s1;                       // an independent copy
      s2 = {s2, " world"};           // mutate the copy
      chk_s("s1 after s2 was modified", s1, "hello");
      chk_s("s2",                       s2, "hello world");
    end
 
    // ================================================================
    // 2. NO NULL TERMINATOR, NO FIXED BUFFER, EMPTY IS ""
    // ================================================================
    begin
      string e;                      // default-initialised
      chk_s("default string is empty", e,       "");
      chk_i("empty len() is 0",        e.len(), 0);
 
      e = "abc";
      chk_i("len() is the character count", e.len(), 3);
      e = {e, "defghij"};            // grows, no overflow to guard
      chk_i("len() after growth",           e.len(), 10);
    end
 
    // ================================================================
    // 3. INDEXING RETURNS A byte, NOT A ONE-CHARACTER STRING
    // ================================================================
    begin
      string s = "Hello";
      byte   b;
      string one;
 
      b   = s[0];                    // a byte: the ASCII code
      one = s.substr(0, 0);          // a one-character STRING
 
      chk_i("s[0] is a byte (ASCII 'H' = 72)", int'(b), 72);
      chk_s("s.substr(0,0) is a string",       one,     "H");
      chk_i("last index is len()-1",  int'(s[s.len()-1]), 111);  // 'o'
    end
 
    // ================================================================
    // 4. WHICH METHODS MUTATE
    // ================================================================
    begin
      string s = "abc";
      string up;
 
      up = s.toupper();              // RETURNS a copy
      chk_s("toupper() returns a copy", up, "ABC");
      chk_s("...original unchanged",    s,  "abc");
 
      s.itoa(42);                    // MUTATES in place, returns nothing
      chk_s("itoa() replaced the string", s, "42");
      chk_i("atoi() reads back the value", s.atoi(), 42);
    end
 
    // ================================================================
    // 5. COMPARISON IS TEXTUAL - lexicographic, case-sensitive
    // ================================================================
    begin
      chk_i("\"10\" < \"9\"   is TRUE (lexicographic)", int'("10" < "9"),  1);
      chk_i("10 < 9        is FALSE (numeric)",         int'(10 < 9),      0);
      chk_i("\"10\".atoi() > \"9\".atoi()",             int'("10".atoi() > "9".atoi()), 1);
 
      chk_i("\"RESET\" == \"reset\"  is FALSE",  int'(string'("RESET") == "reset"), 0);
      chk_i("case-normalised comparison is TRUE",
            int'(string'("RESET").tolower() == "reset"), 1);
 
      chk_i("\"Zebra\" < \"apple\"  is TRUE ('Z'=90 < 'a'=97)",
            int'("Zebra" < "apple"), 1);
    end
 
    if (errors == 0) $display("\nstring_semantics_proof: ALL CHECKS PASSED");
    else             $display("\nstring_semantics_proof: %0d FAILURES", errors);
    $finish;
  end
endmodule