(*
    BSD 2-Clause License

    Copyright (c) 2018, 2019, Anton Krotov
    All rights reserved.
*)

MODULE PE32;

IMPORT BIN, LISTS, UTILS, WR := WRITER, mConst := CONSTANTS, CHL := CHUNKLISTS;


CONST

    SIZE_OF_DWORD = 4;
    SIZE_OF_WORD  = 2;

    SIZE_OF_IMAGE_EXPORT_DIRECTORY = 40;

    IMAGE_NUMBEROF_DIRECTORY_ENTRIES = 16;

    IMAGE_SIZEOF_SHORT_NAME = 8;

    SIZE_OF_IMAGE_FILE_HEADER* = 20;

    SIZE_OF_IMAGE_SECTION_HEADER* = 40;

    (* SectionHeader.Characteristics *)

    SHC_text  = 060000020H;
    SHC_data  = 0C0000040H;
    SHC_bss   = 0C00000C0H;

    SectionAlignment = 1000H;
    FileAlignment    =  200H;


TYPE

    WORD  = WCHAR;
    DWORD = INTEGER;

    NAME* = ARRAY IMAGE_SIZEOF_SHORT_NAME OF CHAR;


    IMAGE_DATA_DIRECTORY = RECORD

        VirtualAddress:  DWORD;
        Size:            DWORD

    END;


    IMAGE_OPTIONAL_HEADER = RECORD

        Magic:                        WORD;
        MajorLinkerVersion:           BYTE;
        MinorLinkerVersion:           BYTE;
        SizeOfCode:                   DWORD;
        SizeOfInitializedData:        DWORD;
        SizeOfUninitializedData:      DWORD;
        AddressOfEntryPoint:          DWORD;
        BaseOfCode:                   DWORD;
        BaseOfData:                   DWORD;
        ImageBase:                    DWORD;
        SectionAlignment:             DWORD;
        FileAlignment:                DWORD;
        MajorOperatingSystemVersion:  WORD;
        MinorOperatingSystemVersion:  WORD;
        MajorImageVersion:            WORD;
        MinorImageVersion:            WORD;
        MajorSubsystemVersion:        WORD;
        MinorSubsystemVersion:        WORD;
        Win32VersionValue:            DWORD;
        SizeOfImage:                  DWORD;
        SizeOfHeaders:                DWORD;
        CheckSum:                     DWORD;
        Subsystem:                    WORD;
        DllCharacteristics:           WORD;
        SizeOfStackReserve:           DWORD;
        SizeOfStackCommit:            DWORD;
        SizeOfHeapReserve:            DWORD;
        SizeOfHeapCommit:             DWORD;
        LoaderFlags:                  DWORD;
        NumberOfRvaAndSizes:          DWORD;

        DataDirectory: ARRAY IMAGE_NUMBEROF_DIRECTORY_ENTRIES OF IMAGE_DATA_DIRECTORY

    END;


    IMAGE_FILE_HEADER* = RECORD

        Machine*:               WORD;
        NumberOfSections*:      WORD;
        TimeDateStamp*:         DWORD;
        PointerToSymbolTable*:  DWORD;
        NumberOfSymbols*:       DWORD;
        SizeOfOptionalHeader*:  WORD;
        Characteristics*:       WORD

    END;


    IMAGE_NT_HEADERS = RECORD

        Signature:       ARRAY 4 OF BYTE;
        FileHeader:      IMAGE_FILE_HEADER;
        OptionalHeader:  IMAGE_OPTIONAL_HEADER

    END;


    IMAGE_SECTION_HEADER* = RECORD

        Name*: NAME;

        VirtualSize*,
        VirtualAddress*,
        SizeOfRawData*,
        PointerToRawData*,
        PointerToRelocations*,
        PointerToLinenumbers*:   DWORD;

        NumberOfRelocations*,
        NumberOfLinenumbers*:    WORD;

        Characteristics*:        DWORD

    END;


    IMAGE_EXPORT_DIRECTORY = RECORD

        Characteristics:       DWORD;
        TimeDateStamp:         DWORD;
        MajorVersion:          WORD;
        MinorVersion:          WORD;
        Name,
        Base,
        NumberOfFunctions,
        NumberOfNames,
        AddressOfFunctions,
        AddressOfNames,
        AddressOfNameOrdinals: DWORD

    END;


    VIRTUAL_ADDR = RECORD

        Code, Data, Bss, Import: INTEGER

    END;


    FILE = WR.FILE;


VAR

    msdos:           ARRAY 128 OF BYTE;
    PEHeader:        IMAGE_NT_HEADERS;
    SectionHeaders:  ARRAY 16 OF IMAGE_SECTION_HEADER;
    Relocations:     LISTS.LIST;
    bit64:           BOOLEAN;
    libcnt:          INTEGER;


PROCEDURE SIZE (): INTEGER;
    RETURN SIZE_OF_DWORD * (ORD(bit64) + 1)
END SIZE;


PROCEDURE Export (program: BIN.PROGRAM; DataRVA: INTEGER; VAR ExportDir: IMAGE_EXPORT_DIRECTORY): INTEGER;
BEGIN

    ExportDir.Characteristics        :=  0;
    ExportDir.TimeDateStamp          :=  PEHeader.FileHeader.TimeDateStamp;
    ExportDir.MajorVersion           :=  0X;
    ExportDir.MinorVersion           :=  0X;
    ExportDir.Name                   :=  program.modname + DataRVA;
    ExportDir.Base                   :=  0;
    ExportDir.NumberOfFunctions      :=  LISTS.count(program.exp_list);
    ExportDir.NumberOfNames          :=  ExportDir.NumberOfFunctions;
    ExportDir.AddressOfFunctions     :=  SIZE_OF_IMAGE_EXPORT_DIRECTORY;
    ExportDir.AddressOfNames         :=  ExportDir.AddressOfFunctions + ExportDir.NumberOfFunctions * SIZE_OF_DWORD;
    ExportDir.AddressOfNameOrdinals  :=  ExportDir.AddressOfNames     + ExportDir.NumberOfFunctions * SIZE_OF_DWORD

    RETURN SIZE_OF_IMAGE_EXPORT_DIRECTORY + ExportDir.NumberOfFunctions * (2 * SIZE_OF_DWORD + SIZE_OF_WORD)
END Export;


PROCEDURE align (n, _align: INTEGER): INTEGER;
BEGIN
    IF n MOD _align # 0 THEN
        n := n + _align - (n MOD _align)
    END

    RETURN n
END align;


PROCEDURE GetProcCount (lib: BIN.IMPRT): INTEGER;
VAR
    import: BIN.IMPRT;
    res:    INTEGER;

BEGIN
    res := 0;
    import := lib.next(BIN.IMPRT);
    WHILE (import # NIL) & (import.label # 0) DO
        INC(res);
        import := import.next(BIN.IMPRT)
    END

    RETURN res
END GetProcCount;


PROCEDURE GetImportSize (imp_list: LISTS.LIST): INTEGER;
VAR
    import: BIN.IMPRT;
    proccnt: INTEGER;
    procoffs: INTEGER;
    OriginalCurrentThunk,
    CurrentThunk: INTEGER;

BEGIN
    libcnt  := 0;
    proccnt := 0;
    import  := imp_list.first(BIN.IMPRT);
    WHILE import # NIL DO
        IF import.label = 0 THEN
            INC(libcnt)
        ELSE
            INC(proccnt)
        END;
        import := import.next(BIN.IMPRT)
    END;

    procoffs := 0;

    import  := imp_list.first(BIN.IMPRT);
    WHILE import # NIL DO
        IF import.label = 0 THEN
            import.OriginalFirstThunk := procoffs;
            import.FirstThunk := procoffs + (GetProcCount(import) + 1);
            OriginalCurrentThunk := import.OriginalFirstThunk;
            CurrentThunk := import.FirstThunk;
            procoffs := procoffs + (GetProcCount(import) + 1) * 2
        ELSE
            import.OriginalFirstThunk := OriginalCurrentThunk;
            import.FirstThunk := CurrentThunk;
            INC(OriginalCurrentThunk);
            INC(CurrentThunk)
        END;
        import := import.next(BIN.IMPRT)
    END

    RETURN (libcnt + 1) * 5 * SIZE_OF_DWORD + (proccnt + libcnt) * 2 * SIZE()
END GetImportSize;


PROCEDURE fixup (program: BIN.PROGRAM; Address: VIRTUAL_ADDR);
VAR
    reloc:   BIN.RELOC;
    iproc:   BIN.IMPRT;
    L:       INTEGER;
    delta:   INTEGER;
    AdrImp:  INTEGER;

BEGIN
    AdrImp := Address.Import + (libcnt + 1) * 5 * SIZE_OF_DWORD;

    reloc := program.rel_list.first(BIN.RELOC);
    WHILE reloc # NIL DO

        L := BIN.get32le(program.code, reloc.offset);
        delta := 3 - reloc.offset - Address.Code - 7 * ORD(bit64);

        CASE reloc.opcode OF

        |BIN.PICDATA:
              BIN.put32le(program.code, reloc.offset, L + Address.Data + delta)

        |BIN.PICCODE:
              BIN.put32le(program.code, reloc.offset, BIN.GetLabel(program, L) + Address.Code + delta)

        |BIN.PICBSS:
              BIN.put32le(program.code, reloc.offset, L + Address.Bss + delta)

        |BIN.PICIMP:
              iproc := BIN.GetIProc(program, L);
              BIN.put32le(program.code, reloc.offset, iproc.FirstThunk * SIZE() + AdrImp + delta)

        END;

        reloc := reloc.next(BIN.RELOC)
    END
END fixup;


PROCEDURE WriteWord (file: FILE; w: WORD);
BEGIN
    WR.Write16LE(file, ORD(w))
END WriteWord;


PROCEDURE WriteName* (File: FILE; name: NAME);
VAR
    i, nameLen: INTEGER;

BEGIN
    nameLen := LENGTH(name);

    FOR i := 0 TO nameLen - 1 DO
        WR.WriteByte(File, ORD(name[i]))
    END;

    i := LEN(name) - nameLen;
    WHILE i > 0 DO
        WR.WriteByte(File, 0);
        DEC(i)
    END

END WriteName;


PROCEDURE WriteSectionHeader* (file: FILE; h: IMAGE_SECTION_HEADER);
VAR
    i, nameLen: INTEGER;

BEGIN
    nameLen := LENGTH(h.Name);

    FOR i := 0 TO nameLen - 1 DO
        WR.WriteByte(file, ORD(h.Name[i]))
    END;

    i := LEN(h.Name) - nameLen;
    WHILE i > 0 DO
        WR.WriteByte(file, 0);
        DEC(i)
    END;

    WR.Write32LE(file, h.VirtualSize);
    WR.Write32LE(file, h.VirtualAddress);
    WR.Write32LE(file, h.SizeOfRawData);
    WR.Write32LE(file, h.PointerToRawData);
    WR.Write32LE(file, h.PointerToRelocations);
    WR.Write32LE(file, h.PointerToLinenumbers);

    WriteWord(file, h.NumberOfRelocations);
    WriteWord(file, h.NumberOfLinenumbers);

    WR.Write32LE(file, h.Characteristics)
END WriteSectionHeader;


PROCEDURE WriteFileHeader* (file: FILE; h: IMAGE_FILE_HEADER);
BEGIN
    WriteWord(file, h.Machine);
    WriteWord(file, h.NumberOfSections);

    WR.Write32LE(file, h.TimeDateStamp);
    WR.Write32LE(file, h.PointerToSymbolTable);
    WR.Write32LE(file, h.NumberOfSymbols);

    WriteWord(file, h.SizeOfOptionalHeader);
    WriteWord(file, h.Characteristics)
END WriteFileHeader;


PROCEDURE write* (program: BIN.PROGRAM; FileName: ARRAY OF CHAR; BaseAddress: INTEGER; console, dll, amd64: BOOLEAN);
VAR
    i, n: INTEGER;

    Size: RECORD

        Code, Data, Bss, Stack, Import, Reloc, Export: INTEGER

    END;

    Address: VIRTUAL_ADDR;

    File: FILE;

    import:       BIN.IMPRT;
    ImportTable:  CHL.INTLIST;

    ExportDir:  IMAGE_EXPORT_DIRECTORY;
    export:     BIN.EXPRT;


    PROCEDURE WriteExportDir (file: FILE; e: IMAGE_EXPORT_DIRECTORY);
    BEGIN
        WR.Write32LE(file, e.Characteristics);
        WR.Write32LE(file, e.TimeDateStamp);

        WriteWord(file, e.MajorVersion);
        WriteWord(file, e.MinorVersion);

        WR.Write32LE(file, e.Name);
        WR.Write32LE(file, e.Base);
        WR.Write32LE(file, e.NumberOfFunctions);
        WR.Write32LE(file, e.NumberOfNames);
        WR.Write32LE(file, e.AddressOfFunctions);
        WR.Write32LE(file, e.AddressOfNames);
        WR.Write32LE(file, e.AddressOfNameOrdinals)
    END WriteExportDir;


    PROCEDURE WriteOptHeader (file: FILE; h: IMAGE_OPTIONAL_HEADER);
    VAR
        i: INTEGER;

    BEGIN

        WriteWord(file, h.Magic);

        WR.WriteByte(file, h.MajorLinkerVersion);
        WR.WriteByte(file, h.MinorLinkerVersion);

        WR.Write32LE(file, h.SizeOfCode);
        WR.Write32LE(file, h.SizeOfInitializedData);
        WR.Write32LE(file, h.SizeOfUninitializedData);
        WR.Write32LE(file, h.AddressOfEntryPoint);
        WR.Write32LE(file, h.BaseOfCode);

        IF bit64 THEN
            WR.Write64LE(file, h.ImageBase)
        ELSE
            WR.Write32LE(file, h.BaseOfData);
            WR.Write32LE(file, h.ImageBase)
        END;

        WR.Write32LE(file, h.SectionAlignment);
        WR.Write32LE(file, h.FileAlignment);

        WriteWord(file, h.MajorOperatingSystemVersion);
        WriteWord(file, h.MinorOperatingSystemVersion);
        WriteWord(file, h.MajorImageVersion);
        WriteWord(file, h.MinorImageVersion);
        WriteWord(file, h.MajorSubsystemVersion);
        WriteWord(file, h.MinorSubsystemVersion);

        WR.Write32LE(file, h.Win32VersionValue);
        WR.Write32LE(file, h.SizeOfImage);
        WR.Write32LE(file, h.SizeOfHeaders);
        WR.Write32LE(file, h.CheckSum);

        WriteWord(file, h.Subsystem);
        WriteWord(file, h.DllCharacteristics);

        IF bit64 THEN
            WR.Write64LE(file, h.SizeOfStackReserve);
            WR.Write64LE(file, h.SizeOfStackCommit);
            WR.Write64LE(file, h.SizeOfHeapReserve);
            WR.Write64LE(file, h.SizeOfHeapCommit)
        ELSE
            WR.Write32LE(file, h.SizeOfStackReserve);
            WR.Write32LE(file, h.SizeOfStackCommit);
            WR.Write32LE(file, h.SizeOfHeapReserve);
            WR.Write32LE(file, h.SizeOfHeapCommit)
        END;

        WR.Write32LE(file, h.LoaderFlags);
        WR.Write32LE(file, h.NumberOfRvaAndSizes);

        FOR i := 0 TO LEN(h.DataDirectory) - 1 DO
            WR.Write32LE(file, h.DataDirectory[i].VirtualAddress);
            WR.Write32LE(file, h.DataDirectory[i].Size)
        END

    END WriteOptHeader;


    PROCEDURE WritePEHeader (file: FILE; h: IMAGE_NT_HEADERS);
    BEGIN
        WR.Write(file, h.Signature, LEN(h.Signature));
        WriteFileHeader(file, h.FileHeader);
        WriteOptHeader(file, h.OptionalHeader)
    END WritePEHeader;


    PROCEDURE InitSection (VAR section: IMAGE_SECTION_HEADER; Name: NAME; Characteristics: DWORD);
    BEGIN
        section.Name                  :=  Name;
        section.PointerToRelocations  :=  0;
        section.PointerToLinenumbers  :=  0;
        section.NumberOfRelocations   :=  0X;
        section.NumberOfLinenumbers   :=  0X;
        section.Characteristics       :=  Characteristics
    END InitSection;


BEGIN
    bit64 := amd64;
    Relocations := LISTS.create(NIL);

    Size.Code  := CHL.Length(program.code);
    Size.Data  := CHL.Length(program.data);
    Size.Bss   := program.bss;
    Size.Stack := program.stack;

    PEHeader.Signature[0] := 50H;
    PEHeader.Signature[1] := 45H;
    PEHeader.Signature[2] := 0;
    PEHeader.Signature[3] := 0;

    IF amd64 THEN
        PEHeader.FileHeader.Machine := 08664X
    ELSE
        PEHeader.FileHeader.Machine := 014CX
    END;

    PEHeader.FileHeader.NumberOfSections := WCHR(4 + ORD(dll));

    PEHeader.FileHeader.TimeDateStamp         :=  UTILS.UnixTime();
    PEHeader.FileHeader.PointerToSymbolTable  :=  0H;
    PEHeader.FileHeader.NumberOfSymbols       :=  0H;
    PEHeader.FileHeader.SizeOfOptionalHeader  :=  WCHR(0E0H + 10H * ORD(amd64));
    PEHeader.FileHeader.Characteristics       :=  WCHR(010EH + (20H - 100H) * ORD(amd64) + 2000H * ORD(dll));

    PEHeader.OptionalHeader.Magic                        :=  WCHR(010BH + 100H * ORD(amd64));
    PEHeader.OptionalHeader.MajorLinkerVersion           :=  mConst.vMajor;
    PEHeader.OptionalHeader.MinorLinkerVersion           :=  mConst.vMinor;
    PEHeader.OptionalHeader.SizeOfCode                   :=  align(Size.Code, FileAlignment);
    PEHeader.OptionalHeader.SizeOfInitializedData        :=  0;
    PEHeader.OptionalHeader.SizeOfUninitializedData      :=  0;
    PEHeader.OptionalHeader.AddressOfEntryPoint          :=  SectionAlignment;
    PEHeader.OptionalHeader.BaseOfCode                   :=  SectionAlignment;
    PEHeader.OptionalHeader.BaseOfData                   :=  PEHeader.OptionalHeader.BaseOfCode + align(Size.Code, SectionAlignment);
    PEHeader.OptionalHeader.ImageBase                    :=  BaseAddress;
    PEHeader.OptionalHeader.SectionAlignment             :=  SectionAlignment;
    PEHeader.OptionalHeader.FileAlignment                :=  FileAlignment;
    PEHeader.OptionalHeader.MajorOperatingSystemVersion  :=  1X;
    PEHeader.OptionalHeader.MinorOperatingSystemVersion  :=  0X;
    PEHeader.OptionalHeader.MajorImageVersion            :=  0X;
    PEHeader.OptionalHeader.MinorImageVersion            :=  0X;
    PEHeader.OptionalHeader.MajorSubsystemVersion        :=  4X;
    PEHeader.OptionalHeader.MinorSubsystemVersion        :=  0X;
    PEHeader.OptionalHeader.Win32VersionValue            :=  0H;
    PEHeader.OptionalHeader.SizeOfImage                  :=  SectionAlignment;
    PEHeader.OptionalHeader.SizeOfHeaders                :=  400H;
    PEHeader.OptionalHeader.CheckSum                     :=  0;
    PEHeader.OptionalHeader.Subsystem                    :=  WCHR((2 + ORD(console)) * ORD(~dll));
    PEHeader.OptionalHeader.DllCharacteristics           :=  0040X;
    PEHeader.OptionalHeader.SizeOfStackReserve           :=  Size.Stack;
    PEHeader.OptionalHeader.SizeOfStackCommit            :=  Size.Stack DIV 16;
    PEHeader.OptionalHeader.SizeOfHeapReserve            :=  100000H;
    PEHeader.OptionalHeader.SizeOfHeapCommit             :=  10000H;
    PEHeader.OptionalHeader.LoaderFlags                  :=  0;
    PEHeader.OptionalHeader.NumberOfRvaAndSizes          :=  IMAGE_NUMBEROF_DIRECTORY_ENTRIES;

    InitSection(SectionHeaders[0], ".text", SHC_text);
    SectionHeaders[0].VirtualSize           :=  Size.Code;
    SectionHeaders[0].VirtualAddress        :=  1000H;
    SectionHeaders[0].SizeOfRawData         :=  align(Size.Code, FileAlignment);
    SectionHeaders[0].PointerToRawData      :=  PEHeader.OptionalHeader.SizeOfHeaders;

    InitSection(SectionHeaders[1], ".data", SHC_data);
    SectionHeaders[1].VirtualSize           :=  Size.Data;
    SectionHeaders[1].VirtualAddress        :=  align(SectionHeaders[0].VirtualAddress + SectionHeaders[0].VirtualSize, SectionAlignment);
    SectionHeaders[1].SizeOfRawData         :=  align(Size.Data, FileAlignment);
    SectionHeaders[1].PointerToRawData      :=  SectionHeaders[0].PointerToRawData + SectionHeaders[0].SizeOfRawData;

    InitSection(SectionHeaders[2], ".bss", SHC_bss);
    SectionHeaders[2].VirtualSize           :=  Size.Bss;
    SectionHeaders[2].VirtualAddress        :=  align(SectionHeaders[1].VirtualAddress + SectionHeaders[1].VirtualSize, SectionAlignment);
    SectionHeaders[2].SizeOfRawData         :=  0;
    SectionHeaders[2].PointerToRawData      :=  SectionHeaders[1].PointerToRawData + SectionHeaders[1].SizeOfRawData;

    Size.Import := GetImportSize(program.imp_list);

    InitSection(SectionHeaders[3], ".idata", SHC_data);
    SectionHeaders[3].VirtualSize           :=  Size.Import + CHL.Length(program.import);
    SectionHeaders[3].VirtualAddress        :=  align(SectionHeaders[2].VirtualAddress + SectionHeaders[2].VirtualSize, SectionAlignment);
    SectionHeaders[3].SizeOfRawData         :=  align(SectionHeaders[3].VirtualSize, FileAlignment);
    SectionHeaders[3].PointerToRawData      :=  SectionHeaders[2].PointerToRawData + SectionHeaders[2].SizeOfRawData;

    Address.Code   := SectionHeaders[0].VirtualAddress + PEHeader.OptionalHeader.ImageBase;
    Address.Data   := SectionHeaders[1].VirtualAddress + PEHeader.OptionalHeader.ImageBase;
    Address.Bss    := SectionHeaders[2].VirtualAddress + PEHeader.OptionalHeader.ImageBase;
    Address.Import := SectionHeaders[3].VirtualAddress + PEHeader.OptionalHeader.ImageBase;

    fixup(program, Address);

    IF dll THEN
        Size.Export := Export(program, SectionHeaders[1].VirtualAddress, ExportDir);

        InitSection(SectionHeaders[4], ".edata", SHC_data);
        SectionHeaders[4].VirtualSize           :=  Size.Export + CHL.Length(program.export);
        SectionHeaders[4].VirtualAddress        :=  align(SectionHeaders[3].VirtualAddress + SectionHeaders[3].VirtualSize, SectionAlignment);
        SectionHeaders[4].SizeOfRawData         :=  align(SectionHeaders[4].VirtualSize, FileAlignment);
        SectionHeaders[4].PointerToRawData      :=  SectionHeaders[3].PointerToRawData + SectionHeaders[3].SizeOfRawData;
    END;

    FOR i := 0 TO IMAGE_NUMBEROF_DIRECTORY_ENTRIES - 1 DO
        PEHeader.OptionalHeader.DataDirectory[i].VirtualAddress := 0;
        PEHeader.OptionalHeader.DataDirectory[i].Size := 0
    END;

    IF dll THEN
        PEHeader.OptionalHeader.DataDirectory[0].VirtualAddress := SectionHeaders[4].VirtualAddress;
        PEHeader.OptionalHeader.DataDirectory[0].Size := SectionHeaders[4].VirtualSize
    END;

    PEHeader.OptionalHeader.DataDirectory[1].VirtualAddress := SectionHeaders[3].VirtualAddress;
    PEHeader.OptionalHeader.DataDirectory[1].Size := SectionHeaders[3].VirtualSize;

    FOR i := 0 TO ORD(PEHeader.FileHeader.NumberOfSections) - 1 DO
        INC(PEHeader.OptionalHeader.SizeOfInitializedData, SectionHeaders[i].SizeOfRawData)
    END;

    DEC(PEHeader.OptionalHeader.SizeOfInitializedData, SectionHeaders[0].SizeOfRawData);
    DEC(PEHeader.OptionalHeader.SizeOfInitializedData, SectionHeaders[2].SizeOfRawData);

    PEHeader.OptionalHeader.SizeOfUninitializedData := align(SectionHeaders[2].VirtualSize, FileAlignment);

    FOR i := 0 TO ORD(PEHeader.FileHeader.NumberOfSections) - 1 DO
        INC(PEHeader.OptionalHeader.SizeOfImage, align(SectionHeaders[i].VirtualSize, SectionAlignment))
    END;

    n := 0;
    BIN.InitArray(msdos, n, "4D5A80000100000004001000FFFF000040010000000000004000000000000000");
    BIN.InitArray(msdos, n, "0000000000000000000000000000000000000000000000000000000080000000");
    BIN.InitArray(msdos, n, "0E1FBA0E00B409CD21B8014CCD21546869732070726F6772616D2063616E6E6F");
    BIN.InitArray(msdos, n, "742062652072756E20696E20444F53206D6F64652E0D0A240000000000000000");

    File := WR.Create(FileName);

    WR.Write(File, msdos, LEN(msdos));

    WritePEHeader(File, PEHeader);

    FOR i := 0 TO ORD(PEHeader.FileHeader.NumberOfSections) - 1 DO
        WriteSectionHeader(File, SectionHeaders[i])
    END;

    WR.Padding(File, FileAlignment);

    CHL.WriteToFile(File, program.code);
    WR.Padding(File, FileAlignment);

    CHL.WriteToFile(File, program.data);
    WR.Padding(File, FileAlignment);

    n := (libcnt + 1) * 5;
    ImportTable := CHL.CreateIntList();

    FOR i := 0 TO (Size.Import - n * SIZE_OF_DWORD) DIV SIZE() + n - 1 DO
        CHL.PushInt(ImportTable, 0)
    END;

    i := 0;
    import := program.imp_list.first(BIN.IMPRT);
    WHILE import # NIL DO
        IF import.label = 0 THEN
            CHL.SetInt(ImportTable, i + 0, import.OriginalFirstThunk * SIZE() + SectionHeaders[3].VirtualAddress + n * SIZE_OF_DWORD);
            CHL.SetInt(ImportTable, i + 1, 0);
            CHL.SetInt(ImportTable, i + 2, 0);
            CHL.SetInt(ImportTable, i + 3, import.nameoffs + Size.Import + SectionHeaders[3].VirtualAddress);
            CHL.SetInt(ImportTable, i + 4, import.FirstThunk * SIZE() + SectionHeaders[3].VirtualAddress + n * SIZE_OF_DWORD);
            i := i + 5
        END;
        import := import.next(BIN.IMPRT)
    END;

    CHL.SetInt(ImportTable, i + 0, 0);
    CHL.SetInt(ImportTable, i + 1, 0);
    CHL.SetInt(ImportTable, i + 2, 0);
    CHL.SetInt(ImportTable, i + 3, 0);
    CHL.SetInt(ImportTable, i + 4, 0);

    import := program.imp_list.first(BIN.IMPRT);
    WHILE import # NIL DO
        IF import.label # 0 THEN
            CHL.SetInt(ImportTable, import.OriginalFirstThunk + n, import.nameoffs + Size.Import + SectionHeaders[3].VirtualAddress - 2);
            CHL.SetInt(ImportTable, import.FirstThunk + n,         import.nameoffs + Size.Import + SectionHeaders[3].VirtualAddress - 2)
        END;
        import := import.next(BIN.IMPRT)
    END;

    FOR i := 0 TO n - 1 DO
        WR.Write32LE(File, CHL.GetInt(ImportTable, i))
    END;

    FOR i := n TO CHL.Length(ImportTable) - 1 DO
        IF amd64 THEN
            WR.Write64LE(File, CHL.GetInt(ImportTable, i))
        ELSE
            WR.Write32LE(File, CHL.GetInt(ImportTable, i))
        END
    END;

    CHL.WriteToFile(File, program.import);
    WR.Padding(File, FileAlignment);

    IF dll THEN

        INC(ExportDir.AddressOfFunctions,    SectionHeaders[4].VirtualAddress);
        INC(ExportDir.AddressOfNames,        SectionHeaders[4].VirtualAddress);
        INC(ExportDir.AddressOfNameOrdinals, SectionHeaders[4].VirtualAddress);

        WriteExportDir(File, ExportDir);

        export := program.exp_list.first(BIN.EXPRT);
        WHILE export # NIL DO
            WR.Write32LE(File, export.label + SectionHeaders[0].VirtualAddress);
            export := export.next(BIN.EXPRT)
        END;

        export := program.exp_list.first(BIN.EXPRT);
        WHILE export # NIL DO
            WR.Write32LE(File, export.nameoffs + Size.Export + SectionHeaders[4].VirtualAddress);
            export := export.next(BIN.EXPRT)
        END;

        FOR i := 0 TO ExportDir.NumberOfFunctions - 1 DO
            WriteWord(File, WCHR(i))
        END;

        CHL.WriteToFile(File, program.export);
        WR.Padding(File, FileAlignment)
    END;

    WR.Close(File)
END write;


END PE32.