Comments on: Casting Strings to Enums in SystemVerilog http://www.verilab.com/blog/2007/10/casting-strings-to-enums-in-systemverilog/ Verilab Thu, 17 May 2012 19:34:17 +0000 http://wordpress.org/?v=2.6.1 By: JL Gray http://www.verilab.com/blog/2007/10/casting-strings-to-enums-in-systemverilog/#comment-148 JL Gray Wed, 28 Nov 2007 19:25:14 +0000 http://www.verilab.com/blog/2007/10/casting-strings-to-enums-in-systemverilog/#comment-148 Avidan, I just looked again at your example... it actually *requires* parameterizable classes (I missed that the first time I read through the code). For that reason, the code won't work with VCS, though it should work just fine with Modelsim. JL Avidan,

I just looked again at your example… it actually *requires* parameterizable classes (I missed that the first time I read through the code). For that reason, the code won’t work with VCS, though it should work just fine with Modelsim.

JL

]]> By: JL Gray http://www.verilab.com/blog/2007/10/casting-strings-to-enums-in-systemverilog/#comment-145 JL Gray Mon, 22 Oct 2007 13:52:24 +0000 http://www.verilab.com/blog/2007/10/casting-strings-to-enums-in-systemverilog/#comment-145 Avidan, You're right, there are some significant issues with enums in SV. However, though I haven't tried writing the code, I believe you could simplify things slightly in your example above by using parameterizable classes. JL Avidan,

You’re right, there are some significant issues with enums in SV. However, though I haven’t tried writing the code, I believe you could simplify things slightly in your example above by using parameterizable classes.

JL

]]> By: Avidan Efody http://www.verilab.com/blog/2007/10/casting-strings-to-enums-in-systemverilog/#comment-144 Avidan Efody Mon, 22 Oct 2007 08:22:55 +0000 http://www.verilab.com/blog/2007/10/casting-strings-to-enums-in-systemverilog/#comment-144 Hi JL, Your entry touched a raw SV nerve :-). I guess your intention was to demonstrate the use of hashes and to provide everyone with a useful function, but on the way you also demonstrated one of SV's enums main shortcomings - although all enums have a similar behavior and share a basic set of functions, there is no such thing as "enum base class", that is common to all of them. So, in the case above, although your function might be useful for every enum, you would have to rewrite it for each different enum type... I have come across this problem in the past as well...One way of working around it, which is not perfect, is to define a class that wrapps around enums. Here's your example rewritten (without the hash, just using brute force method): virtual class enum_wrapper; // functions defined by the standard go here. // these are implemented by the specification virtual function int first();endfunction virtual function int last();endfunction virtual function int next(int current);endfunction virtual function int prev(int current);endfunction virtual function int num();endfunction virtual function string name(int value);endfunction // more user defined functions go here // here's a brute force method for searching... // could be made more efficient by adding the hash... function int string_to_enum(string enum_name); for (int i=first(); i!=last(); i=next(i)) if (enum_name == name(i)) return i; endfunction // int endclass // enum_wrapper // just a garbage enum for default typedef enum {false, true} bool; class specific_enum#(type enum_type = bool) extends enum_wrapper; enum_type m_enum; function int first(); first = m_enum.first(); endfunction; // int function int last(); last = m_enum.last(); endfunction; // int function int next(int current); m_enum = enum_type'(current); next = m_enum.next(); endfunction; // int function int prev(int current); m_enum = enum_type'(current); prev = m_enum.prev(); endfunction; // int function int num(); num = m_enum.num(); endfunction; // int function string name(int value); m_enum = enum_type'(value); name = m_enum.name(); endfunction; // int endclass // specific_enum typedef enum {UNKNOWN, ADD, SUB, MULT} cmd_e; module test; initial begin string cmd_name = "ADD"; specific_enum#(cmd_e) temp = new(); $display("The int value for string %s is %d", cmd_name, temp.string_to_enum(cmd_name)); end endmodule The disadvantage is that you have to define a class instance for the enum wrapper. The advantage is you could have a full library of such enum utilities written only once... Avidan Hi JL,
Your entry touched a raw SV nerve :-). I guess your intention was to demonstrate the use of hashes and to provide everyone with a useful function, but on the way you also demonstrated one of SV’s enums main shortcomings - although all enums have a similar behavior and share a basic set of functions, there is no such thing as “enum base class”, that is common to all of them. So, in the case above, although your function might be useful for every enum, you would have to rewrite it for each different enum type…
I have come across this problem in the past as well…One way of working around it, which is not perfect, is to define a class that wrapps around enums. Here’s your example rewritten (without the hash, just using brute force method):

virtual class enum_wrapper;
// functions defined by the standard go here.
// these are implemented by the specification
virtual function int first();endfunction
virtual function int last();endfunction
virtual function int next(int current);endfunction
virtual function int prev(int current);endfunction
virtual function int num();endfunction
virtual function string name(int value);endfunction

// more user defined functions go here
// here’s a brute force method for searching…
// could be made more efficient by adding the hash…

function int string_to_enum(string enum_name);
for (int i=first(); i!=last(); i=next(i))
if (enum_name == name(i)) return i;
endfunction // int

endclass // enum_wrapper

// just a garbage enum for default
typedef enum {false, true} bool;

class specific_enum#(type enum_type = bool) extends enum_wrapper;
enum_type m_enum;

function int first();
first = m_enum.first();
endfunction; // int

function int last();
last = m_enum.last();
endfunction; // int

function int next(int current);
m_enum = enum_type’(current);
next = m_enum.next();
endfunction; // int

function int prev(int current);
m_enum = enum_type’(current);
prev = m_enum.prev();
endfunction; // int

function int num();
num = m_enum.num();
endfunction; // int

function string name(int value);
m_enum = enum_type’(value);
name = m_enum.name();
endfunction; // int
endclass // specific_enum

typedef enum {UNKNOWN, ADD, SUB, MULT} cmd_e;

module test;
initial begin
string cmd_name = “ADD”;
specific_enum#(cmd_e) temp = new();

$display(”The int value for string %s is %d”, cmd_name, temp.string_to_enum(cmd_name));
end
endmodule

The disadvantage is that you have to define a class instance for the enum wrapper. The advantage is you could have a full library of such enum utilities written only once…

Avidan

]]>