void tweakingPanel_TranslationTweaked(object sender, ExpressionTweakingPanel.TranslationTweakedEventArgs translationTweakedEventArgs)
{
ExpressionTweakingPanel p = (ExpressionTweakingPanel)sender;
XDocument document;
ILog log;
TagClass tag = (TagClass)p.FilePresenterTab.Tag;
TranslationSettings settings = tag.settings;
settings.Retranslation = true;
GenerateSchema(p.FilePresenterTab.SourcePSMSchema, settings, out document, out log);
p.FilePresenterTab.ReDisplayFile(document, EDisplayedFileType.SCH,
p.FilePresenterTab.SourcePSMSchema.Caption, log, p.FilePresenterTab.ValidationSchema, p.FilePresenterTab.SourcePSMSchema);
}
public Asn1Tag(TagClass tagClass, int tagValue, bool isConstructed = false)
: this((byte)((byte)tagClass | (isConstructed ? ConstructedMask : 0)), tagValue)
{
if (tagClass < TagClass.Universal || tagClass > TagClass.Private)
{
throw new ArgumentOutOfRangeException(nameof(tagClass));
}
if (tagValue < 0)
{
throw new ArgumentOutOfRangeException(nameof(tagValue));
}
}
public static void ExpectedTag_IgnoresConstructed(
AsnEncodingRules ruleSet,
string inputHex,
TagClass tagClass,
int tagValue)
{
Asn1Tag primitiveTag = new Asn1Tag(tagClass, tagValue, false);
Asn1Tag constructedTag = new Asn1Tag(tagClass, tagValue, true);
byte[] inputData = inputHex.HexToByteArray();
AsnReader reader = new AsnReader(inputData, ruleSet);
ShortBacked val1 = reader.ReadEnumeratedValue <ShortBacked>(constructedTag);
Assert.False(reader.HasData);
reader = new AsnReader(inputData, ruleSet);
ShortBacked val2 = reader.ReadEnumeratedValue <ShortBacked>(primitiveTag);
Assert.False(reader.HasData);
Assert.Equal(val1, val2);
reader = new AsnReader(inputData, ruleSet);
ShortBacked val3 = (ShortBacked)reader.ReadEnumeratedValue(typeof(ShortBacked), constructedTag);
Assert.False(reader.HasData);
Assert.Equal(val1, val3);
reader = new AsnReader(inputData, ruleSet);
ShortBacked val4 = (ShortBacked)reader.ReadEnumeratedValue(typeof(ShortBacked), primitiveTag);
Assert.False(reader.HasData);
Assert.Equal(val1, val4);
reader = new AsnReader(inputData, ruleSet);
ReadOnlyMemory <byte> bytes1 = reader.ReadEnumeratedBytes(constructedTag);
Assert.False(reader.HasData);
reader = new AsnReader(inputData, ruleSet);
ReadOnlyMemory <byte> bytes2 = reader.ReadEnumeratedBytes(primitiveTag);
Assert.False(reader.HasData);
Assert.Equal(bytes1.ByteArrayToHex(), bytes2.ByteArrayToHex());
Assert.Equal("FF", bytes1.ByteArrayToHex());
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
var sourceTag = (ExtractedTag)value;
TagClass tc = TagsSource.Classes.Where(c => c.RawClass.Magic == sourceTag.Class).FirstOrDefault();
if (tc == null)
{
return(false);
}
var existingTag = tc.Children.Find(t => t.TagFileName == sourceTag.Name);
return(existingTag != null);
}
public static void ExpectedTag_IgnoresConstructed(
AsnEncodingRules ruleSet,
string inputHex,
TagClass tagClass,
int tagValue)
{
byte[] inputData = inputHex.HexToByteArray();
AsnReader reader = new AsnReader(inputData, ruleSet);
reader.ReadNull(new Asn1Tag(tagClass, tagValue, true));
Assert.False(reader.HasData);
reader = new AsnReader(inputData, ruleSet);
reader.ReadNull(new Asn1Tag(tagClass, tagValue, false));
Assert.False(reader.HasData);
}
/// <summary>
/// Read tag. (only check the value type)
/// </summary>
/// <param name="tagClass">expected tag class</param>
/// <param name="isConstructed">expected value of "constructed" flag</param>
/// <param name="tagNumber">expected tag number</param>
/// <param name="length">length of the value field will be stored</param>
/// <returns>true if succeeded.</returns>
public bool ReadTag(TagClass tagClass, bool isConstructed, int tagNumber, out int length)
{
BERTagInfo tagInfo = new BERTagInfo();
if (ReadTagInfo(ref tagInfo) &&
tagInfo.ClassBits == (int)tagClass &&
tagInfo.IsConstructed == isConstructed &&
tagInfo.TagNumber == tagNumber)
{
length = tagInfo.Length;
return(true);
}
length = 0;
return(false);
}
public TagDatum Add(TagClass tagClass, string newPath, int length, int virtualAddress)
{
var last = _data.Last();
var newDatum = new TagDatum
{
Class = tagClass,
Identifier = last.Identifier,
Length = length,
Path = newPath,
VirtualAddress = virtualAddress
};
_data.Insert(IndexOf(last), newDatum);
last.Identifier++;
Update(last.Identifier, last);
return(newDatum);
}
private void openFileDialog1_FileOk(object sender, CancelEventArgs e)
{
string[] tmp = openFileDialog1.FileNames;
for (int i = 0; i < tmp.Length; i++)
{
TrackBase.Files.Add(tmp[i]);
TagClass TM = new TagClass(tmp[i]);
if (TM.title != "")
{
playlist.Items.Add(TM.artist + " - " + TM.title);
}
else
{
playlist.Items.Add(TM.artist);
}
}
}
protected TagIndexBase(CacheStream cache)
{
var binaryReader = new BinaryReader(cache);
classArrayAddress = binaryReader.ReadInt32();
classArrayCount = binaryReader.ReadInt32();
datumArrayAddress = binaryReader.ReadInt32();
ScenarioIdent = binaryReader.ReadTagIdent();
GlobalsIdent = binaryReader.ReadTagIdent();
_noodleValue = binaryReader.ReadInt32();
datumArrayCount = binaryReader.ReadInt32();
fourCC = binaryReader.ReadTagClass();
if (fourCC != new TagClass("tags"))
{
throw new InvalidDataException();
}
}
public void VisitTagRef(TagRefData field)
{
SeekToOffset(field.Offset);
TagClass tagClass = null;
DatumIndex index;
if (field.WithClass)
{
// Read the datum index based upon the layout
StructureValueCollection values = StructureReader.ReadStructure(_reader, _tagRefLayout);
index = new DatumIndex(values.GetInteger("datum index"));
// Check the class, in case the datum index is null
var magic = values.GetInteger("class magic");
var str = CharConstant.ToString((int)magic);
tagClass = field.Tags.Classes.FirstOrDefault(c => c.TagClassMagic == str);
}
else
{
// Just read the datum index at the current position
index = DatumIndex.ReadFrom(_reader);
}
TagEntry tag = null;
if (index.IsValid && index.Index < field.Tags.Entries.Count)
{
tag = field.Tags.Entries[index.Index];
if (tag == null || tag.RawTag == null || tag.RawTag.Index != index)
{
tag = null;
}
}
if (tag != null)
{
field.Class = field.Tags.Classes.FirstOrDefault(c => c.RawClass == tag.RawTag.Class);
field.Value = tag;
}
else
{
field.Class = tagClass;
field.Value = null;
}
}
public LdapMessage TryParsePacket(byte[] input)
{
AsnReader reader = new AsnReader(input, AsnEncodingRules.BER);
AsnReader sequenceReader = reader.ReadSequence();
BigInteger messageId = sequenceReader.ReadInteger();
TagClass tagClass = sequenceReader.PeekTag().TagClass;
int tagValue = sequenceReader.PeekTag().TagValue;
if (tagClass != TagClass.Application)
{
throw new ArgumentException("Input type is expected to be " + TagClass.Application + " but was " + tagClass);
}
IProtocolOp message = DecodeApplicationData(tagValue, sequenceReader, input);
return(new LdapMessage(messageId, message));
}
public static void ExpectedTag_IgnoresConstructed(
AsnEncodingRules ruleSet,
string inputHex,
TagClass tagClass,
int tagValue)
{
byte[] inputData = inputHex.HexToByteArray();
AsnReader reader = new AsnReader(inputData, ruleSet);
ReadOnlyMemory <byte> val1 = reader.ReadIntegerBytes(new Asn1Tag(tagClass, tagValue, true));
Assert.False(reader.HasData);
reader = new AsnReader(inputData, ruleSet);
ReadOnlyMemory <byte> val2 = reader.ReadIntegerBytes(new Asn1Tag(tagClass, tagValue, false));
Assert.False(reader.HasData);
Assert.Equal(val1.ByteArrayToHex(), val2.ByteArrayToHex());
}
private bool ReadBinary(TagClass tagClass, bool isConstructed, int tagNumber, out byte[] data)
{
int valueLength;
if (ReadTag(tagClass, isConstructed, tagNumber, out valueLength) &&
valueLength != LENGTH_INDEFINITE && valueLength > 0)
{
byte[] buff = new byte[valueLength];
int len = strm.Read(buff, 0, valueLength);
if (len == valueLength)
{
data = buff;
return(true);
}
}
data = null;
return(false);
}
public override void Execute(object parameter = null)
{
if (Current.ActiveDiagram != null && Current.ActiveDiagram is PSMDiagram)
{
XDocument schematronSchemaDocument;
ILog log;
TranslationSettings settings = new TranslationSettings();
settings.Functional = true;
settings.SchemaAware = true;
GenerateSchema((PSMSchema)Current.ActiveDiagram.Schema, settings, out schematronSchemaDocument, out log);
FilePresenterButtonInfo[] additionalButtonsInfo = new[] {
new FilePresenterButtonInfo()
{
ButtonName = "SA", Text = "Schema aware", Icon = ExolutioResourceNames.GetResourceImageSource(ExolutioResourceNames.refresh), UpdateFileContentAction = RegenerateSchema, ToggleButton = true, IsToggled = true
},
new FilePresenterButtonInfo()
{
ButtonName = "F", Text = "Functional", Icon = ExolutioResourceNames.GetResourceImageSource(ExolutioResourceNames.refresh), UpdateFileContentAction = RegenerateSchema, ToggleButton = true, IsToggled = true
},
};
ExpressionTweakingPanel tweakingPanel = new ExpressionTweakingPanel();
TagClass tag = new TagClass();
tag.settings = settings;
tag.tweakingPanel = tweakingPanel;
IFilePresenterTab filePresenterTab
= Current.MainWindow.FilePresenter.DisplayFile(schematronSchemaDocument, EDisplayedFileType.SCH, Current.ActiveDiagram.Caption + ".sch", log, sourcePSMSchema: (PSMSchema)Current.ActiveDiagram.Schema,
additionalActions: additionalButtonsInfo, tag: tag);
filePresenterTab.RefreshCallback += RegenerateSchema;
if (settings.SubexpressionTranslations.TranslationOptionsWithMorePossibilities.Any())
{
tweakingPanel.Bind(settings.SubexpressionTranslations);
tweakingPanel.FilePresenterTab = filePresenterTab;
filePresenterTab.DisplayAdditionalControl(tweakingPanel, "Expression Tweaking");
tweakingPanel.TranslationTweaked += tweakingPanel_TranslationTweaked;
}
}
}
/// <summary>
/// Decodes an identifier from the stream.
/// </summary>
/// <param name="Input">Input stream.</param>
/// <param name="Constructed">If the identifier is constructed (true) or primitive (false)</param>
/// <param name="Class">Class of tag.</param>
/// <returns>TAG</returns>
public static long DecodeIdentifier(Stream Input, out bool Constructed, out TagClass Class)
{
int i = Input.ReadByte();
if (i < 0)
{
throw new EndOfStreamException();
}
Class = (TagClass)((i >> 6) & 3);
Constructed = (i & 32) != 0;
i &= 31;
if (i < 31)
{
return(i);
}
return(DecodeVarLenInt(Input));
}
public static void EmptyData_Allows0UnusedBits(
AsnEncodingRules ruleSet,
TagClass tagClass,
int tagValue,
string expectedHex)
{
AsnWriter writer = new AsnWriter(ruleSet);
if (tagClass == TagClass.Universal)
{
Debug.Assert(tagValue == (int)UniversalTagNumber.BitString);
writer.WriteBitString(ReadOnlySpan <byte> .Empty, 0);
}
else
{
writer.WriteBitString(ReadOnlySpan <byte> .Empty, 0, new Asn1Tag(tagClass, tagValue));
}
Verify(writer, expectedHex);
}
/// <summary>
/// Create an <see cref="Asn1Tag"/> for a specified value within a specified tag class.
/// </summary>
/// <param name="tagClass">
/// The tag class for this tag.
/// </param>
/// <param name="tagValue">
/// The numeric value for this tag.
/// </param>
/// <param name="isConstructed">
/// <see langword="true"/> for a constructed tag, <see langword="false"/> for a primitive tag.
/// </param>
/// <exception cref="ArgumentOutOfRangeException">
/// <paramref name="tagClass"/> is not a known value.
///
/// -or-
///
/// <paramref name="tagValue" /> is negative.
/// </exception>
/// <remarks>
/// This constructor allows for the creation undefined UNIVERSAL class tags.
/// </remarks>
public Asn1Tag(TagClass tagClass, int tagValue, bool isConstructed = false)
: this((byte)((byte)tagClass | (isConstructed ? ConstructedMask : 0)), tagValue)
{
switch (tagClass)
{
case TagClass.Universal:
case TagClass.ContextSpecific:
case TagClass.Application:
case TagClass.Private:
break;
default:
throw new ArgumentOutOfRangeException(nameof(tagClass));
}
if (tagValue < 0)
{
throw new ArgumentOutOfRangeException(nameof(tagValue));
}
}
public static void ExpectedTag_IgnoresConstructed(
AsnEncodingRules ruleSet,
string inputHex,
TagClass tagClass,
int tagValue)
{
byte[] inputData = inputHex.HexToByteArray();
AsnReader reader = new AsnReader(inputData, ruleSet);
DateTimeOffset val1 = reader.ReadGeneralizedTime(new Asn1Tag(tagClass, tagValue, true));
Assert.False(reader.HasData);
reader = new AsnReader(inputData, ruleSet);
DateTimeOffset val2 = reader.ReadGeneralizedTime(new Asn1Tag(tagClass, tagValue, false));
Assert.False(reader.HasData);
Assert.Equal(val1, val2);
}
public static void VerifyWriteNamedBitList_WithTag(
AsnEncodingRules ruleSet,
string expectedHex,
Enum value)
{
int ruleSetVal = (int)ruleSet;
TagClass tagClass = (TagClass)(byte)(ruleSetVal << 6);
if (tagClass == TagClass.Universal)
{
tagClass = TagClass.Private;
}
Asn1Tag tag = new Asn1Tag(tagClass, ruleSetVal);
AsnWriter writer = new AsnWriter(ruleSet);
writer.WriteNamedBitList(value, tag);
Verify(writer, expectedHex);
}
protected void ParseIdentifier(byte[] bytes)
{
bool long_form = (bytes[0] & 0x1F) == 0x1F;
identifier_class = (TagClass)(bytes[0] & 0xC0);
is_constructed = ((bytes[0] & 0x20) == 0x20);
if (long_form)
{
int i = 1, temp_tag = 0;
do
{
temp_tag <<= 7;
tag += bytes[i];
} while ((bytes[i++] & 0x80) == 0x80); // Highest bit not set in final octet.
tag = temp_tag;
}
else
{
tag = bytes[0] & 0x1F;
}
}
public static void ExpectedTag_IgnoresConstructed(
AsnEncodingRules ruleSet,
string inputHex,
TagClass tagClass,
int tagValue)
{
byte[] inputData = inputHex.HexToByteArray();
AsnReader reader = new AsnReader(inputData, ruleSet);
AsnReader val1 = reader.ReadSetOf(expectedTag: new Asn1Tag(tagClass, tagValue, true));
Assert.False(reader.HasData);
reader = new AsnReader(inputData, ruleSet);
AsnReader val2 = reader.ReadSetOf(expectedTag: new Asn1Tag(tagClass, tagValue, false));
Assert.False(reader.HasData);
Assert.Equal(val1.ReadEncodedValue().ByteArrayToHex(), val2.ReadEncodedValue().ByteArrayToHex());
}
public static void VerifyEncode(TagClass tagClass, int tagValue, bool constructed, string expectedHex)
{
Asn1Tag tag = new Asn1Tag(tagClass, tagValue, constructed);
Span <byte> buf = stackalloc byte[10];
Assert.False(tag.TryEncode(Span <byte> .Empty, out int written));
Assert.Equal(0, written);
int expectedSize = expectedHex.Length / 2;
Assert.Equal(expectedSize, tag.CalculateEncodedSize());
Assert.False(tag.TryEncode(buf.Slice(0, expectedSize - 1), out written));
Assert.Equal(0, written);
AssertExtensions.Throws <ArgumentException>(
"destination",
() =>
{
Span <byte> tmp = stackalloc byte[expectedSize - 1];
return(tag.Encode(tmp));
});
Assert.True(tag.TryEncode(buf, out written));
Assert.Equal(expectedSize, written);
Assert.Equal(expectedHex, buf.Slice(0, written).ByteArrayToHex());
written = tag.Encode(buf.Slice(1));
Assert.Equal(expectedSize, written);
Assert.Equal(expectedHex, buf.Slice(1, written).ByteArrayToHex());
Assert.True(tag.TryEncode(buf.Slice(0, expectedSize), out written));
Assert.Equal(expectedSize, written);
Assert.Equal(expectedHex, buf.Slice(0, written).ByteArrayToHex());
written = tag.Encode(buf.Slice(1, expectedSize));
Assert.Equal(expectedSize, written);
Assert.Equal(expectedHex, buf.Slice(1, written).ByteArrayToHex());
}
public static void ExpectedTag_IgnoresConstructed(
AsnEncodingRules ruleSet,
string inputHex,
TagClass tagClass,
int tagValue)
{
byte[] inputData = inputHex.HexToByteArray();
Asn1Tag constructedTag = new Asn1Tag(tagClass, tagValue, true);
Asn1Tag primitiveTag = new Asn1Tag(tagClass, tagValue, false);
AsnReader reader = new AsnReader(inputData, ruleSet);
string val1 = reader.ReadObjectIdentifier(constructedTag);
Assert.False(reader.HasData);
reader = new AsnReader(inputData, ruleSet);
string val2 = reader.ReadObjectIdentifier(primitiveTag);
Assert.False(reader.HasData);
Assert.Equal(val1, val2);
}
public TagClassAttribute(string tagClass)
{
TagClass = (TagClass)tagClass;
}
public static void NoNegativeTagNumbers(TagClass tagClass, int value)
{
AssertExtensions.Throws <ArgumentOutOfRangeException>(
"tagValue",
() => new Asn1Tag(tagClass, value));
}
public static void ExpectedTag_IgnoresConstructed(
AsnEncodingRules ruleSet,
string inputHex,
TagClass tagClass,
int tagValue)
{
byte[] inputData = inputHex.HexToByteArray();
AsnReader reader = new AsnReader(inputData, ruleSet);
Asn1Tag correctConstructed = new Asn1Tag(tagClass, tagValue, true);
Asn1Tag correctPrimitive = new Asn1Tag(tagClass, tagValue, false);
Assert.True(
reader.TryReadPrimitiveBitString(
out int ubc1,
out ReadOnlyMemory <byte> val1,
correctConstructed));
Assert.False(reader.HasData);
reader = new AsnReader(inputData, ruleSet);
Assert.True(
reader.TryReadPrimitiveBitString(
out int ubc2,
out ReadOnlyMemory <byte> val2,
correctPrimitive));
Assert.False(reader.HasData);
string val1Hex = val1.ByteArrayToHex();
Assert.Equal(val1Hex, val2.ByteArrayToHex());
Assert.Equal(ubc1, ubc2);
reader = new AsnReader(inputData, ruleSet);
byte[] output1 = new byte[inputData.Length];
Assert.True(reader.TryReadBitString(output1.AsSpan(1), out ubc1, out int written, correctConstructed));
Assert.Equal(ubc2, ubc1);
Assert.Equal(val1Hex, output1.AsSpan(1, written).ByteArrayToHex());
Assert.False(reader.HasData);
reader = new AsnReader(inputData, ruleSet);
Assert.True(reader.TryReadBitString(output1.AsSpan(2), out ubc1, out written, correctPrimitive));
Assert.Equal(ubc2, ubc1);
Assert.Equal(val1Hex, output1.AsSpan(2, written).ByteArrayToHex());
Assert.False(reader.HasData);
reader = new AsnReader(inputData, ruleSet);
byte[] output2 = reader.ReadBitString(out ubc1, correctConstructed);
Assert.Equal(ubc2, ubc1);
Assert.Equal(val1Hex, output2.ByteArrayToHex());
Assert.False(reader.HasData);
reader = new AsnReader(inputData, ruleSet);
byte[] output3 = reader.ReadBitString(out ubc1, correctPrimitive);
Assert.Equal(ubc2, ubc1);
Assert.Equal(val1Hex, output3.ByteArrayToHex());
Assert.False(reader.HasData);
}
//void PostProcessTag(TagBlockWrapper wrapper)
//{
// //var items = wrapper.references.Select(x => x.Owner).Distinct().ToArray();
// //foreach (var item in items)
// //{
// // TagBlockWrapper resource_owner = PreProcessTag(Tags[item.Index]);
// // var resources = wrapper.references.Where(x => x.Owner == item).ToArray();
// // for (int resource_index = 0; resource_index < resources.Length; ++resource_index)
// // {
// // resources[resource_index].TagblockID = resource_owner.tagblocks
// // .Where(x => x.Offset == resources[resource_index].TagblockID)
// // .Select(x => x.TagblockID).First();
// // }
// //}
// //TagBlockWrapper resource_owner = PreProcessTag(Tags[wrapper.references[i].Owner.Index]);
// //{
// //}
// //wrapper.references[i].TagblockID = resource_owner.tagblocks.Select(x => x.).Single();//Select(x => x.Offset).Single();
//}
Tag FindFirst(TagClass tag_class, string path_fragment)
{
foreach (var tag in this.Tags)
{
if (tag.Type == tag_class && tag.Path.Contains(path_fragment))
return tag;
}
return new Tag();
}
internal static bool IsNull(TagDatum data)
{
return
(TagClass.IsNullOrZero(data.Class) && data.Identifier == TagIdent.NullIdentifier && data.Length == 0 &&
data.VirtualAddress == 0);
}
public TagClassHeirarchy(TagClass @class, TagClass parent, TagClass root)
{
Root = root;
Parent = parent;
Class = @class;
}
/// <summary>
/// Decodes an identifier from the stream.
/// </summary>
/// <param name="Constructed">If the identifier is constructed (true) or primitive (false)</param>
/// <param name="Class">Class of tag.</param>
/// <returns>TAG</returns>
public long DecodeIdentifier(out bool Constructed, out TagClass Class)
{
return(BER.DecodeIdentifier(this.input, out Constructed, out Class));
}
public Identifier(TagClass tagClass, bool constructed, int tag)
{
TagClass = tagClass;
Constructed = constructed;
Tag = tag;
}
void IField.SetFieldData(byte[] field_data, IStructure caller)
{
tag_class = (TagClass)BitConverter.ToInt32(field_data, 0);
tag_identifier = BitConverter.ToInt32(field_data, 4);
}
public StructureBspEnvironmentObjectBlock(BinaryReader binaryReader)
{
this.name = binaryReader.ReadString32();
this.rotation = binaryReader.ReadQuaternion();
this.translation = binaryReader.ReadVector3();
this.paletteIndex = binaryReader.ReadShortBlockIndex1();
this.padding = binaryReader.ReadBytes(2);
this.uniqueID = binaryReader.ReadInt32();
this.exportedObjectType = binaryReader.ReadTagClass();
this.scenarioObjectName = binaryReader.ReadString32();
}
internal static Type GetTypeOf(TagClass class_name)
{
return halo_2_classes[class_name];
}
public DontUseMeScenarioEnvironmentObjectBlock(BinaryReader binaryReader)
{
this.bSP = binaryReader.ReadShortBlockIndex1();
this.eMPTYSTRING = binaryReader.ReadInt16();
this.uniqueID = binaryReader.ReadInt32();
this.padding = binaryReader.ReadBytes(4);
this.objectDefinitionTag = binaryReader.ReadTagClass();
this.invalidName_object = binaryReader.ReadInt32();
this.padding0 = binaryReader.ReadBytes(44);
}
public static TagBlock CreateInstance(TagClass class_name)
{
Type tagblock_type = halo_2_classes[class_name];
return Activator.CreateInstance(tagblock_type) as TagBlock;
}
/// <summary>
/// Read tag. (only check the value type)
/// </summary>
/// <param name="tagClass">expected tag class</param>
/// <param name="isConstructed">expected value of "constructed" flag</param>
/// <param name="tagNumber">expected tag number</param>
/// <param name="length">length of the value field will be stored</param>
/// <returns>true if succeeded.</returns>
public bool ReadTag(TagClass tagClass, bool isConstructed, int tagNumber, out int length)
{
BERTagInfo tagInfo = new BERTagInfo();
if (ReadTagInfo(ref tagInfo)
&& tagInfo.ClassBits == (int)tagClass
&& tagInfo.IsConstructed == isConstructed
&& tagInfo.TagNumber == tagNumber) {
length = tagInfo.Length;
return true;
}
length = 0;
return false;
}
public IndexTable(Base.CacheFile Cache)
{
cache = Cache;
var IH = cache.IndexHeader;
var CH = cache.Header;
var Reader = cache.Reader;
ClassList = new List<TagClass>();
#region Read Class List
Reader.SeekTo(IH.tagClassIndexOffset);
for (int i = 0; i < IH.tagClassCount; i++)
{
TagClass tc = new TagClass();
tc.ClassCode = Reader.ReadString(4);
tc.Parent = Reader.ReadString(4);
tc.Parent2 = Reader.ReadString(4);
tc.StringID = Reader.ReadInt32();
ClassList.Add(tc);
}
#endregion
#region Read Tags' Info
Reader.SeekTo(IH.tagInfoOffset);
for (int i = 0; i < IH.tagCount; i++)
{
IndexItem item = new IndexItem() { Cache = cache };
item.ClassIndex = Reader.ReadInt16();
item.ID = (Reader.ReadInt16() << 16) | i;
item.Offset = Reader.ReadInt32() - cache.Magic;
item.metaIndex = i;
this.Add(item);
}
#endregion
#region Read Indices
Reader.SeekTo(CH.fileTableIndexOffset);
int[] indices = new int[IH.tagCount];
for (int i = 0; i < IH.tagCount; i++)
indices[i] = Reader.ReadInt32();
#endregion
#region Read Names
Reader.SeekTo(CH.fileTableOffset);
EndianReader newReader = (cache.tagsKey == "" || cache.tagsKey == null)
? new EndianReader(new MemoryStream(Reader.ReadBytes(CH.fileTableSize)), EndianFormat.Big)
: AES.DecryptSegment(Reader, CH.fileTableOffset, CH.fileTableSize, cache.tagsKey);
for (int i = 0; i < indices.Length; i++)
{
if (indices[i] == -1)
{
this[i].Filename = "<null>";
continue;
}
newReader.SeekTo(indices[i]);
int length;
if (i == indices.Length - 1)
length = CH.fileTableSize - indices[i];
else
{
if (indices[i + 1] == -1)
{
int index = -1;
for (int j = i + 1; j < indices.Length; j++)
{
if (indices[j] != -1)
{
index = j;
break;
}
}
length = (index == -1) ? CH.fileTableSize - indices[i] : indices[index] - indices[i];
}
else
length = indices[i + 1] - indices[i];
}
if (length == 1)
{
this[i].Filename = "<blank>";
continue;
}
if (length < 0)
{
int i0 = indices[i];
int i1 = indices[i + 1];
int i2 = indices[i + 2];
int i3 = indices[i + 3];
}
this[i].Filename = newReader.ReadString(length);
}
newReader.Close();
newReader.Dispose();
#endregion
}
public static void Write(this BinaryWriter binary_writer, TagClass tclass)
{
binary_writer.Write((int)tclass);
}
private bool ReadBinary(TagClass tagClass, bool isConstructed, int tagNumber, out byte[] data)
{
int valueLength;
if (ReadTag(tagClass, isConstructed, tagNumber, out valueLength)
&& valueLength != LENGTH_INDEFINITE && valueLength > 0) {
byte[] buff = new byte[valueLength];
int len = strm.Read(buff, 0, valueLength);
if (len == valueLength) {
data = buff;
return true;
}
}
data = null;
return false;
}
