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);
}
