Exemple #1
0
 private void AppendRefTableString(string word)
 {
     if (!AsmRefEntries.Contains(word))
     {
         AsmRefEntries.Add(word);
     }
 }
Exemple #2
0
        private void Write(IParam param)
        {
            ParamType type = param.TypeKey;

            WriterParam.Write((byte)type);
            switch (type)
            {
            case ParamType.@struct:
            {
                var str   = param as ParamStruct;
                var entry = new RefTableEntry(str);
                StructRefEntries.Add(str, entry);
                AsmRefEntries.Add(entry);        //reserve a space in the file's RefEntries so they stay in order

                var start = WriterParam.BaseStream.Position - 1;
                WriterParam.Write(str.Nodes.Count);

                UnresolvedStructs.Add(new Tuple <int, ParamStruct>((int)WriterParam.BaseStream.Position, str));
                WriterParam.Write(0);

                foreach (var node in str.Nodes.OrderBy(x => x.Key))
                {
                    int hashIndex = AsmHashTable.IndexOf(node.Key);
                    int relOffset = (int)(WriterParam.BaseStream.Position - start);
                    entry.HashOffsets.Add(new KeyValuePair <int, int>(hashIndex, relOffset));

                    Write(node.Value);
                }
                break;
            }

            case ParamType.list:
            {
                var list     = param as ParamList;
                var startPos = WriterParam.BaseStream.Position - 1;
                int count    = list.Nodes.Count;

                WriterParam.Write(count);

                int[] offsets     = new int[count];
                long  ptrStartPos = WriterParam.BaseStream.Position;
                WriterParam.BaseStream.Seek(4 * count, SeekOrigin.Current);
                for (int i = 0; i < count; i++)
                {
                    var node = list.Nodes[i];
                    offsets[i] = (int)(WriterParam.BaseStream.Position - startPos);
                    Write(node);
                }
                var endPos = WriterParam.BaseStream.Position;
                WriterParam.BaseStream.Position = ptrStartPos;
                foreach (var offset in offsets)
                {
                    WriterParam.Write(offset);
                }
                WriterParam.BaseStream.Position = endPos;

                break;
            }

            default:
            {
                object value = (param as ParamValue).Value;
                switch (type)
                {
                case ParamType.@bool:
                    WriterParam.Write((bool)value);
                    break;

                case ParamType.@sbyte:
                    WriterParam.Write((sbyte)value);
                    break;

                case ParamType.@byte:
                    WriterParam.Write((byte)value);
                    break;

                case ParamType.@short:
                    WriterParam.Write((short)value);
                    break;

                case ParamType.@ushort:
                    WriterParam.Write((ushort)value);
                    break;

                case ParamType.@int:
                    WriterParam.Write((int)value);
                    break;

                case ParamType.@uint:
                    WriterParam.Write((uint)value);
                    break;

                case ParamType.@float:
                    WriterParam.Write((float)value);
                    break;

                case ParamType.hash40:
                    WriterParam.Write(AsmHashTable.IndexOf((ulong)value));
                    break;

                case ParamType.@string:
                    string word = (string)value;
                    UnresolvedStrings.Add(new Tuple <int, string>((int)WriterParam.BaseStream.Position, word));

                    AppendRefTableString(word);
                    WriterParam.Write(0);
                    break;
                }

                break;
            }
            }
        }