objfileconsts.pas

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

  HCBlock8Val: array[0..5] of TVal = (
    (RA: $0; Count: length(HCBlock8Val0); Val: @HCBlock8Val0), 
    (RA: $2D; Count: length(HCBlock8Val1); Val: @HCBlock8Val1), 
    (RA: $69; Count: length(HCBlock8Val2); Val: @HCBlock8Val2), 
    (RA: $77; Count: length(HCBlock8Val3); Val: @HCBlock8Val3), 
    (RA: $7E; Count: length(HCBlock8Val4); Val: @HCBlock8Val4), 
    (RA: $86; Count: length(HCBlock8Val5); Val: @HCBlock8Val5));
  HCBlock8Vars: array[0..1] of TCVar = (
    (RA: $29; VN: 'spaceRoot'), 
    (RA: $6F; VN: 'heapErrorCode'));
  HCBlock8: THCBlock = (
    Size: $B8;
    RAC: length(HCBlock8RA); RA: @HCBlock8RA;
    ValC: length(HCBlock8Val); Val: @HCBlock8Val;
    VarsC: length(HCBlock8Vars); Vars: @HCBlock8Vars;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock9RA: array[0..0] of TRA = (
    (RA: $0; PN: 'Commit'; CN: ''));
  HCBlock9Val0: array[0..63] of byte = (
    $53, $56, $57, $55, $83, $C4, $F4, $89, $4C, $24, $04, $89, $14, $24, $8B, $D0, 
    $8B, $EA, $81, $E5, $00, $F0, $FF, $FF, $03, $14, $24, $81, $C2, $FF, $0F, $00, 
    $00, $81, $E2, $00, $F0, $FF, $FF, $89, $54, $24, $08, $8B, $44, $24, $04, $89, 
    $28, $8B, $44, $24, $08, $2B, $C5, $8B, $54, $24, $04, $89, $42, $04, $8B, $35);
  HCBlock9Val1: array[0..41] of byte = (
    $EB, $3C, $8B, $5E, $08, $8B, $7E, $0C, $03, $FB, $3B, $EB, $76, $02, $8B, $DD, 
    $3B, $7C, $24, $08, $76, $04, $8B, $7C, $24, $08, $3B, $FB, $76, $1E, $6A, $04, 
    $68, $00, $10, $00, $00, $2B, $FB, $57, $53, $E8);
  HCBlock9Val2: array[0..17] of byte = (
    $85, $C0, $75, $0A, $8B, $44, $24, $04, $33, $D2, $89, $10, $EB, $0A, $8B, $36, 
    $81, $FE);
  HCBlock9Val3: array[0..9] of byte = (
    $75, $BC, $83, $C4, $0C, $5D, $5F, $5E, $5B, $C3);
  HCBlock9Val: array[0..3] of TVal = (
    (RA: $0; Count: length(HCBlock9Val0); Val: @HCBlock9Val0), 
    (RA: $44; Count: length(HCBlock9Val1); Val: @HCBlock9Val1), 
    (RA: $72; Count: length(HCBlock9Val2); Val: @HCBlock9Val2), 
    (RA: $88; Count: length(HCBlock9Val3); Val: @HCBlock9Val3));
  HCBlock9Vars: array[0..0] of TCVar = (
    (RA: $40; VN: 'spaceRoot'));
  HCBlock9: THCBlock = (
    Size: $94;
    RAC: length(HCBlock9RA); RA: @HCBlock9RA;
    ValC: length(HCBlock9Val); Val: @HCBlock9Val;
    VarsC: length(HCBlock9Vars); Vars: @HCBlock9Vars;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock10RA: array[0..0] of TRA = (
    (RA: $0; PN: 'Decommit'; CN: ''));
  HCBlock10Val0: array[0..48] of byte = (
    $53, $56, $57, $55, $51, $8B, $D8, $8B, $F3, $81, $C6, $FF, $0F, $00, $00, $81, 
    $E6, $00, $F0, $FF, $FF, $89, $34, $24, $8B, $EB, $03, $EA, $81, $E5, $00, $F0, 
    $FF, $FF, $8B, $04, $24, $89, $01, $8B, $C5, $2B, $04, $24, $89, $41, $04, $8B, 
    $35);
  HCBlock10Val1: array[0..37] of byte = (
    $EB, $38, $8B, $5E, $08, $8B, $7E, $0C, $03, $FB, $3B, $1C, $24, $73, $03, $8B, 
    $1C, $24, $3B, $EF, $73, $02, $8B, $FD, $3B, $FB, $76, $1C, $68, $00, $40, $00, 
    $00, $2B, $FB, $57, $53, $E8);
  HCBlock10Val2: array[0..5] of byte = (
    $85, $C0, $75, $0A, $C7, $05);
  HCBlock10Val3: array[0..3] of byte = (
    $8B, $36, $81, $FE);
  HCBlock10Val4: array[0..7] of byte = (
    $75, $C0, $5A, $5D, $5F, $5E, $5B, $C3);
  HCBlock10Val: array[0..4] of TVal = (
    (RA: $0; Count: length(HCBlock10Val0); Val: @HCBlock10Val0), 
    (RA: $35; Count: length(HCBlock10Val1); Val: @HCBlock10Val1), 
    (RA: $5F; Count: length(HCBlock10Val2); Val: @HCBlock10Val2), 
    (RA: $6D; Count: length(HCBlock10Val3); Val: @HCBlock10Val3), 
    (RA: $75; Count: length(HCBlock10Val4); Val: @HCBlock10Val4));
  HCBlock10Vars: array[0..1] of TCVar = (
    (RA: $31; VN: 'spaceRoot'), 
    (RA: $65; VN: 'heapErrorCode'));
  HCBlock10: THCBlock = (
    Size: $80;
    RAC: length(HCBlock10RA); RA: @HCBlock10RA;
    ValC: length(HCBlock10Val); Val: @HCBlock10Val;
    VarsC: length(HCBlock10Vars); Vars: @HCBlock10Vars;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock11RA: array[0..0] of TRA = (
    (RA: $0; PN: 'GetCommitted'; CN: ''));
  HCBlock11Val0: array[0..11] of byte = (
    $53, $56, $57, $55, $83, $C4, $F8, $8B, $F2, $8B, $F8, $BD);
  HCBlock11Val1: array[0..29] of byte = (
    $81, $C7, $FF, $3F, $00, $00, $81, $E7, $00, $C0, $FF, $FF, $8B, $5D, $00, $EB,
    $33, $3B, $7B, $0C, $7F, $2C, $8B, $CE, $8B, $D7, $8B, $43, $08, $E8);
  HCBlock11Val2: array[0..25] of byte = (
    $83, $3E, $00, $74, $50, $8B, $46, $04, $01, $43, $08, $8B, $46, $04, $29, $43,
    $0C, $83, $7B, $0C, $00, $75, $3E, $8B, $C3, $E8);
  HCBlock11Val3: array[0..12] of byte = (
    $EB, $35, $8B, $1B, $3B, $DD, $75, $C9, $8B, $D6, $8B, $C7, $E8);
  HCBlock11Val4: array[0..11] of byte = (
    $83, $3E, $00, $74, $21, $8B, $CC, $8B, $D6, $8B, $C5, $E8);
  HCBlock11Val5: array[0..13] of byte = (
    $83, $3C, $24, $00, $75, $A5, $8B, $CC, $8B, $56, $04, $8B, $06, $E8);
  HCBlock11Val6: array[0..10] of byte = (
    $33, $C0, $89, $06, $59, $5A, $5D, $5F, $5E, $5B, $C3);
  HCBlock11Val: array[0..6] of TVal = (
    (RA: $0; Count: length(HCBlock11Val0); Val: @HCBlock11Val0), 
    (RA: $10; Count: length(HCBlock11Val1); Val: @HCBlock11Val1), 
    (RA: $32; Count: length(HCBlock11Val2); Val: @HCBlock11Val2), 
    (RA: $50; Count: length(HCBlock11Val3); Val: @HCBlock11Val3), 
    (RA: $61; Count: length(HCBlock11Val4); Val: @HCBlock11Val4), 
    (RA: $71; Count: length(HCBlock11Val5); Val: @HCBlock11Val5), 
    (RA: $83; Count: length(HCBlock11Val6); Val: @HCBlock11Val6));
  HCBlock11Vars: array[0..0] of TCVar = (
    (RA: $C; VN: 'decommittedRoot'));
  HCBlock11: THCBlock = (
    Size: $90;
    RAC: length(HCBlock11RA); RA: @HCBlock11RA;
    ValC: length(HCBlock11Val); Val: @HCBlock11Val;
    VarsC: length(HCBlock11Vars); Vars: @HCBlock11Vars;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock12RA: array[0..0] of TRA = (
    (RA: $0; PN: 'GetCommittedAt'; CN: ''));
  HCBlock12Val0: array[0..14] of byte = (
    $53, $56, $57, $55, $83, $C4, $EC, $89, $0C, $24, $8B, $FA, $8B, $F0, $BD);
  HCBlock12Val1: array[0..57] of byte = (
    $81, $C7, $FF, $3F, $00, $00, $81, $E7, $00, $C0, $FF, $FF, $8B, $5D, $00, $EB, 
    $02, $8B, $1B, $3B, $DD, $74, $05, $3B, $73, $08, $75, $F5, $3B, $73, $08, $75, 
    $57, $3B, $7B, $0C, $0F, $8E, $96, $00, $00, $00, $8D, $4C, $24, $04, $8B, $D7, 
    $2B, $53, $0C, $8B, $43, $08, $03, $43, $0C, $E8);
  HCBlock12Val2: array[0..17] of byte = (
    $83, $7C, $24, $04, $00, $74, $33, $8D, $4C, $24, $0C, $8D, $54, $24, $04, $8B, 
    $C5, $E8);
  HCBlock12Val3: array[0..19] of byte = (
    $83, $7C, $24, $0C, $00, $75, $B1, $8D, $4C, $24, $0C, $8B, $54, $24, $08, $8B, 
    $44, $24, $04, $E8);
  HCBlock12Val4: array[0..20] of byte = (
    $8B, $04, $24, $33, $D2, $89, $10, $E9, $90, $00, $00, $00, $8D, $4C, $24, $04, 
    $8B, $D7, $8B, $C6, $E8);
  HCBlock12Val5: array[0..17] of byte = (
    $83, $7C, $24, $04, $00, $74, $34, $8D, $4C, $24, $0C, $8D, $54, $24, $04, $8B, 
    $C5, $E8);
  HCBlock12Val6: array[0..23] of byte = (
    $83, $7C, $24, $0C, $00, $0F, $85, $66, $FF, $FF, $FF, $8D, $4C, $24, $0C, $8B, 
    $54, $24, $08, $8B, $44, $24, $04, $E8);
  HCBlock12Val7: array[0..28] of byte = (
    $8B, $04, $24, $33, $D2, $89, $10, $EB, $48, $8B, $6B, $08, $3B, $F5, $75, $3A, 
    $3B, $7B, $0C, $7F, $35, $8B, $0C, $24, $8B, $D7, $8B, $C5, $E8);
  HCBlock12Val8: array[0..34] of byte = (
    $8B, $04, $24, $83, $38, $00, $74, $28, $8B, $04, $24, $8B, $40, $04, $01, $43, 
    $08, $8B, $04, $24, $8B, $40, $04, $29, $43, $0C, $83, $7B, $0C, $00, $75, $10,
    $8B, $C3, $E8);
  HCBlock12Val9: array[0..16] of byte = (
    $EB, $07, $8B, $04, $24, $33, $D2, $89, $10, $83, $C4, $14, $5D, $5F, $5E, $5B, 
    $C3);
  HCBlock12Val: array[0..9] of TVal = (
    (RA: $0; Count: length(HCBlock12Val0); Val: @HCBlock12Val0), 
    (RA: $13; Count: length(HCBlock12Val1); Val: @HCBlock12Val1), 
    (RA: $51; Count: length(HCBlock12Val2); Val: @HCBlock12Val2), 
    (RA: $67; Count: length(HCBlock12Val3); Val: @HCBlock12Val3), 
    (RA: $7F; Count: length(HCBlock12Val4); Val: @HCBlock12Val4), 
    (RA: $98; Count: length(HCBlock12Val5); Val: @HCBlock12Val5), 
    (RA: $AE; Count: length(HCBlock12Val6); Val: @HCBlock12Val6), 
    (RA: $CA; Count: length(HCBlock12Val7); Val: @HCBlock12Val7), 
    (RA: $EB; Count: length(HCBlock12Val8); Val: @HCBlock12Val8),
    (RA: $112; Count: length(HCBlock12Val9); Val: @HCBlock12Val9));
  HCBlock12Vars: array[0..0] of TCVar = (
    (RA: $F; VN: 'decommittedRoot'));
  HCBlock12: THCBlock = (
    Size: $124;
    RAC: length(HCBlock12RA); RA: @HCBlock12RA;
    ValC: length(HCBlock12Val); Val: @HCBlock12Val;
    VarsC: length(HCBlock12Vars); Vars: @HCBlock12Vars;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock13RA: array[0..0] of TRA = (
    (RA: $0; PN: 'FreeCommitted'; CN: ''));
  HCBlock13Val0: array[0..46] of byte = (
    $53, $56, $57, $83, $C4, $EC, $8B, $F9, $89, $14, $24, $8D, $98, $FF, $3F, $00, 
    $00, $81, $E3, $00, $C0, $FF, $FF, $8B, $34, $24, $03, $F0, $81, $E6, $00, $C0, 
    $FF, $FF, $3B, $DE, $73, $5B, $8B, $CF, $8B, $D6, $2B, $D3, $8B, $C3, $E8);
  HCBlock13Val1: array[0..6] of byte = (
    $8D, $4C, $24, $04, $8B, $D7, $B8);
  HCBlock13Val2: array[0..18] of byte = (
    $8B, $5C, $24, $04, $85, $DB, $74, $1F, $8D, $4C, $24, $0C, $8B, $54, $24, $08, 
    $8B, $C3, $E8);
  HCBlock13Val3: array[0..27] of byte = (
    $8B, $44, $24, $0C, $89, $44, $24, $04, $8B, $44, $24, $10, $89, $44, $24, $08, 
    $83, $7C, $24, $04, $00, $74, $14, $8D, $54, $24, $04, $B8);
  HCBlock13Val4: array[0..12] of byte = (
    $EB, $04, $33, $C0, $89, $07, $83, $C4, $14, $5F, $5E, $5B, $C3);
  HCBlock13Val: array[0..4] of TVal = (
    (RA: $0; Count: length(HCBlock13Val0); Val: @HCBlock13Val0), 
    (RA: $33; Count: length(HCBlock13Val1); Val: @HCBlock13Val1), 
    (RA: $43; Count: length(HCBlock13Val2); Val: @HCBlock13Val2), 
    (RA: $5A; Count: length(HCBlock13Val3); Val: @HCBlock13Val3), 
    (RA: $7F; Count: length(HCBlock13Val4); Val: @HCBlock13Val4));
  HCBlock13Vars: array[0..0] of TCVar = (
    (RA: $3A; VN: 'decommittedRoot'));
  HCBlock13: THCBlock = (
    Size: $8C;
    RAC: length(HCBlock13RA); RA: @HCBlock13RA;
    ValC: length(HCBlock13Val); Val: @HCBlock13Val;
    VarsC: length(HCBlock13Vars); Vars: @HCBlock13Vars;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock14RA: array[0..0] of TRA = (
    (RA: $0; PN: 'InitAllocator'; CN: ''));
  HCBlock14Val0: array[0..6] of byte = (
    $55, $8B, $EC, $33, $D2, $55, $68);
  HCBlock14Val1: array[0..6] of byte = (
    $64, $FF, $32, $64, $89, $22, $68);
  HCBlock14Val2: array[0..0] of byte = (
    $E8);
  HCBlock14Val3: array[0..1] of byte = (
    $80, $3D);
  HCBlock14Val4: array[0..2] of byte = (
    $74, $0A, $68);
  HCBlock14Val5: array[0..0] of byte = (
    $E8);
  HCBlock14Val6: array[0..0] of byte = (
    $B8);
  HCBlock14Val7: array[0..0] of byte = (
    $E8);
  HCBlock14Val8: array[0..0] of byte = (
    $B8);
  HCBlock14Val9: array[0..0] of byte = (
    $E8);
  HCBlock14Val10: array[0..0] of byte = (
    $B8);
  HCBlock14Val11: array[0..0] of byte = (
    $E8);
  HCBlock14Val12: array[0..7] of byte = (
    $68, $F8, $0F, $00, $00, $6A, $00, $E8);
  HCBlock14Val13: array[0..0] of byte = (
    $A3);
  HCBlock14Val14: array[0..1] of byte = (
    $83, $3D);
  HCBlock14Val15: array[0..8] of byte = (
    $74, $2F, $B8, $03, $00, $00, $00, $8B, $15);
  HCBlock14Val16: array[0..14] of byte = (
    $33, $C9, $89, $4C, $82, $F4, $40, $3D, $01, $04, $00, $00, $75, $EC, $B8);
  HCBlock14Val17: array[0..5] of byte = (
    $89, $40, $04, $89, $00, $A3);
  HCBlock14Val18: array[0..1] of byte = (
    $C6, $05);
  HCBlock14Val19: array[0..8] of byte = (
    $33, $C0, $5A, $59, $59, $64, $89, $10, $68);
  HCBlock14Val20: array[0..1] of byte = (
    $80, $3D);
  HCBlock14Val21: array[0..2] of byte = (
    $74, $0A, $68);
  HCBlock14Val22: array[0..0] of byte = (
    $E8);
  HCBlock14Val23: array[0..1] of byte = (
    $C3, $E9);
  HCBlock14Val24: array[0..2] of byte = (
    $EB, $E5, $A0);
  HCBlock14Val25: array[0..1] of byte = (
    $5D, $C3);
  HCBlock14Val: array[0..25] of TVal = (
    (RA: $0; Count: length(HCBlock14Val0); Val: @HCBlock14Val0), 
    (RA: $B; Count: length(HCBlock14Val1); Val: @HCBlock14Val1), 
    (RA: $16; Count: length(HCBlock14Val2); Val: @HCBlock14Val2), 
    (RA: $1B; Count: length(HCBlock14Val3); Val: @HCBlock14Val3), 
    (RA: $22; Count: length(HCBlock14Val4); Val: @HCBlock14Val4), 
    (RA: $29; Count: length(HCBlock14Val5); Val: @HCBlock14Val5), 
    (RA: $2E; Count: length(HCBlock14Val6); Val: @HCBlock14Val6), 
    (RA: $33; Count: length(HCBlock14Val7); Val: @HCBlock14Val7), 
    (RA: $38; Count: length(HCBlock14Val8); Val: @HCBlock14Val8), 
    (RA: $3D; Count: length(HCBlock14Val9); Val: @HCBlock14Val9), 
    (RA: $42; Count: length(HCBlock14Val10); Val: @HCBlock14Val10), 
    (RA: $47; Count: length(HCBlock14Val11); Val: @HCBlock14Val11),
    (RA: $4C; Count: length(HCBlock14Val12); Val: @HCBlock14Val12), 
    (RA: $58; Count: length(HCBlock14Val13); Val: @HCBlock14Val13), 
    (RA: $5D; Count: length(HCBlock14Val14); Val: @HCBlock14Val14), 
    (RA: $64; Count: length(HCBlock14Val15); Val: @HCBlock14Val15), 
    (RA: $71; Count: length(HCBlock14Val16); Val: @HCBlock14Val16), 
    (RA: $84; Count: length(HCBlock14Val17); Val: @HCBlock14Val17), 
    (RA: $8E; Count: length(HCBlock14Val18); Val: @HCBlock14Val18), 
    (RA: $95; Count: length(HCBlock14Val19); Val: @HCBlock14Val19), 
    (RA: $A2; Count: length(HCBlock14Val20); Val: @HCBlock14Val20), 
    (RA: $A9; Count: length(HCBlock14Val21); Val: @HCBlock14Val21), 
    (RA: $B0; Count: length(HCBlock14Val22); Val: @HCBlock14Val22), 
    (RA: $B5; Count: length(HCBlock14Val23); Val: @HCBlock14Val23), 
    (RA: $BB; Count: length(HCBlock14Val24); Val: @HCBlock14Val24), 
    (RA: $C2; Count: length(HCBlock14Val25); Val: @HCBlock14Val25));