objfileconsts.pas

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

  HCBlock14Vars: array[0..8] of TCVar = (
    (RA: $12; VN: 'heapLock'), 
    (RA: $1D; VN: 'IsMultiThread'), 
    (RA: $2F; VN: 'spaceRoot'), 
    (RA: $39; VN: 'decommittedRoot'), 
    (RA: $43; VN: 'committedRoot'), 
    (RA: $59; VN: 'smallTab'), 
    (RA: $80; VN: 'avail'), 
    (RA: $8A; VN: 'rover'), 
    (RA: $90; VN: 'initialized'));
  HCBlock14IA: array[0..1] of TIA = (
    (RA: $7; RRA: $B6), 
    (RA: $9E; RRA: $BD));
  HCBlock14: THCBlock = (
    Size: $C4;
    RAC: length(HCBlock14RA); RA: @HCBlock14RA;
    ValC: length(HCBlock14Val); Val: @HCBlock14Val;
    VarsC: length(HCBlock14Vars); Vars: @HCBlock14Vars;
    IAC: length(HCBlock14IA); IA: @HCBlock14IA;
    PRC: 0; PR: nil);

  HCBlock15RA: array[0..0] of TRA = (
    (RA: $0; PN: 'UniniAllocator'; CN: ''));
  HCBlock15Val0: array[0..5] of byte = (
    $55, $8B, $EC, $53, $80, $3D);
  HCBlock15Val1: array[0..9] of byte = (
    $0F, $84, $CC, $00, $00, $00, $33, $D2, $55, $68);
  HCBlock15Val2: array[0..7] of byte = (
    $64, $FF, $32, $64, $89, $22, $80, $3D);
  HCBlock15Val3: array[0..2] of byte = (
    $74, $0A, $68);
  HCBlock15Val4: array[0..0] of byte = (
    $E8);
  HCBlock15Val5: array[0..1] of byte = (
    $C6, $05);
  HCBlock15Val6: array[0..0] of byte = (
    $A1);
  HCBlock15Val7: array[0..1] of byte = (
    $50, $E8);
  HCBlock15Val8: array[0..2] of byte = (
    $33, $C0, $A3);
  HCBlock15Val9: array[0..1] of byte = (
    $8B, $1D);
  HCBlock15Val10: array[0..13] of byte = (
    $EB, $12, $68, $00, $80, $00, $00, $6A, $00, $8B, $43, $08, $50, $E8);
  HCBlock15Val11: array[0..3] of byte = (
    $8B, $1B, $81, $FB);
  HCBlock15Val12: array[0..2] of byte = (
    $75, $E6, $B8);
  HCBlock15Val13: array[0..0] of byte = (
    $E8);
  HCBlock15Val14: array[0..0] of byte = (
    $B8);
  HCBlock15Val15: array[0..0] of byte = (
    $E8);
  HCBlock15Val16: array[0..0] of byte = (
    $B8);
  HCBlock15Val17: array[0..0] of byte = (
    $E8);
  HCBlock15Val18: array[0..0] of byte = (
    $A1);
  HCBlock15Val19: array[0..7] of byte = (
    $85, $C0, $74, $17, $8B, $10, $89, $15);
  HCBlock15Val20: array[0..1] of byte = (
    $50, $E8);
  HCBlock15Val21: array[0..0] of byte = (
    $A1);
  HCBlock15Val22: array[0..12] of byte = (
    $85, $C0, $75, $E9, $33, $C0, $5A, $59, $59, $64, $89, $10, $68);
  HCBlock15Val23: array[0..1] of byte = (
    $80, $3D);
  HCBlock15Val24: array[0..2] of byte = (
    $74, $0A, $68);
  HCBlock15Val25: array[0..0] of byte = (
    $E8);
  HCBlock15Val26: array[0..0] of byte = (
    $68);
  HCBlock15Val27: array[0..0] of byte = (
    $E8);
  HCBlock15Val28: array[0..1] of byte = (
    $C3, $E9);
  HCBlock15Val29: array[0..4] of byte = (
    $EB, $DB, $5B, $5D, $C3);
  HCBlock15Val: array[0..29] of TVal = (
    (RA: $0; Count: length(HCBlock15Val0); Val: @HCBlock15Val0), 
    (RA: $B; Count: length(HCBlock15Val1); Val: @HCBlock15Val1), 
    (RA: $19; Count: length(HCBlock15Val2); Val: @HCBlock15Val2), 
    (RA: $26; Count: length(HCBlock15Val3); Val: @HCBlock15Val3), 
    (RA: $2D; Count: length(HCBlock15Val4); Val: @HCBlock15Val4), 
    (RA: $32; Count: length(HCBlock15Val5); Val: @HCBlock15Val5), 
    (RA: $39; Count: length(HCBlock15Val6); Val: @HCBlock15Val6), 
    (RA: $3E; Count: length(HCBlock15Val7); Val: @HCBlock15Val7), 
    (RA: $44; Count: length(HCBlock15Val8); Val: @HCBlock15Val8), 
    (RA: $4B; Count: length(HCBlock15Val9); Val: @HCBlock15Val9), 
    (RA: $51; Count: length(HCBlock15Val10); Val: @HCBlock15Val10), 
    (RA: $63; Count: length(HCBlock15Val11); Val: @HCBlock15Val11), 
    (RA: $6B; Count: length(HCBlock15Val12); Val: @HCBlock15Val12), 
    (RA: $72; Count: length(HCBlock15Val13); Val: @HCBlock15Val13), 
    (RA: $77; Count: length(HCBlock15Val14); Val: @HCBlock15Val14), 
    (RA: $7C; Count: length(HCBlock15Val15); Val: @HCBlock15Val15), 
    (RA: $81; Count: length(HCBlock15Val16); Val: @HCBlock15Val16), 
    (RA: $86; Count: length(HCBlock15Val17); Val: @HCBlock15Val17), 
    (RA: $8B; Count: length(HCBlock15Val18); Val: @HCBlock15Val18), 
    (RA: $90; Count: length(HCBlock15Val19); Val: @HCBlock15Val19), 
    (RA: $9C; Count: length(HCBlock15Val20); Val: @HCBlock15Val20), 
    (RA: $A2; Count: length(HCBlock15Val21); Val: @HCBlock15Val21), 
    (RA: $A7; Count: length(HCBlock15Val22); Val: @HCBlock15Val22), 
    (RA: $B8; Count: length(HCBlock15Val23); Val: @HCBlock15Val23), 
    (RA: $BF; Count: length(HCBlock15Val24); Val: @HCBlock15Val24), 
    (RA: $C6; Count: length(HCBlock15Val25); Val: @HCBlock15Val25),
    (RA: $CB; Count: length(HCBlock15Val26); Val: @HCBlock15Val26), 
    (RA: $D0; Count: length(HCBlock15Val27); Val: @HCBlock15Val27), 
    (RA: $D5; Count: length(HCBlock15Val28); Val: @HCBlock15Val28), 
    (RA: $DB; Count: length(HCBlock15Val29); Val: @HCBlock15Val29));
  HCBlock15Vars: array[0..7] of TCVar = (
    (RA: $6; VN: 'initialized'), 
    (RA: $21; VN: 'IsMultiThread'), 
    (RA: $29; VN: 'heapLock'), 
    (RA: $3A; VN: 'smallTab'), 
    (RA: $4D; VN: 'spaceRoot'), 
    (RA: $78; VN: 'decommittedRoot'), 
    (RA: $82; VN: 'committedRoot'), 
    (RA: $8C; VN: 'blockDescBlockList'));
  HCBlock15IA: array[0..1] of TIA = (
    (RA: $15; RRA: $D6), 
    (RA: $B4; RRA: $DD));
  HCBlock15: THCBlock = (
    Size: $E0;
    RAC: length(HCBlock15RA); RA: @HCBlock15RA;
    ValC: length(HCBlock15Val); Val: @HCBlock15Val;
    VarsC: length(HCBlock15Vars); Vars: @HCBlock15Vars;
    IAC: length(HCBlock15IA); IA: @HCBlock15IA;
    PRC: 0; PR: nil);

  HCBlock16RA: array[0..0] of TRA = (
    (RA: $0; PN: 'DeleteFree'; CN: ''));
  HCBlock16Val0: array[0..2] of byte = (
    $53, $3B, $05);
  HCBlock16Val1: array[0..6] of byte = (
    $75, $09, $8B, $50, $04, $89, $15);
  HCBlock16Val2: array[0..28] of byte = (
    $8B, $50, $04, $8B, $48, $08, $81, $F9, $00, $10, $00, $00, $7F, $38, $3B, $C2,
    $75, $17, $85, $C9, $79, $03, $83, $C1, $03, $C1, $F9, $02, $A1);
  HCBlock16Val3: array[0..19] of byte = (
    $33, $D2, $89, $54, $88, $F4, $EB, $24, $85, $C9, $79, $03, $83, $C1, $03, $C1,
    $F9, $02, $8B, $1D);
  HCBlock16Val4: array[0..21] of byte = (
    $89, $54, $8B, $F4, $8B, $00, $89, $02, $89, $50, $04, $5B, $C3, $8B, $00, $89, 
    $02, $89, $50, $04, $5B, $C3);
  HCBlock16Val: array[0..4] of TVal = (
    (RA: $0; Count: length(HCBlock16Val0); Val: @HCBlock16Val0), 
    (RA: $7; Count: length(HCBlock16Val1); Val: @HCBlock16Val1), 
    (RA: $12; Count: length(HCBlock16Val2); Val: @HCBlock16Val2), 
    (RA: $33; Count: length(HCBlock16Val3); Val: @HCBlock16Val3), 
    (RA: $4B; Count: length(HCBlock16Val4); Val: @HCBlock16Val4));
  HCBlock16Vars: array[0..1] of TCVar = (
    (RA: $3; VN: 'rover'), 
    (RA: $2F; VN: 'smallTab'));
  HCBlock16: THCBlock = (
    Size: $64;
    RAC: length(HCBlock16RA); RA: @HCBlock16RA;
    ValC: length(HCBlock16Val); Val: @HCBlock16Val;
    VarsC: length(HCBlock16Vars); Vars: @HCBlock16Vars;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock17RA: array[0..0] of TRA = (
    (RA: $0; PN: 'FindCommitted'; CN: ''));
  HCBlock17Val0: array[0..1] of byte = (
    $8B, $15);
  HCBlock17Val1: array[0..19] of byte = (
    $EB, $10, $8B, $4A, $08, $3B, $C1, $72, $07, $03, $4A, $0C, $3B, $C1, $72, $16,
    $8B, $12, $81, $FA);
  HCBlock17Val2: array[0..3] of byte = (
    $75, $E8, $C7, $05);
  HCBlock17Val3: array[0..4] of byte = (
    $33, $D2, $8B, $C2, $C3);
  HCBlock17Val: array[0..3] of TVal = (
    (RA: $0; Count: length(HCBlock17Val0); Val: @HCBlock17Val0), 
    (RA: $6; Count: length(HCBlock17Val1); Val: @HCBlock17Val1), 
    (RA: $1E; Count: length(HCBlock17Val2); Val: @HCBlock17Val2), 
    (RA: $2A; Count: length(HCBlock17Val3); Val: @HCBlock17Val3));
  HCBlock17Vars: array[0..1] of TCVar = (
    (RA: $2; VN: 'committedRoot'), 
    (RA: $22; VN: 'heapErrorCode'));
  HCBlock17: THCBlock = (
    Size: $30;
    RAC: length(HCBlock17RA); RA: @HCBlock17RA;
    ValC: length(HCBlock17Val); Val: @HCBlock17Val;
    VarsC: length(HCBlock17Vars); Vars: @HCBlock17Vars;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock18RA: array[0..0] of TRA = (
    (RA: $0; PN: 'FillBeforeGap'; CN: ''));
  HCBlock18Val0: array[0..22] of byte = (
    $53, $8B, $CA, $83, $E9, $04, $8D, $1C, $01, $83, $FA, $10, $7C, $0F, $C7, $03, 
    $07, $00, $00, $80, $8B, $D1, $E8);
  HCBlock18Val1: array[0..20] of byte = (
    $5B, $C3, $83, $FA, $04, $7C, $0C, $8B, $CA, $81, $C9, $02, $00, $00, $80, $89, 
    $08, $89, $0B, $5B, $C3);
  HCBlock18Val: array[0..1] of TVal = (
    (RA: $0; Count: length(HCBlock18Val0); Val: @HCBlock18Val0),
    (RA: $1B; Count: length(HCBlock18Val1); Val: @HCBlock18Val1));
  HCBlock18: THCBlock = (
    Size: $30;
    RAC: length(HCBlock18RA); RA: @HCBlock18RA;
    ValC: length(HCBlock18Val); Val: @HCBlock18Val;
    VarsC: 0; Vars: nil;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock19RA: array[0..0] of TRA = (
    (RA: $0; PN: 'InternalFreeMem'; CN: ''));
  HCBlock19Val0: array[0..17] of byte = (
    $8B, $D0, $83, $EA, $04, $8B, $12, $81, $E2, $FC, $FF, $FF, $7F, $83, $EA, $04, 
    $01, $15);
  HCBlock19Val1: array[0..0] of byte = (
    $C3);
  HCBlock19Val: array[0..1] of TVal = (
    (RA: $6; Count: length(HCBlock19Val0); Val: @HCBlock19Val0),
    (RA: $21; Count: length(HCBlock19Val1); Val: @HCBlock19Val1));
  HCBlock19Vars: array[0..1] of TCVar = (
    (RA: $2; VN: 'AllocMemCount'),
    (RA: $18; VN: 'AllocMemSize'));
  HCBlock19: THCBlock = (
    Size: $24;
    RAC: length(HCBlock19RA); RA: @HCBlock19RA;
    ValC: length(HCBlock19Val); Val: @HCBlock19Val;
    VarsC: length(HCBlock19Vars); Vars: @HCBlock19Vars;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock20RA: array[0..0] of TRA = (
    (RA: $0; PN: 'FillAfterGap'; CN: ''));
  HCBlock20Val0: array[0..13] of byte = (
    $83, $FA, $0C, $7C, $0E, $83, $CA, $02, $89, $10, $83, $C0, $04, $E8);
  HCBlock20Val1: array[0..21] of byte = (
    $C3, $83, $FA, $04, $7C, $0A, $8B, $CA, $81, $C9, $02, $00, $00, $80, $89, $08, 
    $03, $C2, $83, $20, $FE, $C3);
  HCBlock20Val: array[0..1] of TVal = (
    (RA: $0; Count: length(HCBlock20Val0); Val: @HCBlock20Val0), 
    (RA: $12; Count: length(HCBlock20Val1); Val: @HCBlock20Val1));
  HCBlock20: THCBlock = (
    Size: $28;
    RAC: length(HCBlock20RA); RA: @HCBlock20RA;
    ValC: length(HCBlock20Val); Val: @HCBlock20Val;
    VarsC: 0; Vars: nil;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock21RA: array[0..0] of TRA = (
    (RA: $0; PN: 'FillerSizeBeforeGap'; CN: ''));
  HCBlock21Val0: array[0..26] of byte = (
    $53, $56, $8B, $D0, $83, $EA, $04, $8B, $12, $8B, $CA, $81, $E1, $02, $00, $00, 
    $80, $81, $F9, $02, $00, $00, $80, $74, $0A, $C7, $05);
  HCBlock21Val1: array[0..23] of byte = (
    $8B, $DA, $81, $E3, $FC, $FF, $FF, $7F, $2B, $C3, $8B, $C8, $33, $11, $F7, $C2, 
    $FE, $FF, $FF, $FF, $74, $0A, $C7, $05);
  HCBlock21Val2: array[0..21] of byte = (
    $F6, $01, $01, $74, $20, $8B, $D0, $83, $EA, $0C, $8B, $72, $08, $2B, $C6, $3B, 
    $70, $08, $74, $0A, $C7, $05);
  HCBlock21Val3: array[0..0] of byte = (
    $E8);
  HCBlock21Val4: array[0..6] of byte = (
    $03, $DE, $8B, $C3, $5E, $5B, $C3);
  HCBlock21Val: array[0..4] of TVal = (
    (RA: $0; Count: length(HCBlock21Val0); Val: @HCBlock21Val0), 
    (RA: $23; Count: length(HCBlock21Val1); Val: @HCBlock21Val1), 
    (RA: $43; Count: length(HCBlock21Val2); Val: @HCBlock21Val2), 
    (RA: $61; Count: length(HCBlock21Val3); Val: @HCBlock21Val3), 
    (RA: $66; Count: length(HCBlock21Val4); Val: @HCBlock21Val4));
  HCBlock21Vars: array[0..0] of TCVar = (
    (RA: $1B; VN: 'heapErrorCode'));
  HCBlock21: THCBlock = (
    Size: $70;
    RAC: length(HCBlock21RA); RA: @HCBlock21RA;
    ValC: length(HCBlock21Val); Val: @HCBlock21Val;
    VarsC: length(HCBlock21Vars); Vars: @HCBlock21Vars;
    IAC: 0; IA: nil;
    PRC: 0; PR: nil);

  HCBlock22RA: array[0..0] of TRA = (
    (RA: $0; PN: 'FillerSizeAfterGap'; CN: ''));
  HCBlock22Val0: array[0..35] of byte = (
    $53, $56, $57, $8B, $D8, $33, $FF, $8B, $03, $A9, $00, $00, $00, $80, $74, $0B, 
    $25, $FC, $FF, $FF, $7F, $03, $F8, $03, $D8, $8B, $03, $A8, $02, $75, $13, $8B,