How do form Variable names by using defines in system verilog:
https://stackoverflow.com/questions/20759707/how-do-form-variable-names-by-using-defines-in-system-verilog
https://verificationacademy.com/forums/systemverilog/define-macros-usage
https://stackoverflow.com/questions/15373113/how-to-create-a-string-from-a-pre-processor-macro
Below is from LRM:
The `define macro text can also include `" , `\`" , and ``.
An `" overrides the usual lexical meaning of " and indicates that the expansion shall include the quotation mark, substitution of actual arguments, and expansions of embedded macros. This allows string literals to be constructed from macro arguments.
A mixture of `" and " is allowed in the macro text, however the use of " always starts a string literal and
must have a terminating " . Any characters embedded inside this string literal, including `" , become part of the string in the replaced macro text. Thus, if " is followed by `" , the " starts a string literal whose last character is ` and is terminated by the " of `" .
A `\`" indicates that the expansion should include the escape sequence \" . For example:
`define msg(x,y) `"x: `\`"y`\`"`"
An example of using this `msg macro is:
$display(`msg(left side,right side));
The preceding example expands to:
$display("left side: \"right side\"");
A `` delimits lexical tokens without introducing white space, allowing identifiers to be constructed from arguments. For example:
`define append(f) f``_master
An example of using this `append macro is:
`append(clock)
This example expands to:
clock_master
The `include directive can be followed by a macro, instead of a string literal:`define home(filename) `"/home/mydir/filename`"
`include `home(myfile)
i paraphrase from the above link, and pay attention to the so called token identifier in systemverilog:
Quote:
So this means if i just use ``I , the expansion of macro `abc(1,a) would be :
assign abc[1] == R.duI_clk_x . Since its not defined as a separate token ??
Yes, that would be the result.
Quote:
Both R and I are arguments to the macro so why you say that no ``R`` is needed where as ``I`` is needed. Is it because the left hand side has no dependency on R or is it because R is not breaking the lexical variable ?
Correct again. What you call a lexical variable is what the compiler calls a token identifier. The compiler grabs text in chunks called tokens, before it knows what the identifier is (variable, typedef, module name). An identifier starts with a letter, followed by any number of alpha-numeric characters, as well as _(underscore). Any other character ends the token.
Quote:
So here ``I`` is not used, why ?
Only [I] is needed because I is surrounded by characters that are not part of token identifiers.
I think the issue comes when the macros are used with generate loop.
The complete code is :
`define WB_DUT_U_ASSIGN(phy_i,idx)\
assign b[phy_i] = `DUT_PATH.Ilane``idx``.a;\
genvar wb
generate
for(wb=0;wb<8;wb++) begin:wb_a
`WB_DUT_U_ASSIGN(wb,wb)
end
endgenerate
Macros are preprocessor directives. There are expanded before parsing any Verilog/SystemVerilog syntax.
In reply to
kvssrohit: As I said
before, macros get expanded as text for any generate processing. `dev_(i) gets expanded as top.i.XXX
The only way to achieve what you want withing SystemVerilog is to restructure your instance names into an array and access them with proper indexing. top[i].
Otherwise there are other macro processing tools that you can use to generate the identifier names you are looking for. But that becomes quite a maintenance headache.
genvar i;
for (i=0; i<=31; i=i+1) begin: gen_force
initial
force top[i].zzz = 1'b1;
end
I don't think you will be able to do mix compiler time defines with run-time variables. There is no space/tab to distinguish between 2 lexical tokens(VAR ,str_var). When you put space the expression will become illegal.
You can use parameterized macro but you cannot use a variable while calling it.
