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));

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");