public IBlendType Find(string name) { IBlendType type = null; m_tables.TryGetValue(name, out type); return(type); }
public List <BlendValueCapsule> DereferenceAll(IBlendType type) { if (!CanDereference(type)) { return(null); } var result = new List <BlendValueCapsule>(); try { int offset = (int)m_address; IBlendType realType; using (var reader = new BinaryReader(m_mapper.GetStreamFromAddress(m_address, out realType))) { type = realType != null ? realType : type; // if the given type is not equals to the real stored type, we belieave the real stored type. result.Capacity = (int)reader.BaseStream.Length / type.SizeOf(); var context = new ReadValueContext() { reader = reader, mapper = m_mapper }; while (reader.BaseStream.Position < reader.BaseStream.Length) { var val = type.ReadValue(context); result.Add(val); } } } catch (Exception e) { throw new BlenderException("Failed to dereference {0} as {1}", AddressString, type.Name); } return(result); }
public BlendValueCapsule DereferenceOne(IBlendType type) { if (!CanDereference(type)) { return(null); } BlendValueCapsule result = null; try { int offset = (int)m_address; IBlendType realType; using (var reader = new BinaryReader(m_mapper.GetStreamFromAddress(m_address, out realType))) { var context = new ReadValueContext() { reader = reader, mapper = m_mapper }; result = type.ReadValue(context); } } catch (Exception e) { throw new BlenderException("Failed to dereference {0} as {1}", AddressString, type.Name); } return(result); }
/// <summary> /// Constructor for a full-spec /// </summary> /// <param name="type">base type</param> /// <param name="dimCountArray">array of size</param> public BlendArrayType(IBlendType type, int[] dimCountArray) { Debug.Assert(type != null, "type must not be null"); m_baseType = type; if (dimCountArray.Length != 0) { m_dimCountArray = new int[dimCountArray.Length]; dimCountArray.CopyTo(m_dimCountArray, 0); } }
public bool Equals(IBlendType type) { var thisType = type as BlendPointerType; if (thisType == null) { // type unmatched return(false); } return(m_baseType.Equals(thisType.m_baseType)); }
public bool Equals(IBlendType type) { var structure = type as BlendStructureType; if (structure == null) { // type unmatched return(false); } return(Name == structure.Name); }
/// <summary> /// get whether a given type can dereference this address /// </summary> /// <param name="baseType">base type (QualifiedBlendType.BaseType)</param> /// <returns></returns> public bool CanDereference(IBlendType baseType) { if (!IsNull()) { if (baseType.GetType() != typeof(UnknownBlendType)) { return(true); } } return(false); }
public bool Equals(IBlendType type) { var primitive = type as BlendPrimitiveType; if (primitive == null) { // type unmatched return(false); } return(m_type == primitive.m_type); }
public virtual bool Equals(IBlendType type) { var qualified = type as BlendArrayType; if (qualified == null) { // type unmatched return(false); } return(!m_baseType.Equals(qualified.m_baseType) ? false : !_Equals(m_dimCountArray, qualified.m_dimCountArray) ? false : true); }
public void Add(IBlendType type) { if (m_tables.ContainsKey(type.Name)) { Debug.Assert(false, type.Name + "is already added"); return; } m_tables[type.Name] = type; if (type is BlendStructureType) { var sType = (BlendStructureType)type; _InsertSdnaType(sType); } }
/// <summary> /// factory method /// </summary> /// <param name="type">base type</param> /// <param name="pointerCount">count of pointer qualifier</param> /// <param name="dimCountArray">array of size</param> /// <remarks> /// if any params do not qualify a base type, this methods just returns it. /// see also constructors. /// If you do not want to an array type, set dim1Count and dim2Count to 0. /// Array and pointer type meanns an array of pointer type. /// </remarks> public static IBlendType From(IBlendType type, int pointerCount, int[] dimCountArray) { for (int i = 0; i < pointerCount; ++i) { type = new BlendPointerType(type); } if ((dimCountArray == null || dimCountArray.Length == 0)) { return(type); } else { return(new BlendArrayType(type, dimCountArray)); } }
/* * private List<_StructureDecl> _SortByTypeDependency(List<_StructureDecl> declList) * { * int capacity = declList.Count(); * var result = new List<_StructureDecl>(capacity); * var tmpTable = new Dictionary<String, _StructureDeclBoolTuple>(capacity); * foreach (var decl in declList) * { * tmpTable.Add(decl.name, new _StructureDeclBoolTuple(decl, false)); * } * * foreach (var v in tmpTable.Values) * { * _RegisterTypeRecursively(v, tmpTable, result); * } * * return result; * } * * private void _RegisterTypeRecursively(_StructureDeclBoolTuple target, Dictionary<String, _StructureDeclBoolTuple> tmpTable, List<_StructureDecl> result) * { * if (target.Item2) * { * // already registered * return; * } * * // call recursively for each member * foreach (var type in target.Item1.fieldTypes) * { * if (type == target.Item1.name) * { * continue; * } * * if (m_repository.Find(type) != null) * { * // primitive type * continue; * } * * _StructureDeclBoolTuple tmpValue = null; * if (!tmpTable.TryGetValue(type, out tmpValue)) * { * // Error? * continue; * } * * _RegisterTypeRecursively(tmpValue, tmpTable, result); * } * * target.Item2 = true; * result.Add(target.Item1); * } */ /// <summary> /// Create a .blend type from SDNA member name with type qualifiers /// </summary> /// <param name="type">.blend type</param> /// <param name="name">member name</param> /// <param name="tLen">size of type [byte]</param> /// <remarks> /// qualifier of array and pointer is contained in SDNA member name. /// this is inconvenient to make domain classes. /// this function moves these qualifiers from name to type. /// </remarks> private static BlendStructureType.MemberDecl _ParseType(IBlendType type, string name, int tLen) { string description = type.Name + " " + name; Match match = null; match = FunctionPointerRegex.Match(name, 0); if (match.Success) { // function pointer is unsupported int ptSize = BlendPointerType.GetPointerSizeOf(); return(new BlendStructureType.MemberDecl(match.Groups[1].Value, new UnknownBlendType(description, ptSize))); } match = PointerAndNameRegex.Match(name, 0); if (match.Success) { string pointers = match.Groups[1].Value; string baseName = match.Groups[2].Value; // parse pointer qualifiers int pointerCount = pointers.Length; // parse array qualifiers List <int> dimCountArray = new List <int>(); var matches = ArraySizeRegex.Matches(name, match.Length); foreach (Match m in matches) { string size = m.Groups[1].Value; dimCountArray.Add(int.Parse(size)); } var resultType = BlendTypeFactory.From(type, pointerCount, dimCountArray.ToArray()); return(new BlendStructureType.MemberDecl(baseName, resultType)); } else { // unknown return(new BlendStructureType.MemberDecl(name, new UnknownBlendType(description, tLen))); } }
/// <summary> /// get a binary stream beginning from a given address /// </summary> /// <param name="address"></param> /// <param name="outType"></param> /// <returns></returns> public Stream GetStreamFromAddress(ulong address, out IBlendType outType) { Tuple <int, int, int, IBlendType> tmp; if (!m_map.TryGetValue(address, out tmp)) { outType = null; return(null); } // Link (sdnaIndex==0) is unbelievable if (tmp.Item3 == 0) { outType = null; } else { outType = tmp.Item4; } return(new MemoryStream(m_binary, tmp.Item1, tmp.Item2)); }
/// <summary> /// Constructor for a full-spec /// </summary> /// <param name="type">base type</param> /// <param name="dim1Count">first dimension count for array</param> /// <param name="dim2Count">second dimension count for array</param> public BlendArrayType(IBlendType type, int dim1Count, int dim2Count) { Debug.Assert(type != null, "type must not be null"); m_baseType = type; // Build array int dimension = dim1Count == 0 ? 0 : dim2Count == 0 ? 1 : 2; if (dimension != 0) { m_dimCountArray = new int[dimension]; var dimCountArray = new int[] { dim1Count, dim2Count }; for (int index = 0; index < m_dimCountArray.Length; ++index) { m_dimCountArray[index] = dimCountArray[index]; } } }
public MemberDecl(string name, IBlendType type) { Name = name; Type = type; }
public _BlendValueCapsule(IBlendType type, object value) : base(type, value) { }
public BlendValueCapsule(IBlendType type, object value) { m_type = type; m_rawValue = value; }
/// <summary> /// Constructor /// </summary> /// <param name="type">base type</param> public BlendPointerType(IBlendType baseType) { Debug.Assert(baseType != null, "type must not be null"); m_baseType = baseType; }
/// <summary> /// add entry of mapping /// </summary> /// <param name="address">old memory address</param> /// <param name="offset">offset from the top of .blend binary</param> /// <param name="size">entry binary size [byte]</param> /// <param name="type">hint type for dereference</param> public void AddEntry(ulong address, int offset, int size, int sdnaIndex, IBlendType type) { Debug.Assert(m_binary.Length >= (offset + size), "size is too big"); m_map.Add(address, Tuple.Create(offset, size, sdnaIndex, type)); }
public bool Equals(IBlendType type) { return(this == type); }