/// <summary>
/// Finds the length of an array type-signal
/// </summary>
/// <returns>The array length.</returns>
/// <param name="element">The element to get the length for.</param>
public AST.Constant GetArrayLength(AST.DataElement element)
{
if (element.CecilType.IsFixedArrayType())
{
if (element.Source is IMemberDefinition)
{
return(new Constant
{
Source = element,
DefaultValue = ((IMemberDefinition)element.Source).GetFixedArrayLength(),
CecilType = element.CecilType.LoadType(typeof(uint))
});
}
else if (element.Source is System.Reflection.MemberInfo)
{
return(new Constant
{
Source = element,
DefaultValue = ((System.Reflection.MemberInfo)element.Source).GetFixedArrayLength(),
CecilType = element.CecilType.LoadType(typeof(uint))
});
}
}
if (element.DefaultValue is Array)
{
return(new Constant()
{
Source = element,
DefaultValue = (element.DefaultValue as Array).Length,
CecilType = element.CecilType.LoadType(typeof(uint))
});
}
throw new Exception($"Unable to guess length for signal: {element.Name}");
}
/// <summary>
/// Gets the initializer statement, if any.
/// </summary>
/// <returns>The initializer.</returns>
/// <param name="element">The variable to get the initializer for.</param>
public string GetInitializer(AST.DataElement element)
{
if (element.DefaultValue == null)
{
return(string.Empty);
}
if (element.DefaultValue is AST.ArrayCreateExpression)
{
var asexp = (AST.ArrayCreateExpression)element.DefaultValue;
var nae = new ArrayCreateExpression()
{
SourceExpression = asexp.SourceExpression,
SourceResultType = asexp.SourceResultType,
};
nae.ElementExpressions = asexp.ElementExpressions
.Select(x => new PrimitiveExpression()
{
SourceExpression = x.SourceExpression,
SourceResultType = x.SourceResultType,
Parent = nae,
Value = ((PrimitiveExpression)x).Value
}).Cast <Expression>().ToArray();
return(RenderExpression(nae));
}
else if (element.DefaultValue is Array)
{
var arr = (Array)element.DefaultValue;
var nae = new ArrayCreateExpression()
{
SourceExpression = null,
SourceResultType = element.CecilType.GetArrayElementType(),
};
nae.ElementExpressions = Enumerable.Range(0, arr.Length)
.Select(x => new PrimitiveExpression()
{
SourceExpression = null,
SourceResultType = element.CecilType.GetArrayElementType(),
Parent = nae,
Value = arr.GetValue(0)
}).Cast <Expression>().ToArray();
return(RenderExpression(nae));
}
else if (element.DefaultValue is ICSharpCode.Decompiler.CSharp.Syntax.AstNode)
{
var eltype = Type.GetType(element.CecilType.FullName);
var defaultvalue = eltype != null && element.CecilType.IsValueType ? Activator.CreateInstance(eltype) : null;
return(RenderExpression(new AST.PrimitiveExpression()
{
Value = defaultvalue,
SourceResultType = element.CecilType
}));
}
else if (element.DefaultValue is AST.EmptyArrayCreateExpression)
{
var ese = element.DefaultValue as AST.EmptyArrayCreateExpression;
return(RenderExpression(new AST.EmptyArrayCreateExpression()
{
SizeExpression = ese.SizeExpression.Clone(),
SourceExpression = ese.SourceExpression,
SourceResultType = ese.SourceResultType
}));
}
else if (element.CecilType.IsArrayType() && element.DefaultValue == null)
{
return(RenderExpression(new EmptyArrayCreateExpression()
{
SourceExpression = null,
SourceResultType = element.CecilType,
SizeExpression = new MemberReferenceExpression()
{
Name = element.Name,
SourceExpression = null,
SourceResultType = element.CecilType,
Target = element
}
}));
}
else
{
return(RenderExpression(new AST.PrimitiveExpression()
{
Value = element.DefaultValue,
SourceResultType = element.CecilType
}));
}
}
/// <summary>
/// Gets the default value for an item, expressed as a VHDL expression
/// </summary>
/// <returns>The default value.</returns>
/// <param name="element">The element to get the default value for.</param>
public string DefaultValue(AST.DataElement element)
{
return(Parent.DefaultValue(element));
}
/// <summary>
/// Returns the VHDL type for a data element
/// </summary>
/// <returns>The VHDL type.</returns>
/// <param name="element">The element to get the type for.</param>
public VHDLType VHDLType(AST.DataElement element)
{
return(Parent.VHDLType(element));
}
/// <summary>
/// Gets the Cpp type for the signal
/// </summary>
/// <returns>The cpp type.</returns>
/// <param name="element">The input signal.</param>
public CppType GetType(AST.DataElement element)
{
return(GetType(element.CecilType));
}
public string Type(AST.DataElement el)
{
return(RS.TypeScope.GetType(el).Name);
}
