public static ModellingType CreateType(ISubtypeIndication si)
{
if (si is ResolvedSubtypeIndication)
{
ModellingType res = CreateType((si as ResolvedSubtypeIndication).BaseType);
res.Constraints.Add(new ResolvedTypeConstraint(si as ResolvedSubtypeIndication));
return(res);
}
if (si is RangeSubtypeIndication)
{
ModellingType res = CreateType((si as RangeSubtypeIndication).BaseType);
res.Constraints.Add(new RangeTypeConstraint(si as RangeSubtypeIndication));
return(res);
}
if (si is IndexSubtypeIndication)
{
ModellingType res = CreateType((si as IndexSubtypeIndication).BaseType);
res.Constraints.Add(new IndexTypeConstraint(si as IndexSubtypeIndication));
return(res);
}
if (si is Subtype)
{
return(CreateType((si as Subtype).SubtypeIndication));
}
if (si is IntegerType)
{
return(ModellingType.CreateModellingType(si as IntegerType));
}
if (si is RealType)
{
return(ModellingType.CreateModellingType(si as RealType));
}
if (si is PhysicalType)
{
return(ModellingType.CreateModellingType(si as PhysicalType));
}
if (si is RecordType)
{
return(ModellingType.CreateModellingType(si as RecordType));
}
if (si is EnumerationType)
{
return(ModellingType.CreateModellingType(si as EnumerationType));
}
if (si is UnconstrainedArray)
{
return(ModellingType.CreateModellingType(si as UnconstrainedArray));
}
if (si is ConstrainedArray)
{
return(ModellingType.CreateModellingType(si as ConstrainedArray));
}
return(null);
}
public ResolvedDiscreteRange [] ResolveRange(SubtypeDiscreteRange range)
{
ModellingType modelType = TypeCreator.CreateType(range.SubtypeIndication);
if (modelType != null)
{
return(modelType.ResolvedRange);
}
return(null);
}
/// <summary>
/// Создание ModellingType
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static ModellingType CreateModellingType(Type type)
{
foreach (ModellingType t in CreatedTypes)
{
if (t.type == type)
{
return(t);
}
}
ModellingType res = new ModellingType(type);
CreatedTypes.Add(res);
return(res);
}
/// <summary>
/// Создание ModellingType
/// </summary>
/// <param name="type"></param>
/// <param name="constraints"></param>
/// <returns></returns>
public static ModellingType CreateModellingType(Type type, List <AbstractConstraint> constraints)
{
foreach (ModellingType t in CreatedTypes)
{
if ((t.type == type) && (ArraysEqual(t.constraints, constraints)))
{
return(t);
}
}
ModellingType res = new ModellingType(type, constraints);
CreatedTypes.Add(res);
return(res);
}
/// <summary>
/// Создание ModellingType
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static ModellingType CreateModellingType(ArrayType type, List <AbstractConstraint> constraints, ResolvedDiscreteRange[] dimension)
{
foreach (ModellingType t in CreatedTypes)
{
if ((t.type == type) && (ArraysEqual(t.constraints, constraints)) && (ArraysEqual(t.dimension, dimension)))
{
return(t);
}
}
ModellingType res = new ModellingType(type, constraints, dimension);
CreatedTypes.Add(res);
return(res);
}
private static Signal CreateUnconstrainedArraySignal(string name, IndexSubtypeIndication si)
{
if (si.BaseType is UnconstrainedArray)
{
UnconstrainedArray arrayType = si.BaseType as UnconstrainedArray;
List <ResolvedDiscreteRange> resolvedRanges = new List <ResolvedDiscreteRange>();
foreach (DiscreteRange r in si.Ranges)
{
if (r is Range)
{
int from = (ExpressionEvaluator.DefaultEvaluator.Evaluate((r as Range).From) as IntegerValue).Value;
int to = (ExpressionEvaluator.DefaultEvaluator.Evaluate((r as Range).To) as IntegerValue).Value;
ResolvedDiscreteRange newRange = ResolvedDiscreteRange.FormIntegerIndexes(from, to);
resolvedRanges.Add(newRange);
}
}
ModellingType resType = ModellingType.CreateModellingType(arrayType, resolvedRanges.ToArray());
resType.Constraints.Add(new IndexTypeConstraint(si));
List <AbstractSignalDump> dumps = new List <AbstractSignalDump>();
List <Signal> childrens = new List <Signal>();
int[,] resIndexes = ResolvedDiscreteRange.CombineRanges(resolvedRanges.ToArray());
for (int i = 0; i < resIndexes.GetLength(0); i++)
{
for (int j = 0; j < resIndexes.GetLength(1); j++)
{
Signal newSignal = CreateSignal(resolvedRanges[j][resIndexes[i, j]].ToString(), arrayType.IndexSubtypes[j]);
childrens.Add(newSignal);
dumps.Add(newSignal.Dump);
}
}
SignalScopeDump resDump = new SignalScopeDump(name, resType, dumps);
Signal resSignal = new Signal(resDump);
return(resSignal);
}
return(null);
}
/// <summary>
/// Получение настроек генератора по заданному модельному типу данных
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static GeneratorSettings GetGeneratorSettings(ModellingType type)
{
if (type.type is IntegerType)
{
return(new GeneratorSettings(32, GeneratorSettings.GeneratedValue.IntegerValue | GeneratorSettings.GeneratedValue.DoubleValue | GeneratorSettings.GeneratedValue.BoolArray, GeneratorSettings.GeneratedValue.IntegerValue, new List <object>()));
}
if (type.type is RealType)
{
return(new GeneratorSettings(32, GeneratorSettings.GeneratedValue.DoubleValue, GeneratorSettings.GeneratedValue.IntegerValue | GeneratorSettings.GeneratedValue.DoubleValue | GeneratorSettings.GeneratedValue.BoolArray, new List <object>()));
}
if (type.type is EnumerationType)
{
return(new GeneratorSettings(1, GeneratorSettings.GeneratedValue.EnumerableValue, GeneratorSettings.GeneratedValue.EnumerableValue, new List <object>((type.type as EnumerationType).Literals)));
}
if ((type.type == VHDL.builtin.StdLogic1164.STD_LOGIC_VECTOR) || (type.type == VHDL.builtin.StdLogic1164.STD_ULOGIC_VECTOR) || (type.type == VHDL.builtin.Standard.BIT_VECTOR))
{
return(new GeneratorSettings((uint)type.Dimension[0].Length, GeneratorSettings.GeneratedValue.IntegerValue | GeneratorSettings.GeneratedValue.DoubleValue | GeneratorSettings.GeneratedValue.BoolArray, GeneratorSettings.GeneratedValue.BoolArray));
}
return(null);
}
public static Signal CreateSignal(string name, ISubtypeIndication si)
{
if (si is ResolvedSubtypeIndication)
{
Signal res = CreateSignal(name, (si as ResolvedSubtypeIndication).BaseType);
return(res);
}
if (si is RangeSubtypeIndication)
{
Signal res = CreateSignal(name, (si as RangeSubtypeIndication).BaseType);
return(res);
}
if (si is IndexSubtypeIndication)
{
Signal res = CreateUnconstrainedArraySignal(name, si as IndexSubtypeIndication);
return(res);
}
if (si is Subtype)
{
return(CreateSignal(name, (si as Subtype).SubtypeIndication));
}
if (si is IntegerType)
{
ModellingType resType = ModellingType.CreateModellingType(si as IntegerType);
IntegerAbstractValueConvertor conv = new IntegerAbstractValueConvertor(resType);
AbstractSimpleSignalDump <int> resDump = new AbstractSimpleSignalDump <int>(name, resType, conv);
Signal resSignal = new Signal(resDump);
return(resSignal);
}
if (si is RealType)
{
ModellingType resType = ModellingType.CreateModellingType(si as RealType);
RealAbstractValueConvertor conv = new RealAbstractValueConvertor(resType);
AbstractSimpleSignalDump <double> resDump = new AbstractSimpleSignalDump <double>(name, resType, conv);
Signal resSignal = new Signal(resDump);
return(resSignal);
}
if (si is PhysicalType)
{
ModellingType resType = ModellingType.CreateModellingType(si as PhysicalType);
PhysicalAbstractValueConvertor conv = new PhysicalAbstractValueConvertor(resType);
AbstractSimpleSignalDump <PhysicalLiteral> resDump = new AbstractSimpleSignalDump <PhysicalLiteral>(name, resType, conv);
Signal resSignal = new Signal(resDump);
return(resSignal);
}
if (si is RecordType)
{
RecordType recType = si as RecordType;
ModellingType resType = ModellingType.CreateModellingType(recType);
List <AbstractSignalDump> dumps = new List <AbstractSignalDump>();
List <Signal> childrens = new List <Signal>();
foreach (var el in recType.Elements)
{
foreach (string s in el.Identifiers)
{
Signal newSignal = CreateSignal(s, el.Type);
childrens.Add(newSignal);
dumps.Add(newSignal.Dump);
}
}
SignalScopeDump resDump = new SignalScopeDump(name, resType, dumps);
Signal resSignal = new Signal(resDump);
return(resSignal);
}
if (si is EnumerationType)
{
ModellingType resType = ModellingType.CreateModellingType(si as EnumerationType);
EnumerationAbstractValueConvertor conv;
if (si == StdLogic1164.STD_ULOGIC)
{
conv = new STD_ULOGIC_AbstractValueConvertor(resType);
}
else
{
if (si == StdLogic1164.STD_LOGIC)
{
conv = new STD_LOGIC_AbstractValueConvertor(resType);
}
else
{
conv = new EnumerationAbstractValueConvertor(resType);
}
}
AbstractSimpleSignalDump <EnumerationLiteral> resDump = new AbstractSimpleSignalDump <EnumerationLiteral>(name, resType, conv);
Signal resSignal = new Signal(resDump);
return(resSignal);
}
if (si is ConstrainedArray)
{
ConstrainedArray arrayType = si as ConstrainedArray;
ModellingType resType = ModellingType.CreateModellingType(arrayType);
List <AbstractSignalDump> dumps = new List <AbstractSignalDump>();
List <Signal> childrens = new List <Signal>();
ResolvedDiscreteRange[] ranges = resType.Dimension;
int[,] resIndexes = ResolvedDiscreteRange.CombineRanges(ranges);
for (int i = 0; i < resIndexes.GetLength(0); i++)
{
for (int j = 0; j < resIndexes.GetLength(1); j++)
{
Signal newSignal = CreateSignal(ranges[j][resIndexes[i, j]].ToString(), arrayType.ElementType);
childrens.Add(newSignal);
dumps.Add(newSignal.Dump);
}
}
SignalScopeDump resDump = new SignalScopeDump(name, resType, dumps);
Signal resSignal = new Signal(resDump);
return(resSignal);
}
return(null);
}
/// <summary>
/// Используется для объединения дельтациклов в один объект TimeStampInfo
/// </summary>
/// <param name="elements"></param>
/// <returns></returns>
public static TimeStampInfo CombineTimestamps(ModellingType groupModellingType, IList <TimeStampInfo> elements)
{
TimeStampInfo res = new TimeStampInfo();
List <AbstractValue> values = new List <AbstractValue>();
List <TimeStampInfoIterator> iterators = new List <TimeStampInfoIterator>();
int currentDeltaCycle = int.MaxValue;
foreach (TimeStampInfo inf in elements)
{
if (inf != null)
{
values.Add(inf[0]);
iterators.Add(new TimeStampInfoIterator(inf));
if (inf.ElementAt(0).Key < currentDeltaCycle)
{
currentDeltaCycle = inf.ElementAt(0).Key;
}
}
}
bool IsDone = false;
while (IsDone == false)
{
IsDone = true;
foreach (TimeStampInfoIterator i in iterators)
{
if (i.IsDone == false)
{
IsDone = false;
break;
}
}
if (IsDone == true)
{
break;
}
currentDeltaCycle = int.MaxValue;
foreach (TimeStampInfoIterator i in iterators)
{
if ((i.IsDone == false) && (i.Current.Key < currentDeltaCycle))
{
currentDeltaCycle = i.Current.Key;
}
}
CompositeValue compValue = CompositeValue.CreateCompositeValue(groupModellingType, values);
res.info.Add(currentDeltaCycle, compValue);
for (int i = 0; i < iterators.Count; i++)
{
TimeStampInfoIterator iter = iterators[i];
if (iter.Current.Key == currentDeltaCycle)
{
iter.MoveNext();
values[i] = iter.Current.Value;
}
}
}
return(res);
}
/// <summary>
/// Используется для объединения дельтациклов в один объект TimeStampInfo
/// </summary>
/// <param name="elements"></param>
/// <returns></returns>
public static TimeStampInfo CombineTimestamps(ModellingType groupModellingType, params TimeStampInfo[] elements)
{
return(CombineTimestamps(groupModellingType, new List <TimeStampInfo>(elements)));
}
/// <summary>
/// Используется для разделения информации о моменте времени составного типа
/// на набор информаций об момоенте времени его составляющих
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
public static List <TimeStampInfo> SplitTimestamps(ModellingType groupModellingType, TimeStampInfo info)
{
if (groupModellingType.Type is VHDL.type.RecordType)
{
List <TimeStampInfo> res = new List <TimeStampInfo>();
foreach (var el in (groupModellingType.Type as VHDL.type.RecordType).Elements)
{
foreach (string s in el.Identifiers)
{
res.Add(new TimeStampInfo());
}
}
foreach (var val in info)
{
if (val.Value is CompositeValue)
{
int index = 0;
foreach (AbstractValue v in (val.Value as CompositeValue).GetChilds())
{
if ((res[index].Count == 0) || (res[index].LastValue != v))
{
res[index].info.Add(val.Key, v);
}
index++;
}
}
else
{
throw new ArgumentException("Invalid type", "info");
}
}
return(res);
}
if (groupModellingType.Type is VHDL.type.ArrayType)
{
List <TimeStampInfo> res = new List <TimeStampInfo>();
for (int i = 0; i < groupModellingType.SizeOf; i++)
{
res.Add(new TimeStampInfo());
}
foreach (var val in info)
{
if (val.Value is CompositeValue)
{
int index = 0;
foreach (AbstractValue v in (val.Value as CompositeValue).GetChilds())
{
if ((res[index].Count == 0) || (res[index].LastValue != v))
{
res[index].info.Add(val.Key, v);
}
index++;
}
}
else
{
throw new ArgumentException("Invalid type", "info");
}
}
return(res);
}
throw new ArgumentException("Invalid type", "groupModellingType");
}
