예제 #1
0
        public DAIGuid GetDaiGuidFieldValue(DAIField field)
        {
            Debug.Assert(field.ValueType == DAIFieldType.DAI_Guid, "this method can only be applied to GUID fields");

            var  guid      = new DAIGuid();
            uint UIntValue = field.GetUIntValue();

            if ((UIntValue >> 31) == 1)
            {
                /* External Guid */
                DAIExternalGuid Guid = this.ExternalGuids.ElementAt((int)(UIntValue & 0x7fffffff));
                guid.external     = true;
                guid.fileGuid     = GuidToString(Guid.FileGuid);
                guid.instanceGuid = GuidToString(Guid.InstanceGuid);
            }
            else if (UIntValue == 0)
            {
                /* NULL Guid */
                guid.instanceGuid = "null";
            }
            else
            {
                /* Internal Guid */
                byte[] Guid = this.InternalGuids[(int)(UIntValue - 1)];
                guid.instanceGuid = GuidToString(Guid);
            }

            return(guid);
        }
예제 #2
0
        private static DAIField wrapWithFakeField(DAIComplex value)
        {
            var fakeField = new DAIField();

            fakeField.ValueType    = DAIFieldType.DAI_Complex;
            fakeField.ComplexValue = value;
            return(fakeField);
        }
예제 #3
0
        public DAIField ReadField(Stream s, int FieldIndex)
        {
            DAIField Field = new DAIField();

            Field.Descriptor = FieldDescriptors[FieldIndex];
            Field.Offset     = s.Position;

            int FieldType = (Field.Descriptor.FieldType & 0xFFFF);

            if (FieldType == 0x29 || FieldType == 0xd029 || FieldType == 0x00 || FieldType == 0x8029)
            {
                Field.ComplexValue = ReadComplex(s, Field.Descriptor.ComplexReference);
                Field.ValueType    = DAIFieldType.DAI_Complex;
            }
            else if (FieldType == 0x407d || FieldType == 0x409d)
            {
                String StrValue     = "";
                Int64  PrevPos      = s.Position;
                int    StringOffset = Tools.ReadInt(s);

                if (StringOffset == -1)
                {
                    StrValue = "";
                }
                else
                {
                    s.Seek(Header.StringOffset + StringOffset, SeekOrigin.Begin);
                    StrValue = Tools.ReadNullString(s);

                    s.Seek(PrevPos + 4, SeekOrigin.Begin);
                }

                Field.Value = new byte[StrValue.Length];
                for (int i = 0; i < StrValue.Length; i++)
                {
                    Field.Value[i] = (byte)StrValue[i];
                }
                Field.ValueType = DAIFieldType.DAI_String;
            }
            else if (FieldType == 0x35)
            {
                uint UIntValue = Tools.ReadUInt(s);
                Field.ValueType = DAIFieldType.DAI_Guid;
                Field.Value     = BitConverter.GetBytes(UIntValue);
            }
            else if (FieldType == 0xc10d)
            {
                uint UIntValue = Tools.ReadUInt(s);
                Field.Value     = BitConverter.GetBytes(UIntValue);
                Field.ValueType = DAIFieldType.DAI_UInt;
            }
            else if (FieldType == 0xc0fd)
            {
                int IntValue = Tools.ReadInt(s);
                Field.Value     = BitConverter.GetBytes(IntValue);
                Field.ValueType = DAIFieldType.DAI_Int;
            }
            else if (FieldType == 0x417d)
            {
                Int64 LongValue = Tools.ReadLong(s);
                Field.Value     = BitConverter.GetBytes(LongValue);
                Field.ValueType = DAIFieldType.DAI_Long;
            }
            else if (FieldType == 0xc13d)
            {
                float FloatValue = Tools.ReadFloat(s);
                Field.Value     = BitConverter.GetBytes(FloatValue);
                Field.ValueType = DAIFieldType.DAI_Float;
            }
            else if (FieldType == 0xc0ad)
            {
                byte ByteValue = (byte)s.ReadByte();
                Field.Value     = new byte[] { ByteValue };
                Field.ValueType = DAIFieldType.DAI_Bool;
            }
            else if (FieldType == 0xc0bd)
            {
                byte ByteValue = (byte)s.ReadByte();
                Field.Value     = new byte[] { ByteValue };
                Field.ValueType = DAIFieldType.DAI_Byte;
            }
            else if (FieldType == 0xc0cd)
            {
                byte ByteValue = (byte)s.ReadByte();
                Field.Value     = new byte[] { ByteValue };
                Field.ValueType = DAIFieldType.DAI_UByte;
            }
            else if (FieldType == 0xc0dd)
            {
                ushort UShortValue = Tools.ReadUShort(s);
                Field.Value     = BitConverter.GetBytes(UShortValue);
                Field.ValueType = DAIFieldType.DAI_UShort;
            }
            else if (FieldType == 0xc0ed)
            {
                short ShortValue = Tools.ReadShort(s);
                Field.Value     = BitConverter.GetBytes(ShortValue);
                Field.ValueType = DAIFieldType.DAI_Short;
            }
            else if (FieldType == 0xc15d)
            {
                byte[] Value = new byte[16];
                for (int i = 0; i < 16; i++)
                {
                    Value[i] = (byte)s.ReadByte();
                }

                Field.Value     = Value;
                Field.ValueType = DAIFieldType.DAI_LongLong;
            }
            else if (FieldType == 0x89 || FieldType == 0xc089)
            {
                String EnumValue = "";

                int CompareValue = Tools.ReadInt(s);
                DAIComplexDescriptor EnumComplex = ComplexDescriptors[Field.Descriptor.ComplexReference];

                if (EnumComplex.FieldCount != 0)
                {
                    for (int i = EnumComplex.FieldStartIndex; i < EnumComplex.FieldStartIndex + EnumComplex.FieldCount; i++)
                    {
                        if (FieldDescriptors[i].PayloadOffset == CompareValue)
                        {
                            EnumValue = FieldDescriptors[i].FieldName;
                            break;
                        }
                    }
                }

                Field.Value = new byte[EnumValue.Length];
                for (int i = 0; i < EnumValue.Length; i++)
                {
                    Field.Value[i] = (byte)EnumValue[i];
                }
                Field.ValueType = DAIFieldType.DAI_Enum;
            }
            else if (FieldType == 0x41)
            {
                int Index = Tools.ReadInt(s);
                DAIArrayRepeater     ArrayRepeater    = ArrayRepeaters[Index];
                DAIComplexDescriptor ArrayComplexDesc = ComplexDescriptors[Field.Descriptor.ComplexReference];

                s.Seek(Header.ArraySectionStart + ArrayRepeater.Offset, SeekOrigin.Begin);
                DAIComplex ArrayComplex = new DAIComplex();
                ArrayComplex.Descriptor = ArrayComplexDesc;
                ArrayComplex.Offset     = s.Position;

                ArrayComplex.Fields = new List <DAIField>();
                for (int i = 0; i < ArrayRepeater.Count; i++)
                {
                    ArrayComplex.Fields.Add(ReadField(s, ArrayComplexDesc.FieldStartIndex));
                }

                Field.ComplexValue = ArrayComplex;
                Field.ValueType    = DAIFieldType.DAI_Array;
            }
            else
            {
            }

            return(Field);
        }
예제 #4
0
        private static AValue convert(DAIField field, ConverterContext ctx)
        {
            AValue result;

            if (field.ValueType == DAIFieldType.DAI_Complex)
            {
                var value = field.GetComplexValue();

                if (value == null)
                {
                    result = new ASimpleValue("{null}");
                }
                else
                {
                    var astruct = new AStruct();
                    astruct.name = value.GetName();

                    foreach (var childField in value.Fields)
                    {
                        AValue convertedChild = convert(childField, ctx);
                        var    childFieldName = childField.Descriptor.FieldName;
                        astruct.fields.Add(childFieldName, convertedChild);
                        astruct.correspondingDaiFields.Add(childFieldName, childField);
                    }

                    result = astruct;
                }
            }
            else if (field.ValueType == DAIFieldType.DAI_Array)
            {
                var value  = field.GetArrayValue();
                var aarray = new AArray();

                foreach (var memberField in value.Fields)
                {
                    AValue convertedMember = convert(memberField, ctx);
                    aarray.elements.Add(convertedMember);
                    aarray.correspondingDaiFields.Add(memberField);
                }

                result = aarray;
            }
            else if (field.ValueType == DAIFieldType.DAI_Guid)
            {
                var guid = ctx.file.GetDaiGuidFieldValue(field);

                if (guid.instanceGuid.Equals("null"))
                {
                    result = new ANullRef();
                }
                else
                {
                    if (guid.external)
                    {
                        var aexref = new AExRef(guid.fileGuid, guid.instanceGuid);
                        ctx.extRefs.Add(new Tuple <AExRef, string>(aexref, ctx.instanceGuid));
                        result = aexref;
                    }
                    else
                    {
                        var ainref = new AIntRef(guid.instanceGuid);
                        ctx.intReferences.Add(new Tuple <AIntRef, string>(ainref, ctx.instanceGuid));
                        result = ainref;
                    }
                }
            }
            else
            {
                String strValue;

                switch (field.ValueType)
                {
                case DAIFieldType.DAI_String:
                    strValue = field.GetStringValue();
                    break;

                case DAIFieldType.DAI_Enum:
                    strValue = field.GetEnumValue();
                    break;

                case DAIFieldType.DAI_Int:
                    strValue = field.GetIntValue().ToString();
                    break;

                case DAIFieldType.DAI_UInt:
                    strValue = field.GetUIntValue().ToString();
                    break;

                case DAIFieldType.DAI_Double:
                case DAIFieldType.DAI_Float:
                    strValue = field.GetFloatValue().ToString();
                    break;

                case DAIFieldType.DAI_Short:
                    strValue = field.GetShortValue().ToString();
                    break;

                case DAIFieldType.DAI_UShort:
                    strValue = field.GetUShortValue().ToString();
                    break;

                case DAIFieldType.DAI_Byte:
                case DAIFieldType.DAI_UByte:
                    strValue = field.GetByteValue().ToString();
                    break;

                case DAIFieldType.DAI_Long:
                    strValue = field.GetLongValue().ToString();
                    break;

                case DAIFieldType.DAI_LongLong:
                    strValue = "LL " + DAIEbx.GuidToString(field.GetLongLongValue());
                    break;

                case DAIFieldType.DAI_Bool:
                    strValue = field.GetBoolValue().ToString();
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }

                result = new ASimpleValue(strValue, tryUnhash(strValue));
            }

            return(result);
        }