objfileconsts.pas

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

    $F3, $8B, $C6, $E8);
  HCBlock22Val1: array[0..15] of byte = (
    $8B, $46, $08, $03, $F8, $03, $D8, $83, $23, $FE, $8B, $C7, $5F, $5E, $5B, $C3);
  HCBlock22Val: array[0..1] of TVal = (
    (RA: $0; Count: length(HCBlock22Val0); Val: @HCBlock22Val0), 
    (RA: $28; Count: length(HCBlock22Val1); Val: @HCBlock22Val1));
  HCBlock22: THCBlock = (
    Size: $38;
    RAC: length(HCBlock22RA); RA: @HCBlock22RA;
    ValC: length(HCBlock22Val); Val: @HCBlock22Val;
    VarsC: 0; Vars: nil;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock23RA: array[0..0] of TRA = (
    (RA: $0; PN: 'DecommitFree'; CN: ''));
  HCBlock23Val0: array[0..13] of byte = (
    $53, $56, $57, $55, $83, $C4, $F8, $8B, $FA, $8B, $F0, $8B, $C6, $E8);
  HCBlock23Val1: array[0..46] of byte = (
    $8B, $D8, $8B, $6B, $08, $8B, $C5, $03, $43, $0C, $8B, $D0, $8D, $0C, $37, $2B, 
    $D1, $83, $FA, $0C, $7F, $04, $8B, $F8, $2B, $FE, $8B, $C6, $2B, $C5, $83, $F8, 
    $0C, $7D, $12, $8B, $CC, $8B, $D6, $2B, $53, $08, $03, $D7, $8B, $C5, $E8);
  HCBlock23Val2: array[0..12] of byte = (
    $EB, $0F, $8B, $CC, $8B, $D7, $83, $EA, $04, $8D, $46, $04, $E8);
  HCBlock23Val3: array[0..17] of byte = (
    $8B, $2C, $24, $85, $ED, $75, $04, $33, $C0, $EB, $30, $8B, $D5, $2B, $D6, $8B, 
    $C6, $E8);
  HCBlock23Val4: array[0..21] of byte = (
    $8B, $C5, $03, $44, $24, $04, $8B, $53, $08, $03, $53, $0C, $3B, $C2, $73, $0A, 
    $8D, $14, $37, $2B, $D0, $E8);
  HCBlock23Val5: array[0..4] of byte = (
    $8B, $D4, $8B, $C3, $E8);
  HCBlock23Val6: array[0..8] of byte = (
    $B0, $01, $59, $5A, $5D, $5F, $5E, $5B, $C3);
  HCBlock23Val: array[0..6] of TVal = (
    (RA: $0; Count: length(HCBlock23Val0); Val: @HCBlock23Val0), 
    (RA: $12; Count: length(HCBlock23Val1); Val: @HCBlock23Val1), 
    (RA: $45; Count: length(HCBlock23Val2); Val: @HCBlock23Val2), 
    (RA: $56; Count: length(HCBlock23Val3); Val: @HCBlock23Val3), 
    (RA: $6C; Count: length(HCBlock23Val4); Val: @HCBlock23Val4),
    (RA: $86; Count: length(HCBlock23Val5); Val: @HCBlock23Val5), 
    (RA: $8F; Count: length(HCBlock23Val6); Val: @HCBlock23Val6));
  HCBlock23: THCBlock = (
    Size: $98;
    RAC: length(HCBlock23RA); RA: @HCBlock23RA;
    ValC: length(HCBlock23Val); Val: @HCBlock23Val;
    VarsC: 0; Vars: nil;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock24RA: array[0..0] of TRA = (
    (RA: $0; PN: 'InsertFree'; CN: ''));
  HCBlock24Val0: array[0..42] of byte = (
    $53, $56, $57, $8B, $F2, $8B, $F8, $8B, $DF, $89, $73, $08, $8B, $C3, $03, $C6, 
    $83, $E8, $0C, $89, $70, $08, $81, $FE, $00, $10, $00, $00, $7F, $37, $8B, $D6, 
    $85, $D2, $79, $03, $83, $C2, $03, $C1, $FA, $02, $A1);
  HCBlock24Val1: array[0..8] of byte = (
    $8B, $44, $90, $F4, $85, $C0, $75, $10, $A1);
  HCBlock24Val2: array[0..37] of byte = (
    $89, $5C, $90, $F4, $89, $5B, $04, $89, $1B, $EB, $3A, $8B, $10, $89, $43, $04, 
    $89, $13, $89, $18, $89, $5A, $04, $EB, $2C, $81, $FE, $00, $3C, $00, $00, $7C, 
    $0D, $8B, $D6, $8B, $C7, $E8);
  HCBlock24Val3: array[0..4] of byte = (
    $84, $C0, $75, $17, $A1);
  HCBlock24Val4: array[0..1] of byte = (
    $89, $1D);
  HCBlock24Val5: array[0..15] of byte = (
    $8B, $10, $89, $43, $04, $89, $13, $89, $18, $89, $5A, $04, $5F, $5E, $5B, $C3);
  HCBlock24Val: array[0..5] of TVal = (
    (RA: $0; Count: length(HCBlock24Val0); Val: @HCBlock24Val0), 
    (RA: $2F; Count: length(HCBlock24Val1); Val: @HCBlock24Val1),
    (RA: $3C; Count: length(HCBlock24Val2); Val: @HCBlock24Val2), 
    (RA: $66; Count: length(HCBlock24Val3); Val: @HCBlock24Val3), 
    (RA: $6F; Count: length(HCBlock24Val4); Val: @HCBlock24Val4), 
    (RA: $75; Count: length(HCBlock24Val5); Val: @HCBlock24Val5));
  HCBlock24Vars: array[0..1] of TCVar = (
    (RA: $2B; VN: 'smallTab'), 
    (RA: $6B; VN: 'rover'));
  HCBlock24: THCBlock = (
    Size: $88;
    RAC: length(HCBlock24RA); RA: @HCBlock24RA;
    ValC: length(HCBlock24Val); Val: @HCBlock24Val;
    VarsC: length(HCBlock24Vars); Vars: @HCBlock24Vars;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock25RA: array[0..0] of TRA = (
    (RA: $0; PN: 'FreeCurAlloc'; CN: ''));
  HCBlock25Val0: array[0..1] of byte = (
    $83, $3D);
  HCBlock25Val1: array[0..3] of byte = (
    $7E, $40, $83, $3D);
  HCBlock25Val2: array[0..3] of byte = (
    $7D, $0C, $C7, $05);
  HCBlock25Val3: array[0..2] of byte = (
    $EB, $2B, $A1);
  HCBlock25Val4: array[0..4] of byte = (
    $83, $C8, $02, $8B, $15);
  HCBlock25Val5: array[0..2] of byte = (
    $89, $02, $A1);
  HCBlock25Val6: array[0..3] of byte = (
    $83, $C0, $04, $E8);
  HCBlock25Val7: array[0..2] of byte = (
    $33, $C0, $A3);
  HCBlock25Val8: array[0..2] of byte = (
    $33, $C0, $A3);
  HCBlock25Val9: array[0..0] of byte = (
    $C3);
  HCBlock25Val: array[0..9] of TVal = (
    (RA: $0; Count: length(HCBlock25Val0); Val: @HCBlock25Val0), 
    (RA: $7; Count: length(HCBlock25Val1); Val: @HCBlock25Val1), 
    (RA: $10; Count: length(HCBlock25Val2); Val: @HCBlock25Val2), 
    (RA: $1C; Count: length(HCBlock25Val3); Val: @HCBlock25Val3), 
    (RA: $23; Count: length(HCBlock25Val4); Val: @HCBlock25Val4), 
    (RA: $2C; Count: length(HCBlock25Val5); Val: @HCBlock25Val5), 
    (RA: $33; Count: length(HCBlock25Val6); Val: @HCBlock25Val6), 
    (RA: $3B; Count: length(HCBlock25Val7); Val: @HCBlock25Val7), 
    (RA: $42; Count: length(HCBlock25Val8); Val: @HCBlock25Val8), 
    (RA: $49; Count: length(HCBlock25Val9); Val: @HCBlock25Val9));
  HCBlock25Vars: array[0..2] of TCVar = (
    (RA: $2; VN: 'remBytes'), 
    (RA: $14; VN: 'heapErrorCode'),
    (RA: $28; VN: 'curAlloc'));
  HCBlock25: THCBlock = (
    Size: $4C;
    RAC: length(HCBlock25RA); RA: @HCBlock25RA;
    ValC: length(HCBlock25Val); Val: @HCBlock25Val;
    VarsC: length(HCBlock25Vars); Vars: @HCBlock25Vars;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock26RA: array[0..0] of TRA = (
    (RA: $0; PN: 'MergeCommit'; CN: ''));
  HCBlock26Val0: array[0..15] of byte = (
    $53, $56, $57, $83, $C4, $F0, $8B, $F0, $8D, $3C, $24, $A5, $A5, $8B, $FC, $E8);
  HCBlock26Val1: array[0..6] of byte = (
    $8D, $4C, $24, $08, $8B, $D7, $B8);
  HCBlock26Val2: array[0..0] of byte = (
    $E8);
  HCBlock26Val3: array[0..18] of byte = (
    $8B, $5C, $24, $08, $85, $DB, $75, $04, $33, $C0, $EB, $52, $8B, $07, $3B, $D8, 
    $73, $0A, $E8);
  HCBlock26Val4: array[0..20] of byte = (
    $29, $07, $01, $47, $04, $8B, $07, $03, $47, $04, $8B, $F3, $03, $74, $24, $0C, 
    $3B, $C6, $73, $08, $E8);
  HCBlock26Val5: array[0..20] of byte = (
    $01, $47, $04, $8B, $07, $03, $47, $04, $3B, $F0, $75, $11, $83, $E8, $04, $BA, 
    $04, $00, $00, $00, $E8);
  HCBlock26Val6: array[0..6] of byte = (
    $83, $6F, $04, $04, $8B, $07, $A3);
  HCBlock26Val7: array[0..3] of byte = (
    $8B, $47, $04, $A3);
  HCBlock26Val8: array[0..8] of byte = (
    $B0, $01, $83, $C4, $10, $5F, $5E, $5B, $C3);
  HCBlock26Val: array[0..8] of TVal = (
    (RA: $0; Count: length(HCBlock26Val0); Val: @HCBlock26Val0), 
    (RA: $14; Count: length(HCBlock26Val1); Val: @HCBlock26Val1), 
    (RA: $1F; Count: length(HCBlock26Val2); Val: @HCBlock26Val2), 
    (RA: $24; Count: length(HCBlock26Val3); Val: @HCBlock26Val3), 
    (RA: $3B; Count: length(HCBlock26Val4); Val: @HCBlock26Val4), 
    (RA: $54; Count: length(HCBlock26Val5); Val: @HCBlock26Val5), 
    (RA: $6D; Count: length(HCBlock26Val6); Val: @HCBlock26Val6), 
    (RA: $78; Count: length(HCBlock26Val7); Val: @HCBlock26Val7), 
    (RA: $80; Count: length(HCBlock26Val8); Val: @HCBlock26Val8));
  HCBlock26Vars: array[0..2] of TCVar = (
    (RA: $1B; VN: 'committedRoot'), 
    (RA: $74; VN: 'curAlloc'), 
    (RA: $7C; VN: 'remBytes'));
  HCBlock26: THCBlock = (
    Size: $8C;
    RAC: length(HCBlock26RA); RA: @HCBlock26RA;
    ValC: length(HCBlock26Val); Val: @HCBlock26Val;
    VarsC: length(HCBlock26Vars); Vars: @HCBlock26Vars;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock27RA: array[0..0] of TRA = (
    (RA: $0; PN: 'NewCommit'; CN: ''));
  HCBlock27Val0: array[0..11] of byte = (
    $53, $83, $C4, $F8, $8B, $D8, $8B, $D4, $8D, $43, $04, $E8);
  HCBlock27Val1: array[0..8] of byte = (
    $83, $3C, $24, $00, $74, $0B, $8B, $C4, $E8);
  HCBlock27Val2: array[0..13] of byte = (
    $84, $C0, $75, $04, $33, $C0, $EB, $02, $B0, $01, $59, $5A, $5B, $C3);
  HCBlock27Val: array[0..2] of TVal = (
    (RA: $0; Count: length(HCBlock27Val0); Val: @HCBlock27Val0),
    (RA: $10; Count: length(HCBlock27Val1); Val: @HCBlock27Val1),
    (RA: $1D; Count: length(HCBlock27Val2); Val: @HCBlock27Val2));
  HCBlock27: THCBlock = (
    Size: $2C;
    RAC: length(HCBlock27RA); RA: @HCBlock27RA;
    ValC: length(HCBlock27Val); Val: @HCBlock27Val;
    VarsC: 0; Vars: nil;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock28RA: array[0..0] of TRA = (
    (RA: $0; PN: 'NewCommitAt'; CN: ''));
  HCBlock28Val0: array[0..16] of byte = (
    $53, $56, $83, $C4, $F8, $8B, $F2, $8B, $D8, $8B, $CC, $8D, $56, $04, $8B, $C3, 
    $E8);
  HCBlock28Val1: array[0..8] of byte = (
    $83, $3C, $24, $00, $74, $0B, $8B, $C4, $E8);
  HCBlock28Val2: array[0..14] of byte = (
    $84, $C0, $75, $04, $33, $C0, $EB, $02, $B0, $01, $59, $5A, $5E, $5B, $C3);
  HCBlock28Val: array[0..2] of TVal = (
    (RA: $0; Count: length(HCBlock28Val0); Val: @HCBlock28Val0), 
    (RA: $15; Count: length(HCBlock28Val1); Val: @HCBlock28Val1), 
    (RA: $22; Count: length(HCBlock28Val2); Val: @HCBlock28Val2));
  HCBlock28: THCBlock = (
    Size: $34;
    RAC: length(HCBlock28RA); RA: @HCBlock28RA;
    ValC: length(HCBlock28Val); Val: @HCBlock28Val;
    VarsC: 0; Vars: nil;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock29RA: array[0..0] of TRA = (
    (RA: $0; PN: 'SearchSmallBlocks'; CN: ''));
  HCBlock29Val0: array[0..20] of byte = (
    $33, $D2, $85, $C0, $79, $03, $83, $C0, $03, $C1, $F8, $02, $3D, $00, $04, $00, 
    $00, $7F, $16, $8B, $15);
  HCBlock29Val1: array[0..18] of byte = (
    $8B, $54, $82, $F4, $85, $D2, $75, $08, $40, $3D, $01, $04, $00, $00, $75, $EA, 
    $8B, $C2, $C3);
  HCBlock29Val: array[0..1] of TVal = (
    (RA: $0; Count: length(HCBlock29Val0); Val: @HCBlock29Val0), 
    (RA: $19; Count: length(HCBlock29Val1); Val: @HCBlock29Val1));
  HCBlock29Vars: array[0..0] of TCVar = (
    (RA: $15; VN: 'smallTab'));
  HCBlock29: THCBlock = (
    Size: $2C;
    RAC: length(HCBlock29RA); RA: @HCBlock29RA;
    ValC: length(HCBlock29Val); Val: @HCBlock29Val;
    VarsC: length(HCBlock29Vars); Vars: @HCBlock29Vars;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock30RA: array[0..0] of TRA = (
    (RA: $0; PN: 'TryHarder'; CN: ''));
  HCBlock30Val0: array[0..6] of byte = (
    $53, $56, $57, $55, $8B, $F0, $BF);
  HCBlock30Val1: array[0..0] of byte = (
    $BD);
  HCBlock30Val2: array[0..1] of byte = (
    $8B, $1D);
  HCBlock30Val3: array[0..52] of byte = (
    $3B, $73, $08, $0F, $8E, $84, $00, $00, $00, $8B, $1F, $8B, $43, $08, $3B, $F0, 
    $7E, $7B, $89, $73, $08, $8B, $5B, $04, $3B, $73, $08, $7F, $F8, $8B, $17, $89, 
    $42, $08, $3B, $1F, $74, $04, $89, $1F, $EB, $63, $81, $FE, $00, $10, $00, $00, 
    $7F, $0D, $8B, $C6, $E8);
  HCBlock30Val4: array[0..8] of byte = (
    $8B, $D8, $85, $DB, $75, $4E, $8B, $C6, $E8);
  HCBlock30Val5: array[0..33] of byte = (
    $84, $C0, $75, $07, $33, $C0, $E9, $88, $00, $00, $00, $3B, $75, $00, $7F, $A4, 
    $29, $75, $00, $83, $7D, $00, $0C, $7D, $08, $03, $75, $00, $33, $C0, $89, $45, 
    $00, $A1);
  HCBlock30Val6: array[0..1] of byte = (
    $01, $35);
  HCBlock30Val7: array[0..11] of byte = (
    $8B, $D6, $83, $CA, $02, $89, $10, $83, $C0, $04, $FF, $05);
  HCBlock30Val8: array[0..4] of byte = (
    $83, $EE, $04, $01, $35);
  HCBlock30Val9: array[0..4] of byte = (
    $EB, $4C, $8B, $C3, $E8);
  HCBlock30Val10: array[0..17] of byte = (
    $8B, $53, $08, $8B, $C2, $2B, $C6, $83, $F8, $0C, $7C, $0C, $8B, $D3, $03, $D6, 
    $92, $E8);
  HCBlock30Val11: array[0..33] of byte = (
    $EB, $12, $8B, $F2, $3B, $1F, $75, $05, $8B, $43, $04, $89, $07, $8B, $C3, $03, 
    $C6, $83, $20, $FE, $8B, $C3, $8B, $D6, $83, $CA, $02, $89, $10, $83, $C0, $04, 
    $FF, $05);
  HCBlock30Val12: array[0..4] of byte = (
    $83, $EE, $04, $01, $35);
  HCBlock30Val13: array[0..4] of byte = (
    $5D, $5F, $5E, $5B, $C3);
  HCBlock30Val: array[0..13] of TVal = (
    (RA: $0; Count: length(HCBlock30Val0); Val: @HCBlock30Val0), 
    (RA: $B; Count: length(HCBlock30Val1); Val: @HCBlock30Val1), 
    (RA: $10; Count: length(HCBlock30Val2); Val: @HCBlock30Val2), 
    (RA: $16; Count: length(HCBlock30Val3); Val: @HCBlock30Val3), 
    (RA: $4F; Count: length(HCBlock30Val4); Val: @HCBlock30Val4), 
    (RA: $5C; Count: length(HCBlock30Val5); Val: @HCBlock30Val5), 
    (RA: $82; Count: length(HCBlock30Val6); Val: @HCBlock30Val6), 
    (RA: $88; Count: length(HCBlock30Val7); Val: @HCBlock30Val7), 
    (RA: $98; Count: length(HCBlock30Val8); Val: @HCBlock30Val8), 
    (RA: $A1; Count: length(HCBlock30Val9); Val: @HCBlock30Val9),