void VerifyHeaderGroupTag(IO.ITagStream ts, Type type_of)
            {
                if (header.GroupTag != headerGroupTag.ID)
                {
                    if (type == FieldType.Struct)
                    {
                        var groups = ts.Engine.VersionToStructCollection();
                        int index  = groups.FindGroupIndex(header.GroupTag);

                        if (index == -1)
                        {
                            failureReason = VersioningFailureReason.GroupTagNotFound;

                            Debug.LogFile.WriteLine("{5} field set signature failed (signature not found) \t@{0:X8} [{1} !{2}] in {3}\t {4}",
                                                    relativeOffset, headerGroupTag.TagToString(), new string(TagGroup.FromUInt(header.GroupTag)),
                                                    type_of, ts.GetExceptionDescription(),
                                                    GetTypeString());
                            throw new Exceptions.InvalidVersion(ts);
                        }
                    }

                    failureReason = VersioningFailureReason.GroupTagMismatch;

                    Debug.LogFile.WriteLine("{5} field set signature failed\t@{0:X8} [{1} !{2}] in {3}\t {4}",
                                            relativeOffset,
                                            headerGroupTag.TagToString(), new string(TagGroup.FromUInt(header.GroupTag)),
                                            type_of, ts.GetExceptionDescription(),
                                            GetTypeString());
                    throw new Exceptions.InvalidVersion(ts);
                }
            }
            void VerifyHeaderCount(IO.ITagStream ts, Type type_of)
            {
                if (header.Count != expectedCount)
                {
                    failureReason = VersioningFailureReason.CountMismatch;

                    throw new Debug.ExceptionLog("{5} field set count mismatch \t@{0:X8} [{1} !{2}] in {3}\t {4}",
                                                 relativeOffset, expectedCount, header.Count,
                                                 type_of, ts.GetExceptionDescription(),
                                                 GetTypeString());
                }
            }
            void VerifyHeaderVersionIds(IO.ITagStream ts, Type type_of)
            {
                if ((header.Index != state.Attribute.Version || header.Size != state.Attribute.SizeOf) &&
                    state.VersionIsValid(header.Index, header.Size))
                {
                    needsUpgrading = true;
                }
                else
                {
                    if (header.Index != state.Attribute.Version)
                    {
                        if (header.Index > state.Attribute.Version)
                        {
                            failureReason = VersioningFailureReason.VersionIdIsNewer;
                        }
                        else
                        {
                            failureReason = VersioningFailureReason.VersionIdNotSupported;
                        }

                        Debug.LogFile.WriteLine("{5} field set version mismatch\t@{0:X8} [{1} !{2}] in {3}\t {4}",
                                                relativeOffset, state.Attribute.Version, header.Index,
                                                type_of, ts.GetExceptionDescription(),
                                                GetTypeString());
                        throw new Exceptions.InvalidVersion(ts, state.Attribute.Version, header.Index);
                    }

                    int expected_size;
                    if (!state.VersioningSizeIsValid(header, ts.Flags, out expected_size))
                    {
                        if (state.VersioningCanBeImplicitlyPerformed(header, ts.Flags))
                        {
                            needsUpgrading       = true;
                            useImplicitUpgrading = true;
                        }
                        else
                        {
                            failureReason = VersioningFailureReason.VersionIdMismatch;

                            Debug.LogFile.WriteLine("{5} field set sizeof mismatch \t@{0:X8} [{1} !{2}] in {3}\t {4}",
                                                    relativeOffset, expected_size, header.Size,
                                                    type_of, ts.GetExceptionDescription(),
                                                    GetTypeString());
                            throw new Exceptions.InvalidVersion(ts, state.Attribute.Version, expected_size, header.Index, header.Size);
                        }
                    }
                }
            }
            public FieldSetVersioning(BlamVersion engine, FieldType container_type, DefinitionState state)
            {
                failureReason        = VersioningFailureReason.None;
                relativeOffset       = 0;
                expectedCount        = 1;
                needsUpgrading       = false;
                useImplicitUpgrading = false;
                header = new tag_fieldset_header();

                this.type  = container_type;
                this.state = state;

                if (container_type != FieldType.Struct)
                {
                    this.headerGroupTag = Blam.MiscGroups.tbfd;
                }
                else
                {
                    var groups = engine.VersionToStructCollection();
                    var sa     = state.Attribute as StructAttribute;

                    headerGroupTag = groups[sa.GroupIndex];
                }
            }
示例#5
0
			void VerifyHeaderVersionIds(IO.ITagStream ts, Type type_of)
			{
				if ((header.Index != state.Attribute.Version || header.Size != state.Attribute.SizeOf) &&
					 state.VersionIsValid(header.Index, header.Size))
				{
					needsUpgrading = true;
				}
				else
				{
					if (header.Index != state.Attribute.Version)
					{
						if (header.Index > state.Attribute.Version)
							failureReason = VersioningFailureReason.VersionIdIsNewer;
						else
							failureReason = VersioningFailureReason.VersionIdNotSupported;

						Debug.LogFile.WriteLine("{5} field set version mismatch\t@{0:X8} [{1} !{2}] in {3}\t {4}",
							relativeOffset, state.Attribute.Version, header.Index,
							type_of, ts.GetExceptionDescription(),
							GetTypeString());
						throw new Exceptions.InvalidVersion(ts, state.Attribute.Version, header.Index);
					}

					int expected_size;
					if (!state.VersioningSizeIsValid(header, ts.Flags, out expected_size))
					{
						if (state.VersioningCanBeImplicitlyPerformed(header, ts.Flags))
						{
							needsUpgrading = true;
							useImplicitUpgrading = true;
						}
						else
						{
							failureReason = VersioningFailureReason.VersionIdMismatch;

							Debug.LogFile.WriteLine("{5} field set sizeof mismatch \t@{0:X8} [{1} !{2}] in {3}\t {4}",
								relativeOffset, expected_size, header.Size,
								type_of, ts.GetExceptionDescription(),
								GetTypeString());
							throw new Exceptions.InvalidVersion(ts, state.Attribute.Version, expected_size, header.Index, header.Size);
						}
					}
				}
			}
示例#6
0
			void VerifyHeaderCount(IO.ITagStream ts, Type type_of)
			{
				if (header.Count != expectedCount)
				{
					failureReason = VersioningFailureReason.CountMismatch;

					throw new Debug.ExceptionLog("{5} field set count mismatch \t@{0:X8} [{1} !{2}] in {3}\t {4}",
						relativeOffset, expectedCount, header.Count,
						type_of, ts.GetExceptionDescription(),
						GetTypeString());
				}
			}
示例#7
0
			void VerifyHeaderGroupTag(IO.ITagStream ts, Type type_of)
			{
				if (header.GroupTag != headerGroupTag.ID)
				{
					if(type == FieldType.Struct)
					{
						var groups = ts.Engine.VersionToStructCollection();
						int index = groups.FindGroupIndex(header.GroupTag);

						if(index == -1)
						{
							failureReason = VersioningFailureReason.GroupTagNotFound;

							Debug.LogFile.WriteLine("{5} field set signature failed (signature not found) \t@{0:X8} [{1} !{2}] in {3}\t {4}",
								relativeOffset, headerGroupTag.TagToString(), new string(TagGroup.FromUInt(header.GroupTag)),
								type_of, ts.GetExceptionDescription(),
								GetTypeString());
							throw new Exceptions.InvalidVersion(ts);
						}
					}

					failureReason = VersioningFailureReason.GroupTagMismatch;

					Debug.LogFile.WriteLine("{5} field set signature failed\t@{0:X8} [{1} !{2}] in {3}\t {4}",
						relativeOffset,
						headerGroupTag.TagToString(), new string(TagGroup.FromUInt(header.GroupTag)),
						type_of, ts.GetExceptionDescription(),
						GetTypeString());
					throw new Exceptions.InvalidVersion(ts);
				}
			}
示例#8
0
			public FieldSetVersioning(BlamVersion engine, FieldType container_type, DefinitionState state)
			{
				failureReason = VersioningFailureReason.None;
				relativeOffset = 0;
				expectedCount = 1;
				needsUpgrading = false;
				useImplicitUpgrading = false;
				header = new tag_fieldset_header();

				this.type = container_type;
				this.state = state;

				if(container_type != FieldType.Struct)
					this.headerGroupTag = Blam.MiscGroups.tbfd;
				else
				{
					var groups = engine.VersionToStructCollection();
					var sa = state.Attribute as StructAttribute;

					headerGroupTag = groups[sa.GroupIndex];
				}
			}