def make_constructor(self,obj,name,parent=None,InOut_Filter=None, VaribleSignalFilter = None ):
primary = hdl.get_primary_object(obj)
TypeName = hdl.get_type_simple(primary)
member = primary.getMember()
VariableList = " variable ret : " + TypeName+ " := " + TypeName +"_null;"
name = TypeName +"_ctr"
fl = flat_member_list(primary, [])
Constructor_Default_arguments=self.get_constroctor_default_list(obj)
argList = [
join_str(x["name"],Delimeter="_") + " : integer := " + str(value(x["symbol"]))
for x in Constructor_Default_arguments
]
Argliststr = join_str(argList,Delimeter="; ",IgnoreIfEmpty=True)
body= [
" ret." + join_str(x["name"],Delimeter=".") + " := "+ hdl.get_type_simple(x["symbol"]) + "_ctr(" + join_str(x["name"],Delimeter="_") +");\n"
for x in Constructor_Default_arguments
]
body = join_str(body,IgnoreIfEmpty=True)
body += " return ret;\n"
func = v_function(body=body, returnType=TypeName, argumentList=Argliststr,VariableList=VariableList,name=name,IsEmpty=False,isFreeFunction=True)
setattr(parent, name, func)
def getHeader_make_record(self,obj, name, parent=None, InOut_Filter=None, VaribleSignalFilter = None):
TypeName = hdl.get_type_simple(obj)
member = obj.getMember()
start= "\ntype "+TypeName+" is record \n"
end= """end record;
{Default}
type {TypeName}_a is array (natural range <>) of {TypeName};
""".format(
Default = obj.__hdl_converter__.make_constant(
obj,
TypeName + "_null" ,
parent,
InOut_Filter,
VaribleSignalFilter
),
TypeName=TypeName
)
Content = [
hdl.recordMember(x["symbol"],x["name"],obj,InOut_Filter)
for x in member
]
ret=join_str(Content,start= start ,end= end, IgnoreIfEmpty=True,LineEnding=";\n", LineBeginning=" ")
self.make_constructor( obj,
TypeName + "_null" ,
parent,
InOut_Filter,
VaribleSignalFilter)
return ret
def def_def_record_Member(self, obj, name, parent, Inout=None):
if parent._issubclass_("v_class"):
if obj._Inout == InOut_t.Slave_t:
Inout = InoutFlip(Inout)
return name + " : " + hdl.get_type_simple(obj)
return ""
def get_SelfPush(self):
members_args = []
if not self.PushPull == "push":
return members_args
varsig = " signal "
i_members = self.obj.__hdl_converter__.get_internal_connections(
self.obj)
for m in i_members:
internal_inout_filter = InoutFlip_if(self.InOut_Filter,
m["type"] == 'sig2var')
sig = m["source"][
"symbol"].__hdl_converter__.extract_conversion_types(
m["source"]["symbol"],
exclude_class_type=v_classType_t.transition_t,
filter_inout=internal_inout_filter)
type_name = hdl.get_type_simple(sig[0]["symbol"])
members_args.append(varsig + "self_sig_" + m["source"]["name"] +
sig[0]["suffix"] + " : out " + type_name +
self.suffix)
return members_args
def impl_process_header(self, obj):
if obj._Inout != InOut_t.Internal_t:
return ""
if obj._varSigConst != varSig.variable_t:
return ""
VarSymb = get_varSig(obj._varSigConst)
return VarSymb + " " + str(obj) + " : " + hdl.get_type_simple(
obj) + " := " + obj._type(value(obj.symbol)).name + ";\n"
def _vhdl__DefineSymbol(self, obj ,VarSymb=None):
print_cnvt("_vhdl__DefineSymbol is deprecated")
VarSymb = VarSymb if VarSymb else get_varSig(obj._varSigConst)
if obj.__Driver__ and str( obj.__Driver__) != 'process':
return ""
TypeName = hdl.get_type_simple(obj)
return VarSymb +" " +str(obj) + " : " + TypeName +" := " + obj.__hdl_converter__.get_init_values(obj) +";\n"
def impl_symbol_instantiation(self, obj, VarSymb=None):
print_cnvt("impl_symbol_instantiation is deprecated")
VarSymb = VarSymb if VarSymb else get_varSig(obj._varSigConst)
if obj.__Driver__ and str(obj.__Driver__) != 'process':
return ""
TypeName = hdl.get_type_simple(obj)
return VarSymb + " " + str(
obj) + " : " + TypeName + " := " + hdl.impl_constructor(
obj) + ";\n"
def get_packet_file_content(self, obj):
PackageName = hdl.get_type_simple(obj) + "_pack"
s = isConverting2VHDL()
set_isConverting2VHDL(True)
pack = argg_pack.v_package(PackageName,
sourceFile=obj.__srcFilePath__,
PackageContent=[obj])
fileContent = pack.to_string()
set_isConverting2VHDL(s)
return fileContent
def get_port_list(self, obj):
inout = hdl.get_Inout(self.symbol, obj)
if not (inout == InOut_t.input_t or inout == InOut_t.output_t):
return []
inoutstr = " : " + hdl.InOut_t2str2(self.symbol, inout) + " "
type_name = hdl.get_type_simple(self.symbol)
return [
hdl.get_HDL_name(self.symbol, obj, self.suffix) + inoutstr +
type_name + " := " +
hdl.get_init_values(obj=obj, parent=self.symbol)
]
def includes(self,obj, name,parent):
ret = ""
for x in obj.__dict__.items():
t = getattr(obj, x[0])
if issubclass(type(t),argg_hdl_base):
ret += hdl.includes(t,x[0],obj)
for x in obj.__hdl_converter__.__ast_functions__:
ret += hdl.includes(x,None,obj)
ret += "use work."+ hdl.get_type_simple(obj)+"_pack.all;"
return ret
def def_packet_header(self, obj, name, parent):
if parent and parent._issubclass_("v_class"):
return ""
# type T_STATE is (RESET, START, EXECUTE, FINISH);
name = hdl.get_type_simple(obj)
enumNames = [e.name for e in obj._type]
start = ""
ret = "\n type " + name + " is ( \n "
for x in enumNames:
ret += start + x
start = ",\n "
ret += "\n );\n\n"
return ret
def make_constant(self, obj, name,parent=None,InOut_Filter=None, VaribleSignalFilter = None):
TypeName = hdl.get_type_simple(obj)
member = obj.getMember()
defaults = obj.__hdl_converter__.get_init_values(
obj=obj,
parent=parent,
InOut_Filter=InOut_Filter,
VaribleSignalFilter=VaribleSignalFilter,
ForceExpand=True
)
if not defaults.strip():
return ""
ret = "\n constant " + name + " : " + TypeName + ":= " + defaults +';\n'
return ret
def get_process_header(self, obj):
if self.symbol.__v_classType__ == v_classType_t.transition_t:
return []
if obj._Inout != InOut_t.Internal_t and not obj.__isInst__:
return []
if obj._varSigConst == varSig.combined_t and self.symbol._varSigConst == varSig.signal_t:
return []
if obj._varSigConst == varSig.signal_t:
return []
type_name = hdl.get_type_simple(self.symbol)
return [
"variable " + hdl.get_HDL_name(self.symbol, obj, self.suffix) +
" : " + type_name + " := " +
hdl.get_init_values(obj=obj, parent=self.symbol) + ";\n"
]
def impl_get_init_values(self,
obj,
parent=None,
InOut_Filter=None,
VaribleSignalFilter=None,
ForceExpand=False):
primary = hdl.get_primary_object(obj)
if ForceExpand:
member = obj.getMember()
Content = [
hdl.def_record_Member_Default(x["symbol"], x["name"],
obj.getMember(name=x["name"]),
InOut_Filter) for x in member
]
start = "(\n"
ret = join_str(Content,
start=start,
end="\n )",
Delimeter=",\n",
LineBeginning=" ",
IgnoreIfEmpty=True)
return ret
TypeName = hdl.get_type_simple(parent)
name = TypeName + "_ctr"
Constructor_Default_arguments = self.get_constroctor_default_list(obj)
fl = flat_member_list(obj, [])
# print(name, Constructor_Default_arguments, fl)
argList = [
join_str(x["name"], Delimeter="_") + " => " +
str(value(x["symbol"])) for i, x in enumerate(fl)
if not x["symbol"].__abstract_type_info__.UseDefaultCtr
if len(Constructor_Default_arguments) > i and value(x["symbol"]) !=
value(Constructor_Default_arguments[i]["symbol"])
]
Argliststr = join_str(argList,
Delimeter=", ",
IgnoreIfEmpty=True,
start="(",
end=")")
ret = name + Argliststr
return ret
def get_Self(self):
members_args = []
if not self.IncludeSelf:
return members_args
xs = self.obj.__hdl_converter__.extract_conversion_types(self.obj)
for x in xs:
isSignal = x["symbol"]._varSigConst == varSig.signal_t
varsig = if_true_get_first(isSignal, [" signal ", " "])
self_InOut = " inout "
type_name = hdl.get_type_simple(x["symbol"])
members_args.append(varsig + "self" + x["suffix"] + " : " +
self_InOut + " " + type_name + self.suffix)
members_args += self.get_SelfPush()
return members_args
def to_arglist(self,obj, name,parent, withDefault = False, astParser=None):
ret = []
xs = hdl.extract_conversion_types(obj)
for x in xs:
inoutstr = " inout " # fixme
varSignal = "" if x["symbol"]._varSigConst == varSig.variable_t else " Signal "
Default_str = " := " + hdl.get_default_value(obj) \
if withDefault and obj.__writeRead__ != InOut_t.output_t and obj._Inout != InOut_t.output_t \
else ""
TypeName = hdl.get_type_simple(x["symbol"])
ret.append(varSignal + name + x["suffix"] + " : " + inoutstr +" " + TypeName +Default_str)
r =join_str(ret,Delimeter="; ",IgnoreIfEmpty=True)
return r
def extract_primitive_records(obj):
ret = []
ts = hdl.extract_conversion_types(obj)
for t in ts:
name = hdl.get_type_simple(obj)
suffix = t["suffix"]
record_obj = get_Constructor("v_data_record")(name + suffix,
t["symbol"]._varSigConst)
record_obj._Inout = t["symbol"]._Inout if len(
ts) > 1 else InOut_t.Default_t
members = t["symbol"].getMember()
record_obj.__v_classType__ = t["symbol"].__v_classType__
record_obj.__abstract_type_info__.vetoHDLConversion = True
for x in members:
if x["symbol"].__isFreeType__:
continue
setattr(record_obj, x["name"], x["symbol"])
ret.append(extracted_record_t(record_obj, t["suffix"]))
return ret
def __str__(self):
members_args = self.get_Self()
members = self.obj.getMember(self.InOut_Filter)
for i in members:
n_connector = _get_connector(i["symbol"])
xs = i["symbol"].__hdl_converter__.extract_conversion_types(
i["symbol"],
exclude_class_type=v_classType_t.transition_t,
filter_inout=self.InOut_Filter)
for x in xs:
varsig = " "
if n_connector._varSigConst == varSig.signal_t:
varsig = " signal "
type_name = hdl.get_type_simple(x["symbol"])
members_args.append(varsig + i["name"] + " : " + self.InOut +
" " + type_name + self.suffix)
ret = join_str(members_args, Delimeter="; ")
return ret
def get_packet_file_content(self, obj):
h1 = hdl.def_packet_header(obj, None, None)
PackageName = hdl.get_type_simple(obj) + "_pack"
fileContent = """
library IEEE;
library work;
use IEEE.numeric_std.all;
use IEEE.std_logic_1164.all;
use ieee.std_logic_unsigned.all;
use work.argg_hdl_core.all;
package {PackageName} is
{pack}
end {PackageName};
package body {PackageName} is
end {PackageName};
""".format(PackageName=PackageName, pack=h1)
return fileContent
def get_Name_array(self,obj):
return hdl.get_type_simple(obj)+"_a"
def get_packet_file_name(self, obj):
return hdl.get_type_simple(obj) + "_pack.vhd"
def def_includes(self, obj, name, parent):
PackageName = hdl.get_type_simple(obj) + "_pack"
return " use work." + PackageName + ".all;\n"
def impl_constructor(self,obj):
return hdl.get_type_simple(obj)+"_ctr(" +value(obj)+")"
