private object ReadType(CtfStruct strct, object[] result, CtfMetadataType type) { Align(type.Align); switch (type.CtfType) { case CtfTypes.Array: CtfArray array = (CtfArray)type; int len = array.GetLength(strct, result); object[] ret = new object[len]; for (int j = 0; j < len; j++) { ret[j] = ReadType(null, null, array.Type); } return(ret); case CtfTypes.Enum: return(ReadType(strct, result, ((CtfEnum)type).Type)); case CtfTypes.Float: CtfFloat flt = (CtfFloat)type; ReadBits(flt.Exp + flt.Mant); return(0f); // TODO: Not implemented. case CtfTypes.Integer: CtfInteger ctfInt = (CtfInteger)type; return(ReadInteger(ctfInt)); case CtfTypes.String: bool ascii = ((CtfString)type).IsAscii; return(ReadString(ascii)); case CtfTypes.Struct: return(ReadStruct((CtfStruct)type)); case CtfTypes.Variant: CtfVariant var = (CtfVariant)type; int i = strct.GetFieldIndex(var.Switch); CtfField field = strct.Fields[i]; CtfEnum enumType = (CtfEnum)field.Type; int value = strct.GetFieldValue <int>(result, i); string name = enumType.GetName(value); field = var.Union.Where(f => f.Name == name).Single(); return(ReadType(strct, result, field.Type)); default: throw new InvalidOperationException(); } }
public void ReadTypeIntoBuffer(CtfStruct context, CtfMetadataType type) { Align(type.Align); type.BitOffset = _bitOffset; if (type.CtfType == CtfTypes.Enum) { type = ((CtfEnum)type).Type; type.BitOffset = _bitOffset; } else if (type.CtfType != CtfTypes.Struct && type.CtfType != CtfTypes.Variant) { int size = type.GetSize(); if (size != CtfEvent.SizeIndeterminate) { ReadBits(size); return; } } switch (type.CtfType) { case CtfTypes.Array: CtfArray array = (CtfArray)type; var indexType = context.GetField(array.Index).Type; int len = CtfInteger.ReadInt <int>(indexType, _buffer, indexType.BitOffset); int elemSize = array.Type.GetSize(); if (elemSize == CtfEvent.SizeIndeterminate) { for (int j = 0; j < len; j++) { ReadTypeIntoBuffer(null, array.Type); } } else { for (int j = 0; j < len; j++) { Align(type.Align); ReadBits(elemSize); } } break; case CtfTypes.Float: CtfFloat flt = (CtfFloat)type; ReadBits(flt.Exp + flt.Mant); break; case CtfTypes.Integer: CtfInteger ctfInt = (CtfInteger)type; ReadBits(ctfInt.Size); break; case CtfTypes.String: Debug.Assert((_bitOffset % 8) == 0); int startOffset = _bitOffset >> 3; int offset = startOffset; ReadBits(8); bool ascii = ((CtfString)type).IsAscii; if (ascii) { while (_buffer[offset++] != 0) { ReadBits(8); } } else { byte b = _buffer[offset]; while (b != 0) { switch (b) { default: break; case 0xc: case 0xd: ReadBits(8); break; case 0xe: ReadBits(16); break; case 0xf: ReadBits(24); break; } offset = ReadBits(8) >> 3; b = _buffer[offset]; } } int bufferLen = (_bitOffset >> 3) - startOffset; Encoding encoding = ascii ? Encoding.ASCII : Encoding.UTF8; byte[] newArr = Encoding.Convert(encoding, Encoding.Unicode, _buffer, startOffset, bufferLen); ((CtfString)type).Length = bufferLen; if (_buffer.Length < _bufferLength + newArr.Length) { byte[] buffer = ReallocateBuffer(_bufferLength + newArr.Length); System.Buffer.BlockCopy(buffer, 0, _buffer, 0, _bufferLength); } System.Buffer.BlockCopy(newArr, 0, _buffer, startOffset, newArr.Length); _bufferLength = startOffset + newArr.Length; _bitOffset = _bufferLength * 8; break; case CtfTypes.Struct: ReadStruct((CtfStruct)type); break; case CtfTypes.Variant: CtfVariant var = (CtfVariant)type; CtfField field = context.GetField(var.Switch); CtfEnum enumType = (CtfEnum)field.Type; int value = CtfInteger.ReadInt <int>(enumType, _buffer, enumType.BitOffset); string name = enumType.GetName(value); field = var.GetVariant(name); ReadTypeIntoBuffer(null, field.Type); break; default: throw new InvalidOperationException(); } }
private CtfMetadataType ParseOneType(string statement, out int index) { CtfMetadataType type = null; Match match; if ((match = s_integer.Match(statement)).Success) { Group group = match.Groups[1]; CtfPropertyBag bag = GetPropertyBag(group.ToString()); type = new CtfInteger(bag); index = group.Index + group.Length; } else if ((match = s_struct.Match(statement)).Success) { var group = match.Groups[1]; if (group.ToString() != "{") { throw new InvalidOperationException(); } int open = group.Index; int close = FindCloseBrace(statement, open); CtfField[] fields = ParseStructFields(statement, open, close).ToArray(); type = new CtfStruct(null, fields); index = close + 1; } else if ((match = s_float.Match(statement)).Success) { int open = match.Index + match.Length - 1; int close = FindCloseBrace(statement, open); CtfPropertyBag bag = GetPropertyBag(statement, open, close); type = new CtfFloat(bag); index = close + 1; } else if ((match = s_variant.Match(statement)).Success) { string switchVariable = match.Groups[1].ToString(); int open = statement.IndexOf('{'); int close = FindCloseBrace(statement, open); if (close == -1) { throw new InvalidOperationException(); } CtfField[] fields = ParseStructFields(statement, open, close).ToArray(); type = new CtfVariant(switchVariable, fields); index = close + 1; } else if ((match = s_variable.Match(statement)).Success) { var typeGroup = match.Groups[1]; string typeName = typeGroup.ToString().Trim(); if (typeName == "string") { type = new CtfString(); } else { type = new CtfUnresolvedType(typeName); } index = typeGroup.Index + typeGroup.Length; } else if ((match = s_enum.Match(statement)).Success) { var groups = match.Groups; string typeName = groups[1].ToString().Trim(); int open = statement.IndexOf('{'); int close = FindCloseBrace(statement, open); if (close == -1) { throw new InvalidOperationException(); } CtfNamedRange[] ranges = ParseNamedRanges(statement, open + 1, close).ToArray(); // TODO: Can enums just be an inline defined integer? type = new CtfEnum(new CtfUnresolvedType(typeName), ranges); index = close + 1; } else { // TODO: Floating point index = 0; return(null); } return(type); }