objfileconsts.pas

SrcDecompiler is about creating a Delphi program decompiler. The program is written for Delphi 4 or

unit ObjFileConsts;

interface

uses
  Procs;

const
  AbstractErrorProcName = '@AbstractError';
  InitResStringImportsProcName = '@InitResStringImports';
  InitImportsProcName = '@InitImports';
  HandleOnExceptionProcName = '@HandleOnException'; 

type
  PProc = ^TProc;
  
  PHCBlock = ^THCBlock;
  THCBlock = record
    Size: Integer;
    RAC: Integer;
    RA: Pointer; // ^array[0..RAC-1] of TRA  Reference addresses to proc.
    ValC: Integer;
    Val: Pointer; // ^array[0..ValC-1] of  TVal
    VarsC: Integer;
    Vars: Pointer; // ^array[0..VarsC-1] of TCVar Vars
    IAC: Integer;
    IA: Pointer; // ^array[0..IAC-1] of TIA internal addresses
    PRC: Integer;
    PR: Pointer; // ^array[0..PRC-1] of TPR proc refs.
  end;

  TRA = record
    RA: Integer;     // Relative address
    PN: string;      // proc name
    CN: string;      // class name
    PV: PProc;       // Proc var
    PT: TProcType;   // Proc type (ptProcedure or ptMethodProcedure by default)
    Source: string;  // Source of the unit.
  end;
  
  PRAArray = ^TRAArray;
  TRAArray = array[0..$FFFF] of TRA;
  TVal = record
    RA: Integer;
    Count: Integer;
    Val: Pointer; // ^array[0..Count-1] of Byte;
  end;
  PValArray = ^TValArray;
  TValArray = array[0..$FFFF] of TVal;
  TCVar = record
    RA: Integer;
    VN: string; // var name
    VRA: Integer; // Offset of the var.
  end;
  TVarArray = array[0..$FFFF] of TCVar;
  TIA = record
    RA: Integer;
    RRA: Integer; // referenced relative address
  end;
  TIAArray = array[0..$FFFF] of TIA;
  TPR = record
    RA: Integer;
    PN: string;
    CN: string;
  end;
  TPRArray = array[0..$FFFF] of TPR;

const
  HCBlock0RA: array[0..0] of TRA = (
    (RA: $0; PN: 'GetBlockDesc'; CN: ''));
  HCBlock0Val0: array[0..2] of byte = (
    $53, $56, $BE);
  HCBlock0Val1: array[0..12] of byte = (
    $83, $3E, $00, $75, $3A, $68, $44, $06, $00, $00, $6A, $00, $E8);
  HCBlock0Val2: array[0..11] of byte = (
    $8B, $C8, $85, $C9, $75, $05, $33, $C0, $5E, $5B, $C3, $A1);
  HCBlock0Val3: array[0..3] of byte = (
    $89, $01, $89, $0D);
  HCBlock0Val4: array[0..30] of byte = (
    $33, $D2, $8B, $C2, $03, $C0, $8D, $44, $C1, $04, $8B, $1E, $89, $18, $89, $06, 
    $42, $83, $FA, $64, $75, $EC, $8B, $06, $8B, $10, $89, $16, $5E, $5B, $C3);
  HCBlock0Val: array[0..4] of TVal = (
    (RA: $0; Count: length(HCBlock0Val0); Val: @HCBlock0Val0), 
    (RA: $7; Count: length(HCBlock0Val1); Val: @HCBlock0Val1),
    (RA: $18; Count: length(HCBlock0Val2); Val: @HCBlock0Val2), 
    (RA: $28; Count: length(HCBlock0Val3); Val: @HCBlock0Val3), 
    (RA: $30; Count: length(HCBlock0Val4); Val: @HCBlock0Val4));
  HCBlock0Vars: array[0..1] of TCVar = (
    (RA: $3; VN: 'blockDescFreeList'), 
    (RA: $24; VN: 'blockDescBlockList'));
  HCBlock0: THCBlock = (
    Size: $50;
    RAC: length(HCBlock0RA); RA: @HCBlock0RA;
    ValC: length(HCBlock0Val); Val: @HCBlock0Val;
    VarsC: length(HCBlock0Vars); Vars: @HCBlock0Vars;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock1RA: array[0..0] of TRA = (
    (RA: $0; PN: 'MakeEmpty'; CN: ''));
  HCBlock1Val0: array[0..5] of byte = (
    $89, $00, $89, $40, $04, $C3);
  HCBlock1Val: array[0..0] of TVal = (
    (RA: $0; Count: length(HCBlock1Val0); Val: @HCBlock1Val0));
  HCBlock1: THCBlock = (
    Size: $8;
    RAC: length(HCBlock1RA); RA: @HCBlock1RA;
    ValC: length(HCBlock1Val); Val: @HCBlock1Val;
    VarsC: 0; Vars: nil;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock2RA: array[0..0] of TRA = (
    (RA: $0; PN: 'AddBlockAfter'; CN: ''));
  HCBlock2Val0: array[0..6] of byte = (
    $53, $56, $8B, $F2, $8B, $D8, $E8);
  HCBlock2Val1: array[0..35] of byte = (
    $85, $C0, $75, $05, $33, $C0, $5E, $5B, $C3, $8B, $16, $89, $50, $08, $8B, $56, 
    $04, $89, $50, $0C, $8B, $13, $89, $10, $89, $58, $04, $89, $42, $04, $89, $03, 
    $B0, $01, $5E, $5B);
  HCBlock2Val: array[0..1] of TVal = (
    (RA: $0; Count: length(HCBlock2Val0); Val: @HCBlock2Val0), 
    (RA: $B; Count: length(HCBlock2Val1); Val: @HCBlock2Val1));
  HCBlock2: THCBlock = (
    Size: $30;
    RAC: length(HCBlock2RA); RA: @HCBlock2RA;
    ValC: length(HCBlock2Val); Val: @HCBlock2Val;
    VarsC: 0; Vars: nil;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock3RA: array[0..0] of TRA = (
    (RA: $0; PN: 'DeleteBlock'; CN: ''));
  HCBlock3Val0: array[0..11] of byte = (
    $8B, $50, $04, $8B, $08, $89, $0A, $89, $51, $04, $8B, $15);
  HCBlock3Val1: array[0..2] of byte = (
    $89, $10, $A3);
  HCBlock3Val2: array[0..0] of byte = (
    $C3);
  HCBlock3Val: array[0..2] of TVal = (
    (RA: $0; Count: length(HCBlock3Val0); Val: @HCBlock3Val0), 
    (RA: $10; Count: length(HCBlock3Val1); Val: @HCBlock3Val1), 
    (RA: $17; Count: length(HCBlock3Val2); Val: @HCBlock3Val2));
  HCBlock3Vars: array[0..0] of TCVar = (
    (RA: $C; VN: 'blockDescFreeList'));
  HCBlock3: THCBlock = (
    Size: $18;
    RAC: length(HCBlock3RA); RA: @HCBlock3RA;
    ValC: length(HCBlock3Val); Val: @HCBlock3Val;
    VarsC: length(HCBlock3Vars); Vars: @HCBlock3Vars;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock4RA: array[0..0] of TRA = (
    (RA: $0; PN: 'MergeBlockAfter'; CN: ''));
  HCBlock4Val0: array[0..44] of byte = (
    $53, $56, $57, $55, $51, $8B, $F1, $89, $14, $24, $8B, $E8, $8B, $5D, $00, $8B,
    $04, $24, $8B, $10, $89, $16, $8B, $50, $04, $89, $56, $04, $8B, $3B, $8B, $43, 
    $08, $8B, $D0, $03, $53, $0C, $3B, $16, $75, $14, $8B, $C3, $E8);
  HCBlock4Val1: array[0..24] of byte = (
    $8B, $43, $08, $89, $06, $8B, $43, $0C, $01, $46, $04, $EB, $16, $8B, $16, $03, 
    $56, $04, $3B, $C2, $75, $0D, $8B, $C3, $E8);
  HCBlock4Val2: array[0..16] of byte = (
    $8B, $43, $0C, $01, $46, $04, $8B, $DF, $3B, $EB, $75, $C2, $8B, $D6, $8B, $C5, 
    $E8);
  HCBlock4Val3: array[0..13] of byte = (
    $84, $C0, $75, $04, $33, $C0, $89, $06, $5A, $5D, $5F, $5E, $5B, $C3);
  HCBlock4Val: array[0..3] of TVal = (
    (RA: $0; Count: length(HCBlock4Val0); Val: @HCBlock4Val0), 
    (RA: $31; Count: length(HCBlock4Val1); Val: @HCBlock4Val1), 
    (RA: $4E; Count: length(HCBlock4Val2); Val: @HCBlock4Val2), 
    (RA: $63; Count: length(HCBlock4Val3); Val: @HCBlock4Val3));
  HCBlock4: THCBlock = (
    Size: $74;
    RAC: length(HCBlock4RA); RA: @HCBlock4RA;
    ValC: length(HCBlock4Val); Val: @HCBlock4Val;
    VarsC: 0; Vars: nil;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock5RA: array[0..0] of TRA = (
    (RA: $0; PN: 'RemoveBlock'; CN: ''));
  HCBlock5Val0: array[0..58] of byte = (
    $53, $56, $57, $55, $83, $C4, $F8, $8B, $D8, $8B, $FB, $8B, $32, $8B, $43, $08, 
    $3B, $F0, $72, $6C, $8B, $CE, $03, $4A, $04, $8B, $E8, $03, $6B, $0C, $3B, $CD, 
    $77, $5E, $3B, $F0, $75, $1B, $8B, $42, $04, $01, $43, $08, $8B, $42, $04, $29, 
    $43, $0C, $83, $7B, $0C, $00, $75, $44, $8B, $C3, $E8);
  HCBlock5Val1: array[0..48] of byte = (
    $EB, $3B, $8B, $0A, $8B, $72, $04, $03, $CE, $8B, $F8, $03, $7B, $0C, $3B, $CF, 
    $75, $05, $29, $73, $0C, $EB, $26, $8B, $0A, $03, $4A, $04, $89, $0C, $24, $2B, 
    $F9, $89, $7C, $24, $04, $8B, $12, $2B, $D0, $89, $53, $0C, $8B, $D4, $8B, $C3, 
    $E8);
  HCBlock5Val2: array[0..26] of byte = (
    $84, $C0, $75, $04, $33, $C0, $EB, $0C, $B0, $01, $EB, $08, $8B, $1B, $3B, $FB, 
    $75, $85, $33, $C0, $59, $5A, $5D, $5F, $5E, $5B, $C3);
  HCBlock5Val: array[0..2] of TVal = (
    (RA: $0; Count: length(HCBlock5Val0); Val: @HCBlock5Val0), 
    (RA: $3F; Count: length(HCBlock5Val1); Val: @HCBlock5Val1), 
    (RA: $74; Count: length(HCBlock5Val2); Val: @HCBlock5Val2));
  HCBlock5: THCBlock = (
    Size: $90;
    RAC: length(HCBlock5RA); RA: @HCBlock5RA;
    ValC: length(HCBlock5Val); Val: @HCBlock5Val;
    VarsC: 0; Vars: nil;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock6RA: array[0..0] of TRA = (
    (RA: $0; PN: 'GetSpace'; CN: ''));
  HCBlock6Val0: array[0..47] of byte = (
    $53, $56, $57, $8B, $DA, $8B, $F0, $81, $FE, $00, $00, $10, $00, $7D, $07, $BE, 
    $00, $00, $10, $00, $EB, $0C, $81, $C6, $FF, $FF, $00, $00, $81, $E6, $00, $00, 
    $FF, $FF, $89, $73, $04, $6A, $01, $68, $00, $20, $00, $00, $56, $6A, $00, $E8);
  HCBlock6Val1: array[0..10] of byte = (
    $8B, $F8, $89, $3B, $85, $FF, $74, $23, $8B, $D3, $B8);
  HCBlock6Val2: array[0..14] of byte = (
    $84, $C0, $75, $13, $68, $00, $80, $00, $00, $6A, $00, $8B, $03, $50, $E8);
  HCBlock6Val3: array[0..7] of byte = (
    $33, $C0, $89, $03, $5F, $5E, $5B, $C3);
  HCBlock6Val: array[0..3] of TVal = (
    (RA: $0; Count: length(HCBlock6Val0); Val: @HCBlock6Val0), 
    (RA: $34; Count: length(HCBlock6Val1); Val: @HCBlock6Val1), 
    (RA: $48; Count: length(HCBlock6Val2); Val: @HCBlock6Val2), 
    (RA: $5B; Count: length(HCBlock6Val3); Val: @HCBlock6Val3));
  HCBlock6Vars: array[0..0] of TCVar = (
    (RA: $3F; VN: 'spaceRoot'));
  HCBlock6: THCBlock = (
    Size: $64;
    RAC: length(HCBlock6RA); RA: @HCBlock6RA;
    ValC: length(HCBlock6Val); Val: @HCBlock6Val;
    VarsC: length(HCBlock6Vars); Vars: @HCBlock6Vars;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock7RA: array[0..0] of TRA = (
    (RA: $0; PN: 'GetSpaceAt'; CN: ''));
  HCBlock7Val0: array[0..30] of byte = (
    $53, $56, $57, $55, $8B, $D9, $8B, $F2, $8B, $E8, $C7, $43, $04, $00, $00, $10, 
    $00, $6A, $04, $68, $00, $20, $00, $00, $68, $00, $00, $10, $00, $55, $E8);
  HCBlock7Val1: array[0..32] of byte = (
    $8B, $F8, $89, $3B, $85, $FF, $75, $1F, $81, $C6, $FF, $FF, $00, $00, $81, $E6, 
    $00, $00, $FF, $FF, $89, $73, $04, $6A, $04, $68, $00, $20, $00, $00, $56, $55, 
    $E8);
  HCBlock7Val2: array[0..9] of byte = (
    $89, $03, $83, $3B, $00, $74, $23, $8B, $D3, $B8);
  HCBlock7Val3: array[0..14] of byte = (
    $84, $C0, $75, $13, $68, $00, $80, $00, $00, $6A, $00, $8B, $03, $50, $E8);
  HCBlock7Val4: array[0..8] of byte = (
    $33, $C0, $89, $03, $5D, $5F, $5E, $5B, $C3);
  HCBlock7Val: array[0..4] of TVal = (
    (RA: $0; Count: length(HCBlock7Val0); Val: @HCBlock7Val0), 
    (RA: $23; Count: length(HCBlock7Val1); Val: @HCBlock7Val1), 
    (RA: $48; Count: length(HCBlock7Val2); Val: @HCBlock7Val2), 
    (RA: $5B; Count: length(HCBlock7Val3); Val: @HCBlock7Val3), 
    (RA: $6E; Count: length(HCBlock7Val4); Val: @HCBlock7Val4));
  HCBlock7Vars: array[0..0] of TCVar = (
    (RA: $52; VN: 'spaceRoot'));
  HCBlock7: THCBlock = (
    Size: $78;
    RAC: length(HCBlock7RA); RA: @HCBlock7RA;
    ValC: length(HCBlock7Val); Val: @HCBlock7Val;
    VarsC: length(HCBlock7Vars); Vars: @HCBlock7Vars;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock8RA: array[0..0] of TRA = (
    (RA: $0; PN: 'FreeSpace'; CN: ''));
  HCBlock8Val0: array[0..40] of byte = (
    $53, $56, $57, $55, $83, $C4, $EC, $89, $4C, $24, $04, $89, $14, $24, $C7, $44, 
    $24, $08, $FF, $FF, $FF, $FF, $33, $D2, $89, $54, $24, $0C, $8B, $E8, $8B, $04, 
    $24, $03, $C5, $89, $44, $24, $10, $8B, $1D);
  HCBlock8Val1: array[0..55] of byte = (
    $EB, $51, $8B, $3B, $8B, $73, $08, $3B, $EE, $77, $46, $8B, $C6, $03, $43, $0C, 
    $3B, $44, $24, $10, $77, $3B, $3B, $74, $24, $08, $73, $04, $89, $74, $24, $08, 
    $8B, $C6, $03, $43, $0C, $3B, $44, $24, $0C, $76, $04, $89, $44, $24, $0C, $68, 
    $00, $80, $00, $00, $6A, $00, $56, $E8);
  HCBlock8Val2: array[0..5] of byte = (
    $85, $C0, $75, $0A, $C7, $05);
  HCBlock8Val3: array[0..2] of byte = (
    $8B, $C3, $E8);
  HCBlock8Val4: array[0..3] of byte = (
    $8B, $DF, $81, $FB);
  HCBlock8Val5: array[0..49] of byte = (
    $75, $A7, $8B, $44, $24, $04, $33, $D2, $89, $10, $83, $7C, $24, $0C, $00, $74, 
    $19, $8B, $44, $24, $04, $8B, $54, $24, $08, $89, $10, $8B, $44, $24, $0C, $2B, 
    $44, $24, $08, $8B, $54, $24, $04, $89, $42, $04, $83, $C4, $14, $5D, $5F, $5E, 
    $5B, $C3);