Example #1
0
        protected override void WriteRow(WritingContext context, MetadataRow <uint, uint> row)
        {
            var writer = context.Writer;

            writer.WriteUInt32(row.Column1);
            writer.WriteUInt32(row.Column2);
        }
        public override void Write(WritingContext context)
        {
            var writer = context.Writer;

            writer.WriteByte((byte)ElementType);
            writer.WriteCompressedUInt32((uint)Index);
        }
        protected override void WriteRow(WritingContext context, MetadataRow <uint, uint> row)
        {
            var writer = context.Writer;

            writer.WriteIndex(TableStream.GetTable(MetadataTokenType.TypeDef).IndexSize, row.Column1);
            writer.WriteIndex(TableStream.GetIndexEncoder(CodedIndex.TypeDefOrRef).IndexSize, row.Column2);
        }
Example #4
0
 public override void Write(WritingContext context)
 {
     foreach (var value in EnumerateGuids())
     {
         context.Writer.WriteBytes(value.ToByteArray());
     }
 }
Example #5
0
        public override void Write(WritingContext context)
        {
            if (!Validate())
            {
                throw new InvalidOperationException();
            }

            var writer = context.Writer;

            writer.WriteByte((byte)ElementType);
            BaseType.Write(context);
            writer.WriteCompressedUInt32((uint)Dimensions.Count);

            var sizedDimensions = Dimensions.Where(x => x.Size.HasValue).ToArray();

            writer.WriteCompressedUInt32((uint)sizedDimensions.Length);
            foreach (var sizedDimension in sizedDimensions)
            {
                writer.WriteCompressedUInt32((uint)sizedDimension.Size.Value);
            }

            var boundedDimensions = Dimensions.Where(x => x.LowerBound.HasValue).ToArray();

            writer.WriteCompressedUInt32((uint)boundedDimensions.Length);
            foreach (var boundedDimension in boundedDimensions)
            {
                writer.WriteCompressedUInt32((uint)boundedDimension.LowerBound.Value);
            }
        }
        public override void Write(WritingContext context)
        {
            var writer = context.Writer;

            writer.WriteByte((byte)NativeType);
            writer.WriteByte((byte)ElementType);
        }
 public override void Write(WritingContext context)
 {
     var writer = context.Writer;
     writer.WriteByte((byte)NativeType);
     writer.WriteCompressedUInt32((uint)NumberOfElements);
     writer.WriteByte((byte)ElementType);
 }
Example #8
0
 public override void Write(WritingContext context)
 {
     // TODO: more elegant way of creating buffer.
     context.Writer.Position += GetPhysicalLength();
     context.Writer.Position -= GetPhysicalLength();
     base.Write(context);
 }
Example #9
0
 public override void Write(WritingContext context)
 {
     foreach (var table in VTableHeaders)
     {
         table.Write(context);
     }
 }
Example #10
0
        public override void Write(WritingContext context)
        {
            var writer = context.Writer;

            writer.WriteUInt32(Reserved);
            writer.WriteByte(MajorVersion);
            writer.WriteByte(MinorVersion);
            writer.WriteByte(HeapSizes);
            writer.WriteByte(Reserved2);
            writer.WriteUInt64(ValidBitVector);
            writer.WriteUInt64(SortedBitVector);

            var presentTables = GetPresentTables().ToArray();

            foreach (var table in presentTables)
            {
                writer.WriteUInt32((uint)table.Count);
            }

            foreach (var table in presentTables)
            {
                table.Write(context);
            }

            writer.WriteUInt32(0);
        }
Example #11
0
 public override void Write(WritingContext context)
 {
     foreach (var guid in _guidOffsetMapping.Keys)
     {
         context.Writer.WriteBytes(guid.ToByteArray());
     }
 }
Example #12
0
        public override void Write(WritingContext context)
        {
            var writer = context.Writer;

            writer.WriteByte((byte)(0x2 | (Code.Length << 2)));
            writer.WriteBytes(Code);
        }
        public byte[] Serialize(BuildingContext context)
        {
            using (var stream = new MemoryStream())
            {
                var writer = new BigEndianStreamWriter(stream);

                writer.Write(MaxStack);
                writer.Write(MaxLocals);
                writer.Write(Code.Length);
                writer.Write(Code);

                writer.Write((ushort)ExceptionHandlers.Count);
                foreach (var handler in ExceptionHandlers)
                {
                    handler.Write(writer);
                }

                writer.Write((ushort)Attributes.Count);
                var writingContext = new WritingContext(writer);
                foreach (var attribute in Attributes)
                {
                    attribute.Write(writingContext);
                }

                return(stream.ToArray());
            }
        }
Example #14
0
 public override void Write(WritingContext context)
 {
     // TODO: more elegant way of creating buffer.
     context.Writer.Position += GetPhysicalLength();
     context.Writer.Position -= GetPhysicalLength();
     base.Write(context);
 }
Example #15
0
        protected override void WriteRow(WritingContext context, MetadataRow <uint, uint> row)
        {
            var writer = context.Writer;

            writer.WriteIndex(TableStream.GetIndexEncoder(CodedIndex.HasFieldMarshal).IndexSize, row.Column1);
            writer.WriteIndex(TableStream.BlobIndexSize, row.Column2);
        }
Example #16
0
        public override void Write(WritingContext context)
        {
            var writer = context.Writer;

            writer.WriteByte(0x06);
            FieldType.Write(context);
        }
 private ExcelSerializer(IXLRangeBase range, CsvConfiguration configuration)
 {
     Workbook      = range.Worksheet.Workbook;
     this.range    = range;
     Configuration = configuration ?? new CsvConfiguration(CultureInfo.InvariantCulture);
     Context       = new WritingContext(TextWriter.Null, Configuration, false);
 }
 public override void Write(WritingContext context)
 {
     var writer = context.Writer;
     writer.WriteByte((byte)ElementType);
     WriteTypeDefOrRef(context.Assembly.NetDirectory.MetadataHeader, context.Writer, ModifierType);
     BaseType.Write(context);
 }
Example #19
0
        protected override void WriteRow(WritingContext context, MetadataRow <uint, uint> row)
        {
            var writer = context.Writer;

            writer.WriteIndex(TableStream.GetTable(MetadataTokenType.Method).IndexSize, row.Column1);
            writer.WriteIndex(TableStream.BlobIndexSize, row.Column2);
        }
Example #20
0
        protected override void WriteRow(WritingContext context, MetadataRow <DataSegment, uint> row)
        {
            var writer = context.Writer;

            writer.WriteUInt32((uint)row.Column1.GetRva(context.Assembly));
            writer.WriteIndex(TableStream.GetTable(MetadataTokenType.Field).IndexSize, row.Column2);
        }
Example #21
0
        private void WriteExceptionHandlers(WritingContext context)
        {
            var useFatFormat = ExceptionHandlers.Any(x => x.IsFatFormatRequired);
            var writer       = context.Writer;

            writer.WriteByte((byte)(0x01 | (useFatFormat ? 0x40 : 0)));
            if (useFatFormat)
            {
                var byteLength = ExceptionHandlers.Count * 24;
                writer.WriteByte((byte)(byteLength & 0xFF));
                writer.WriteByte((byte)((byteLength & 0xFF00) >> 0x08));
                writer.WriteByte((byte)((byteLength & 0xFF0000) >> 0x10));
            }
            else
            {
                writer.WriteByte((byte)(ExceptionHandlers.Count * 12));
                writer.WriteUInt16(0);
            }

            foreach (var handler in ExceptionHandlers)
            {
                handler.IsFat = useFatFormat;
                handler.Write(context);
            }
        }
Example #22
0
 protected override void WriteRow(WritingContext context, MetadataRow<EventAttributes, uint, uint> row)
 {
     var writer = context.Writer;
     writer.WriteUInt16((ushort) row.Column1);
     writer.WriteIndex(TableStream.StringIndexSize, row.Column2);
     writer.WriteIndex(TableStream.GetIndexEncoder(CodedIndex.TypeDefOrRef).IndexSize, row.Column3);
 }
Example #23
0
        public override void Write(WritingContext context)
        {
            var stream = context.Writer;

            stream.WriteUInt32(VirtualAddress);
            stream.WriteUInt32(Size);
        }
Example #24
0
        public override void Write(WritingContext context)
        {
            var writer = context.Writer;

            writer.WriteByte((byte)ElementType);

            WriteTypeDefOrRef(context.Assembly.NetDirectory.MetadataHeader, context.Writer, Type);
        }
Example #25
0
        protected override void WriteRow(WritingContext context, MetadataRow <ushort, uint, uint> row)
        {
            var writer = context.Writer;

            writer.WriteUInt16(row.Column1);
            writer.WriteUInt32(row.Column2);
            writer.WriteIndex(TableStream.GetTable(MetadataTokenType.TypeDef).IndexSize, row.Column3);
        }
Example #26
0
        protected override void WriteMember(WritingContext context, AssemblyRefProcessor member)
        {
            var writer = context.Writer;
            var row    = member.MetadataRow;

            writer.WriteUInt32(row.Column1);
            writer.WriteIndex(TableStream.GetTable <AssemblyReference>().IndexSize, row.Column2);
        }
 public override void Write(WritingContext context)
 {
     var writer = context.Writer;
     writer.WriteByte((byte)'.');
     writer.WriteCompressedUInt32((uint)Attributes.Count);
     foreach (var attribute in Attributes)
         attribute.Write(context);
 }
 public override void Write(WritingContext context)
 {
     var writer = context.Writer;
     writer.WriteByte(0x07);
     writer.WriteCompressedUInt32((uint)Variables.Count);
     foreach (var variable in Variables)
         variable.Write(context);
 }
        public override void Write(WritingContext context)
        {
            base.Write(context);
            var writer = context.Writer;

            writer.Write(ClassIndex);
            writer.Write(NameAndTypeIndex);
        }
Example #30
0
 public override void Write(WritingContext context)
 {
     foreach (var segment in Segments)
     {
         context.Writer.Position = segment.StartOffset;
         segment.Write(context);
     }
 }
Example #31
0
        public override void Write(WritingContext context)
        {
            base.Write(context);
            var writer = context.Writer;

            writer.Write((byte)ReferenceKind);
            writer.Write(ReferenceIndex);
        }
 public override void Write(WritingContext context)
 {
     var writer = context.Writer;
     writer.WriteByte(0x0A);
     writer.WriteCompressedUInt32((uint)GenericArguments.Count);
     foreach (var argument in GenericArguments)
         argument.Write(context);
 }
Example #33
0
        protected override void WriteMember(WritingContext context, GenericParameterConstraint member)
        {
            var writer = context.Writer;
            var row    = member.MetadataRow;

            writer.WriteIndex(TableStream.GetTable <GenericParameter>().IndexSize, row.Column1);
            writer.WriteIndex(TableStream.GetIndexEncoder(CodedIndex.TypeDefOrRef).IndexSize, row.Column2);
        }
Example #34
0
        protected override void WriteMember(WritingContext context, FieldRva member)
        {
            var writer = context.Writer;
            var row    = member.MetadataRow;

            writer.WriteUInt32(row.Column1);
            writer.WriteIndex(TableStream.GetTable <FieldDefinition>().IndexSize, row.Column2);
        }
Example #35
0
        protected override void WriteRow(WritingContext context, MetadataRow <SecurityAction, uint, uint> row)
        {
            var writer = context.Writer;

            writer.WriteUInt16((ushort)row.Column1);
            writer.WriteIndex(TableStream.GetIndexEncoder(CodedIndex.HasDeclSecurity).IndexSize, row.Column2);
            writer.WriteIndex(TableStream.BlobIndexSize, row.Column3);
        }
Example #36
0
        public override void Write(WritingContext context)
        {
            base.Write(context);
            var writer = context.Writer;

            writer.Write(NameIndex);
            writer.Write(DescriptorIndex);
        }
Example #37
0
        protected override void WriteRow(WritingContext context, MetadataRow <FileAttributes, uint, uint> row)
        {
            var writer = context.Writer;

            writer.WriteUInt32((uint)row.Column1);
            writer.WriteIndex(TableStream.StringIndexSize, row.Column2);
            writer.WriteIndex(TableStream.BlobIndexSize, row.Column3);
        }
 public override void Write(WritingContext context)
 {
     var writer = context.Writer;
     writer.WriteByte((byte)NativeType);
     writer.WriteSerString(Guid.ToString("B"));
     writer.WriteSerString(UnmanagedType);
     writer.WriteSerString(ManagedType);
     writer.WriteSerString(Cookie);
 }
Example #39
0
 public override void Write(WritingContext context)
 {
     var writer = context.Writer;
     writer.WriteByte((byte)Attributes);
     writer.WriteCompressedUInt32((uint)Parameters.Count);
     PropertyType.Write(context);
     foreach (var parameter in Parameters)
         parameter.Write(context);
 }
Example #40
0
        public override void Write(WritingContext context)
        {
            if (Value == null)
                throw new ArgumentNullException();

            var writer = context.Writer;
            switch (Type.GetTypeCode(Value.GetType()))
            {
                case TypeCode.Boolean:
                    writer.WriteByte((byte)((bool)Value ? 1 : 0));
                    break;
                case TypeCode.Byte:
                    writer.WriteByte((byte)Value);
                    break;
                case TypeCode.Char:
                    writer.WriteUInt16((char)Value);
                    break;
                case TypeCode.Double:
                    writer.WriteDouble((double)Value);
                    break;
                case TypeCode.Int16:
                    writer.WriteInt16((short)Value);
                    break;
                case TypeCode.Int32:
                    writer.WriteInt32((int)Value);
                    break;
                case TypeCode.Int64:
                    writer.WriteInt64((long)Value);
                    break;
                case TypeCode.SByte:
                    writer.WriteSByte((sbyte)Value);
                    break;
                case TypeCode.Single:
                    writer.WriteSingle((float)Value);
                    break;
                case TypeCode.String:
                    writer.WriteSerString((string)Value);
                    break;
                case TypeCode.UInt16:
                    writer.WriteUInt16((ushort)Value);
                    break;
                case TypeCode.UInt32:
                    writer.WriteUInt32((uint)Value);
                    break;
                case TypeCode.UInt64:
                    writer.WriteUInt64((ulong)Value);
                    break;
                default:
                    var typeSignature = Value as TypeSignature;
                    if (typeSignature != null)
                        writer.WriteSerString(TypeNameBuilder.GetAssemblyQualifiedName(typeSignature));
                    else
                        throw new NotSupportedException();
                    break;
            }
        }
 public override void Write(WritingContext context)
 {
     var writer = context.Writer;
     writer.WriteUInt16(0x0001);
     foreach (var argument in FixedArguments)
         argument.Write(context);
     writer.WriteUInt16((ushort)NamedArguments.Count);
     foreach (var argument in NamedArguments)
         argument.Write(context);
 }
 public override void Write(WritingContext context)
 {
     var writer = context.Writer;
     writer.WriteByte((byte)NativeType);
     writer.WriteByte((byte)ElementType);
     if (ParameterIndex.HasValue)
     {
         writer.WriteCompressedUInt32((uint)ParameterIndex.Value);
         if (NumberOfElements.HasValue)
             writer.WriteCompressedUInt32((uint)NumberOfElements.Value);
     }
 }
        public override void Write(WritingContext context)
        {
            var writer = context.Writer;
            writer.WriteSerString(TypeName);

            if (NamedArguments.Count == 0)
            {
                writer.WriteCompressedUInt32(1);
                writer.WriteCompressedUInt32(0);
            }
            else
            {
                writer.WriteCompressedUInt32(
                    (uint)(NamedArguments.Count.GetCompressedSize() + NamedArguments.Sum(x => x.GetPhysicalLength())));
                writer.WriteCompressedUInt32((uint)NamedArguments.Count);
                foreach (var argument in NamedArguments)
                {
                    argument.Write(context);
                }
            }
        }
Example #44
0
        public override void Write(WritingContext context)
        {
            var writer = context.Writer;
            writer.WriteByte((byte)Attributes);

            if (IsGeneric)
                writer.WriteCompressedUInt32((uint)GenericParameterCount);

            writer.WriteCompressedUInt32((uint)Parameters.Count);
            ReturnType.Write(context);
            foreach (var parameter in Parameters)
                parameter.Write(context);
        }
 public override void Write(WritingContext context)
 {
     context.Writer.WriteByte((byte)ElementType);
     BaseType.Write(context);
 }
Example #46
0
        private void WriteCode(WritingContext context)
        {
            var builder = new MethodBodyOperandBuilder((NetBuildingContext)context.BuildingContext, this);
            var assembler = new MsilAssembler(builder, context.Writer);

            foreach (var instruction in Instructions)
                assembler.Write(instruction);
        }
Example #47
0
        public sealed override void Save(StreamHandler writer)
        {
            var elements = this.PacketElements;
            var ctx = new WritingContext(writer);

            for (int i = 0; i < elements.Length; i++)
                s_writing[(int)elements[i]](this, ctx);
        }
Example #48
0
 public override void Write(WritingContext context)
 {
     var writer = context.Writer;
     writer.WriteByte(0x06);
     FieldType.Write(context);
 }
Example #49
0
 public override void Write(WritingContext context)
 {
     foreach (var table in VTableHeaderHeaders)
         table.Write(context);
 }
Example #50
0
 public override void Write(WritingContext context)
 {
     var writer = context.Writer;
     writer.WriteUInt32(Rva);
     writer.WriteUInt16((ushort)Table.Count);
     writer.WriteUInt16((ushort)Attributes);
 }
Example #51
0
        public override void Write(WritingContext context)
        {
            var writer = context.Writer;
            if (IsFat)
            {
                writer.WriteUInt32((uint)HandlerType);
                writer.WriteUInt32((uint)TryStart.Offset);
                writer.WriteUInt32((uint)(TryEnd.Offset - TryStart.Offset));
                writer.WriteUInt32((uint)HandlerStart.Offset);
                writer.WriteUInt32((uint)(HandlerEnd.Offset - HandlerStart.Offset));
            }
            else
            {
                writer.WriteUInt16((ushort)HandlerType);
                writer.WriteUInt16((ushort)TryStart.Offset);
                writer.WriteByte((byte)(TryEnd.Offset - TryStart.Offset));
                writer.WriteUInt16((ushort)HandlerStart.Offset);
                writer.WriteByte((byte)(HandlerEnd.Offset - HandlerStart.Offset));
            }

            switch (HandlerType)
            {
                case ExceptionHandlerType.Exception:
                    writer.WriteUInt32(CatchType.MetadataToken.ToUInt32());
                    break;
                case ExceptionHandlerType.Filter:
                    writer.WriteUInt32((uint)FilterStart.Offset);
                    break;
                default:
                    writer.WriteUInt32(0);
                    break;
            }
        }
Example #52
0
 public override void Write(WritingContext context)
 {
     context.Writer.WriteBytes(Data);
 }
Example #53
0
        public override void Write(WritingContext context)
        {
            var writer = context.Writer;

            if (IsFat)
            {
                writer.WriteUInt16((ushort)((ExceptionHandlers.Count > 0 ? 0x8 : 0) |
                                            (InitLocals ? 0x10 : 0) | 0x3003));
                writer.WriteUInt16((ushort)MaxStack);
                writer.WriteUInt32(GetCodeSize());
                writer.WriteUInt32(Signature == null ? 0 : Signature.MetadataToken.ToUInt32());
            }
            else
            {
                writer.WriteByte((byte)(0x2 | GetCodeSize() << 2));
            }

            WriteCode(context);

            if (ExceptionHandlers.Count > 0)
                WriteExceptionHandlers(context);
        }
Example #54
0
 public override void Write(WritingContext context)
 {
     var writer = context.Writer;
     writer.WriteUInt32(Cb);
     writer.WriteUInt16(MajorRuntimeVersion);
     writer.WriteUInt16(MinorRuntimeVersion);
     MetadataDirectory.Write(context);
     writer.WriteUInt32((uint)Flags);
     writer.WriteUInt32(EntryPointToken);
     ResourcesDirectory.Write(context);
     StrongNameSignatureDirectory.Write(context);
     CodeManagerTableDirectory.Write(context);
     VTableFixupsDirectory.Write(context);
     ExportAddressTableJumpsDirectory.Write(context);
     ManagedNativeHeaderDirectory.Write(context);
 }
 public override void Write(WritingContext context)
 {
     var writer = context.Writer;
     writer.WriteByte((byte)NativeType);
     writer.WriteByte((byte)ElementType);
 }
 public override void Write(WritingContext context)
 {
     context.Writer.WriteByte((byte) ElementType.FnPtr);
     Signature.Write(context);
 }
        public override void Write(WritingContext context)
        {
            var writer = context.Writer;
            writer.WriteByte((byte)ElementType);
            writer.WriteByte((byte)(IsValueType ? ElementType.ValueType : ElementType.Class));

            WriteTypeDefOrRef(context.Assembly.NetDirectory.MetadataHeader, context.Writer, GenericType);

            writer.WriteCompressedUInt32((uint)GenericArguments.Count);
            foreach (var argument in GenericArguments)
                argument.Write(context);
        }
Example #58
0
 public override void Write(WritingContext context)
 {
     VariableType.Write(context);
 }
 public override void Write(WritingContext context)
 {
     var writer = context.Writer;
     writer.WriteUInt32(OffsetToData);
     writer.WriteUInt32(Size);
     writer.WriteUInt32(CodePage);
     writer.WriteUInt32(Reserved);
 }
Example #60
0
        private void WriteExceptionHandlers(WritingContext context)
        {
            var useFatFormat = ExceptionHandlers.Any(x => x.IsFatFormatRequired);
            var writer = context.Writer;

            writer.Align(4);

            writer.WriteByte((byte)(0x01 | (useFatFormat ? 0x40 : 0)));
            if (useFatFormat)
            {
                var byteLength = ExceptionHandlers.Count * 24;
                writer.WriteByte((byte)(byteLength & 0xFF));
                writer.WriteByte((byte)((byteLength & 0xFF00) >> 0x08));
                writer.WriteByte((byte)((byteLength & 0xFF0000) >> 0x10));
            }
            else
            {
                writer.WriteByte((byte)(ExceptionHandlers.Count * 12));
                writer.WriteUInt16(0);
            }

            foreach (var handler in ExceptionHandlers)
            {
                handler.IsFat = useFatFormat;
                handler.Write(context);
            }
        }