public ResolvedDiscreteRange ResolveSimpleRange(Range range) { int from = (int)(Evaluate(range.From) as IntegerValue).Value; int to = (int)(Evaluate(range.To) as IntegerValue).Value; return(ResolvedDiscreteRange.FormIntegerIndexes(from, to)); }
private ResolvedDiscreteRange[] GetResolvedRange() { if (type is EnumerationType) { int count = (type as EnumerationType).Literals.Count; return(new ResolvedDiscreteRange[] { ResolvedDiscreteRange.FormIntegerIndexes(1, count) }); } return(new ResolvedDiscreteRange[] { ResolvedDiscreteRange.Range1 }); }
/// <summary> /// Создание словаря по входным данным /// </summary> /// <param name="_value"></param> /// <param name="range"></param> /// <returns></returns> public static Dictionary <int[], AbstractValue> CreateDictionary(ResolvedDiscreteRange range) { Dictionary <int[], AbstractValue> res = new Dictionary <int[], AbstractValue>(); for (int i = 0; i <= range.Length; i++) { res.Add(new int[] { i }, null); } return(res); }
/// <summary> /// Создание словаря по входным данным /// </summary> /// <param name="_value"></param> /// <param name="range"></param> /// <returns></returns> private Dictionary <int[], AbstractValue> CreateDictionary(ResolvedDiscreteRange[] resolvedDiscreteRange) { int[,] ranges = ResolvedDiscreteRange.CombineRanges(resolvedDiscreteRange); Dictionary <int[], AbstractValue> res = new Dictionary <int[], AbstractValue>(); for (int i = 0; i <= ranges.GetLength(0); i++) { int[] indexes = new int[ranges.GetLength(1)]; for (int j = 0; j < ranges.GetLength(1); j++) { indexes[j] = ranges[i, j]; } res.Add(indexes, null); } return(res); }
public VCD_Variable(Signal var, string identifier) { this.base_variable = var; this.identifier = identifier; this.reference = var.Name; this._iterator = var.Dump.Iterator; _iterator.Reset(); //Определяем тип переменной string type = var.Type.Name; _iterator = var.Dump.Iterator; size = 1; switch (type.ToUpper()) { case "BIT": case "STD_ULOGIC": case "STD_LOGIC": var_type = VCDVariableType.Reg; break; case "BIT_VECTOR": case "STD_ULOGIC_VECTOR": case "STD_LOGIC_VECTOR": ResolvedDiscreteRange range = var.Type.Dimension[0]; startIndex = range.From; endIndex = range.To; size = (UInt32)(Math.Abs(endIndex - startIndex) + 1); var_type = VCDVariableType.Reg; break; case "INTEGER": var_type = VCDVariableType.Integer; size = 32; startIndex = 31; endIndex = 0; break; case "REAL": var_type = VCDVariableType.Real; break; default: break; } }
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="_value"></param> /// <param name="range"></param> /// <returns></returns> private Dictionary <int[], AbstractValue> CreateDictionary(IList <AbstractValue> _value, ResolvedDiscreteRange[] resolvedDiscreteRange) { int[,] ranges = ResolvedDiscreteRange.CombineRanges(resolvedDiscreteRange); if (_value.Count != ranges.GetLength(0)) { throw new Exception("Invalid length of list"); } Dictionary <int[], AbstractValue> res = new Dictionary <int[], AbstractValue>(); for (int i = 0; i < ranges.GetLength(0); i++) { int [] indexes = new int [ranges.GetLength(1)]; for (int j = 0; j < ranges.GetLength(1); j++) { indexes[j] = ranges[i, j]; } res.Add(indexes, _value[i]); } return(res); }
public STD_LOGIC_VECTOR_VALUE(IList <AbstractValue> _value, ResolvedDiscreteRange range) : base(_value, range) { }
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> /// Конструктор /// </summary> /// <param name="type"></param> public ArrayValue(VHDL.type.UnconstrainedArray type, ResolvedDiscreteRange range) : base(ModellingType.CreateModellingType(type, new ResolvedDiscreteRange[] { range })) { _values = CreateDictionary(range); }
/// <summary> /// Конструктор /// </summary> /// <param name="type"></param> public ArrayValue(VHDL.type.UnconstrainedArray type, Dictionary <int[], AbstractValue> dictionary) : base(ModellingType.CreateModellingType(type, new ResolvedDiscreteRange[] { ResolvedDiscreteRange.FormIntegerIndexes(dictionary.Count) })) { _values = dictionary; }
/// <summary> /// Конструктор /// </summary> /// <param name="type"></param> public ArrayValue(VHDL.type.UnconstrainedArray type, IList <AbstractValue> _value) : base(ModellingType.CreateModellingType(type, new ResolvedDiscreteRange[] { ResolvedDiscreteRange.FormIntegerIndexes(_value.Count) })) { _values = CreateDictionary(_value); }
/// <summary> /// Создание словаря по входным данным /// </summary> /// <param name="_value"></param> /// <param name="range"></param> /// <returns></returns> public static Dictionary <int[], AbstractValue> CreateDictionary(IList <AbstractValue> _value, ResolvedDiscreteRange range) { if (_value.Count != range.Length) { throw new Exception("Invalid length of list"); } Dictionary <int[], AbstractValue> res = new Dictionary <int[], AbstractValue>(); for (int i = 0; i <= range.Length; i++) { res.Add(new int[] { i }, _value[i]); } return(res); }
public BIT_VECTOR_VALUE(IList <AbstractValue> _value, ResolvedDiscreteRange range) : base(new ConstrainedArray("std_logic_vector", Standard.BIT, range.CreateRange()), _value, range) { }
public static VCD_Variable Parse(string[] Words) { VCD_Variable var = new VCD_Variable(); // var.var_type switch (Words[1].ToLower()) { case "event": var.var_type = VCDVariableType.Event; break; case "integer": var.var_type = VCDVariableType.Integer; break; case "parameter": var.var_type = VCDVariableType.Parameter; break; case "real": var.var_type = VCDVariableType.Real; break; case "reg": var.var_type = VCDVariableType.Reg; break; case "supply0": var.var_type = VCDVariableType.Supply0; break; case "supply1": var.var_type = VCDVariableType.Supply1; break; case "time": var.var_type = VCDVariableType.Time; break; case "tri": var.var_type = VCDVariableType.Tri; break; case "triand": var.var_type = VCDVariableType.Triand; break; case "trior": var.var_type = VCDVariableType.Trior; break; case "trireg": var.var_type = VCDVariableType.Trireg; break; case "tri0": var.var_type = VCDVariableType.Tri0; break; case "tri1": var.var_type = VCDVariableType.Tri1; break; case "wand": var.var_type = VCDVariableType.Wand; break; case "wire": var.var_type = VCDVariableType.Wire; break; case "wor": var.var_type = VCDVariableType.Wor; break; } var.size = uint.Parse(Words[2]); var.identifier = Words[3]; //Если встераем сложное имя переменной с учетом ее размерности if ((var.size != 1)) { if (Words[4].Contains(":")) { string[] temp = Words[4].Split(new char[] { ' ', '[', ']', ':' }); var.reference = temp[0]; bool parse_res = int.TryParse(temp[1], out var.startIndex); parse_res = int.TryParse(temp[2], out var.endIndex); } else { var.reference = Words[4]; var.endIndex = (int)var.size - 1; var.startIndex = 0; } } else { var.reference = Words[4]; } switch (var.VariableType) { case VCD_Variable.VCDVariableType.Integer: var.base_variable = TypeCreator.CreateSignal(var.Reference, VHDL.builtin.Standard.INTEGER); var.appendFunction = VCDConvertor.Append_Integer_VALUE; break; case VCD_Variable.VCDVariableType.Real: var.base_variable = TypeCreator.CreateSignal(var.Reference, VHDL.builtin.Standard.REAL); var.appendFunction = VCDConvertor.Append_Real_VALUE; break; case VCD_Variable.VCDVariableType.Time: break; case VCD_Variable.VCDVariableType.Event: case VCD_Variable.VCDVariableType.Parameter: case VCD_Variable.VCDVariableType.Reg: case VCD_Variable.VCDVariableType.Supply0: case VCD_Variable.VCDVariableType.Supply1: case VCD_Variable.VCDVariableType.Tri: case VCD_Variable.VCDVariableType.Tri0: case VCD_Variable.VCDVariableType.Tri1: case VCD_Variable.VCDVariableType.Triand: case VCD_Variable.VCDVariableType.Trior: case VCD_Variable.VCDVariableType.Trireg: case VCD_Variable.VCDVariableType.Wand: case VCD_Variable.VCDVariableType.Wire: case VCD_Variable.VCDVariableType.Wor: { if (var.Size == 1) { var.base_variable = TypeCreator.CreateSignal(var.Reference, VHDL.builtin.StdLogic1164.STD_ULOGIC); var.appendFunction = VCDConvertor.Append_STD_ULOGIC_VALUE; } else { ResolvedDiscreteRange range = ResolvedDiscreteRange.FormIntegerIndexes(var.StartIndex, var.EndIndex); VHDL.type.ISubtypeIndication arrayType = VHDL.builtin.StdLogic1164.Create_STD_ULOGIC_VECTOR(new Range(range.From, (range.RangeDirection == RangeDirection.To)?Range.RangeDirection.TO:Range.RangeDirection.DOWNTO, range.To)); var.base_variable = TypeCreator.CreateSignal(var.Reference, arrayType); var.appendFunction = VCDConvertor.Append_STD_ULOGIC_VECTOR_VALUE; } } break; } return(var); }
public STD_ULOGIC_VECTOR_VALUE(IList <AbstractValue> _value, ResolvedDiscreteRange range) : base(VHDL.builtin.StdLogic1164.STD_ULOGIC_VECTOR, _value, range) { }