You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
637 lines
21 KiB
637 lines
21 KiB
/*static char *SCCSID = "%W% %E%";*/
|
|
/*
|
|
* Copyright Microsoft Corporation 1983-1987
|
|
*
|
|
* This Module contains Proprietary Information of Microsoft
|
|
* Corporation and should be treated as Confidential.
|
|
*/
|
|
|
|
/* Exepack */
|
|
|
|
/****************************************************************
|
|
* *
|
|
* PACK.C *
|
|
* *
|
|
****************************************************************/
|
|
|
|
#include <minlit.h> /* Types, constants */
|
|
#include <bndtrn.h> /* More types and constants */
|
|
#include <bndrel.h> /* More types and constants */
|
|
#include <lnkio.h> /* Linker I/O definitions */
|
|
#include <lnkmsg.h> /* Error messages */
|
|
#include <extern.h> /* External declarations */
|
|
|
|
#if FEXEPACK AND ODOS3EXE /* Whole file is conditional */
|
|
typedef struct _RUNTYPE
|
|
{
|
|
WORD wSignature;
|
|
WORD cbLastp;
|
|
WORD cpnRes;
|
|
WORD irleMax;
|
|
WORD cparDirectory;
|
|
WORD cparMinAlloc;
|
|
WORD cparMaxAlloc;
|
|
WORD saStack;
|
|
WORD raStackInit;
|
|
WORD wchksum;
|
|
WORD raStart;
|
|
WORD saStart;
|
|
WORD rbrgrle;
|
|
WORD iovMax;
|
|
WORD doslev;
|
|
}
|
|
RUNTYPE;
|
|
|
|
/* States of automaton */
|
|
#define STARTSTATE 0
|
|
#define FINDREPEAT 1
|
|
#define FINDENDRPT 2
|
|
#define EMITRECORD 3
|
|
|
|
/*
|
|
* LOCAL FUNCTION PROTOTYPES
|
|
*/
|
|
|
|
|
|
LOCAL void NEAR EmitRecords(void);
|
|
LOCAL unsigned char NEAR GetFromVM(void);
|
|
LOCAL unsigned short NEAR ScanWhileSame(void);
|
|
LOCAL unsigned short NEAR ScanWhileDifferent(void);
|
|
LOCAL WORD NEAR AfterScanning(unsigned short l);
|
|
LOCAL void NEAR OutEnum(void);
|
|
LOCAL void NEAR OutIter(SATYPE sa, WORD length);
|
|
|
|
|
|
/*
|
|
* DATA DEFINED IN UNPACK MODULE: unpack.asm
|
|
*/
|
|
|
|
#if NOT defined( _WIN32 )
|
|
extern char * FAR cdecl UnpackModule; /* Unpacker/Relocator module */
|
|
extern char FAR cdecl SegStart; // Start of unpacker
|
|
extern WORD FAR cdecl cbUnpack; /* Length of UnpackModule */
|
|
extern WORD FAR cdecl ipsave; /* Original IP */
|
|
extern WORD FAR cdecl cssave; /* Original CS */
|
|
extern WORD FAR cdecl spsave; /* Original SP */
|
|
extern WORD FAR cdecl sssave; /* Original SS */
|
|
extern WORD FAR cdecl cparExp; /* # para. in expanded image */
|
|
extern WORD FAR cdecl raStartUnpack; /* Offset of code start in unpacker */
|
|
extern WORD FAR cdecl raMoveUnpack; /* Offset of self-moving in unpacker */
|
|
extern WORD FAR cdecl raBadStack; /* Bottom of bad stack range */
|
|
extern WORD FAR cdecl szBadStack; /* Bad stack range */
|
|
#else // _WIN32
|
|
|
|
//
|
|
// For the portable NTGroup version of this linker, we can't use unpack32.asm
|
|
// directly because we need to run on RISC platforms. But we still need this
|
|
// code, which is real-mode x86 code tacked onto the DOS binary which unpacks
|
|
// the packed EXE and then calls the real entrypoint. So it's defined as a
|
|
// byte array, and the interesting offsets are hard-coded here. I came across
|
|
// these values and the code debugging link3216.exe built as the languages group
|
|
// did.
|
|
//
|
|
|
|
#define SegStart unpack
|
|
#define cbUnpack (*(WORD *) &unpack[6])
|
|
#define ipsave (*(WORD *) &unpack[0])
|
|
#define cssave (*(WORD *) &unpack[2])
|
|
#define spsave (*(WORD *) &unpack[8])
|
|
#define sssave (*(WORD *) &unpack[0xa])
|
|
#define cparExp (*(WORD *) &unpack[0xc])
|
|
#define raStartUnpack 0x10
|
|
#define raMoveUnpack 0x33
|
|
#define raBadStack 0
|
|
#define szBadStack 0x35
|
|
|
|
unsigned char unpack[] = {
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, 0x01,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0x42,
|
|
0x8b, 0xe8, 0x8c, 0xc0, 0x05, 0x10, 0x00, 0x0e,
|
|
0x1f, 0xa3, 0x04, 0x00, 0x03, 0x06, 0x0c, 0x00,
|
|
0x8e, 0xc0, 0x8b, 0x0e, 0x06, 0x00, 0x8b, 0xf9,
|
|
0x4f, 0x8b, 0xf7, 0xfd, 0xf3, 0xa4, 0x50, 0xb8,
|
|
0x34, 0x00, 0x50, 0xcb, 0x8c, 0xc3, 0x8c, 0xd8,
|
|
0x48, 0x8e, 0xd8, 0x8e, 0xc0, 0xbf, 0x0f, 0x00,
|
|
0xb9, 0x10, 0x00, 0xb0, 0xff, 0xf3, 0xae, 0x47,
|
|
0x8b, 0xf7, 0x8b, 0xc3, 0x48, 0x8e, 0xc0, 0xbf,
|
|
0x0f, 0x00, 0xb1, 0x04, 0x8b, 0xc6, 0xf7, 0xd0,
|
|
0xd3, 0xe8, 0x8c, 0xda, 0x2b, 0xd0, 0x73, 0x04,
|
|
0x8c, 0xd8, 0x2b, 0xd2, 0xd3, 0xe0, 0x03, 0xf0,
|
|
0x8e, 0xda, 0x8b, 0xc7, 0xf7, 0xd0, 0xd3, 0xe8,
|
|
0x8c, 0xc2, 0x2b, 0xd0, 0x73, 0x04, 0x8c, 0xc0,
|
|
0x2b, 0xd2, 0xd3, 0xe0, 0x03, 0xf8, 0x8e, 0xc2,
|
|
|
|
0xac, 0x8a, 0xd0, 0x4e, 0xad, 0x8b, 0xc8, 0x46,
|
|
0x8a, 0xc2, 0x24, 0xfe, 0x3c, 0xb0, 0x75, 0x05,
|
|
0xac, 0xf3, 0xaa, 0xeb, 0x06, 0x3c, 0xb2, 0x75,
|
|
0x6d, 0xf3, 0xa4, 0x8a, 0xc2, 0xa8, 0x01, 0x74,
|
|
0xb1, 0xbe, 0x32, 0x01, 0x0e, 0x1f, 0x8b, 0x1e,
|
|
0x04, 0x00, 0xfc, 0x33, 0xd2, 0xad, 0x8b, 0xc8,
|
|
0xe3, 0x13, 0x8b, 0xc2, 0x03, 0xc3, 0x8e, 0xc0,
|
|
0xad, 0x8b, 0xf8, 0x83, 0xff, 0xff, 0x74, 0x11,
|
|
0x26, 0x01, 0x1d, 0xe2, 0xf3, 0x81, 0xfa, 0x00,
|
|
0xf0, 0x74, 0x16, 0x81, 0xc2, 0x00, 0x10, 0xeb,
|
|
0xdc, 0x8c, 0xc0, 0x40, 0x8e, 0xc0, 0x83, 0xef,
|
|
0x10, 0x26, 0x01, 0x1d, 0x48, 0x8e, 0xc0, 0xeb,
|
|
0xe2, 0x8b, 0xc3, 0x8b, 0x3e, 0x08, 0x00, 0x8b,
|
|
0x36, 0x0a, 0x00, 0x03, 0xf0, 0x01, 0x06, 0x02,
|
|
0x00, 0x2d, 0x10, 0x00, 0x8e, 0xd8, 0x8e, 0xc0,
|
|
0xbb, 0x00, 0x00, 0xfa, 0x8e, 0xd6, 0x8b, 0xe7,
|
|
|
|
0xfb, 0x8b, 0xc5, 0x2e, 0xff, 0x2f, 0xb4, 0x40,
|
|
0xbb, 0x02, 0x00, 0xb9, 0x16, 0x00, 0x8c, 0xca,
|
|
0x8e, 0xda, 0xba, 0x1c, 0x01, 0xcd, 0x21, 0xb8,
|
|
0xff, 0x4c, 0xcd, 0x21, 0x50, 0x61, 0x63, 0x6b,
|
|
0x65, 0x64, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x20,
|
|
0x69, 0x73, 0x20, 0x63, 0x6f, 0x72, 0x72, 0x75,
|
|
0x70, 0x74
|
|
};
|
|
|
|
#endif // _WIN32
|
|
|
|
LOCAL WORD lastc; /* last character */
|
|
LOCAL WORD c; /* current or next character */
|
|
LOCAL WORD State = STARTSTATE;
|
|
/* current state */
|
|
LOCAL FTYPE fEnumOK; /* OK to emit enumerated records */
|
|
LOCAL WORD cbRepeat; /* length of repeated stream */
|
|
LOCAL WORD cbEnum; /* length of enumerated stream */
|
|
|
|
#define EHLEN 3 /* 2 for length + 1 for type */
|
|
#define MAXRPT 0xfff0 /* Maximum length to compress */
|
|
#define MAXENM (0xfff0-(EHLEN+1))
|
|
/* Maximum length of enum. stream */
|
|
#define MINEXP (2*EHLEN+2) /* Minimum length of repeated stream,
|
|
* after the first repeate record */
|
|
#define toAdr20(seg, off) (((long)seg << 4) + off)
|
|
|
|
LOCAL WORD minRpt = (18 * EHLEN) + 1;
|
|
/* Minimum for rpt rec begins larger */
|
|
|
|
/* Type values for expansion record headers */
|
|
|
|
#define RPTREC 0xb0 /* Repeat record */
|
|
#define ENMREC 0xb2 /* Enumerated record */
|
|
|
|
|
|
/*
|
|
* OutPack - Run a buffer through the compactor. Return value is
|
|
* undefined.
|
|
*/
|
|
void OutPack (pb, cb)
|
|
REGISTER BYTE *pb; /* Pointer to buffer */
|
|
unsigned cb; /* Number of bytes to compress */
|
|
{
|
|
REGISTER BYTE *endp; /* Pointer to end of buffer */
|
|
|
|
endp = &pb[cb];
|
|
|
|
while (pb < endp)
|
|
switch (State)
|
|
{
|
|
case STARTSTATE:
|
|
lastc = *pb++;
|
|
State = FINDREPEAT;
|
|
break;
|
|
|
|
case FINDREPEAT:
|
|
if (cbEnum >= MAXENM)
|
|
{
|
|
EmitRecords();
|
|
State = FINDREPEAT;
|
|
break;
|
|
}
|
|
c = *pb++;
|
|
if (c == lastc)
|
|
{
|
|
cbRepeat = 2;
|
|
State = FINDENDRPT;
|
|
break;
|
|
}
|
|
/* At this point c != lastc */
|
|
fputc(lastc, bsRunfile);
|
|
cbEnum++;
|
|
lastc = c;
|
|
break;
|
|
|
|
case FINDENDRPT:
|
|
c = *pb++;
|
|
if (c == lastc && cbRepeat < MAXRPT)
|
|
{
|
|
cbRepeat++;
|
|
break;
|
|
}
|
|
if (cbRepeat < minRpt)
|
|
{
|
|
/*
|
|
* Not long enough. Enum record swallows
|
|
* repeated chars.
|
|
*/
|
|
while (cbEnum <= MAXENM && cbRepeat > 0)
|
|
{
|
|
fputc(lastc, bsRunfile);
|
|
cbEnum++;
|
|
cbRepeat--;
|
|
}
|
|
if (cbRepeat > 0)
|
|
EmitRecords();
|
|
} else
|
|
EmitRecords();
|
|
lastc = c; /* Prepare for next stream */
|
|
State = FINDREPEAT;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* EmitRecords - Emits 1 or 2 expansion records. Return value is
|
|
* undefined.
|
|
*/
|
|
|
|
LOCAL void NEAR EmitRecords ()
|
|
{
|
|
/* We have 1 or 2 records to output */
|
|
if (cbEnum > 0)
|
|
{
|
|
#if MDEBUG AND FDEBUG
|
|
if (fDebug) fprintf(stdout, "E%8x\n", cbEnum);
|
|
#endif
|
|
if (fEnumOK)
|
|
{
|
|
/* Output an enumerated record header */
|
|
OutWord(cbEnum);
|
|
fputc(ENMREC, bsRunfile);
|
|
}
|
|
cbEnum = 0;
|
|
}
|
|
if (cbRepeat >= minRpt)
|
|
{
|
|
#if MDEBUG AND FDEBUG
|
|
if (fDebug) fprintf(stdout, "R%8x\n", cbRepeat);
|
|
#endif
|
|
/* Output a repeat record */
|
|
fputc(lastc, bsRunfile);
|
|
OutWord(cbRepeat);
|
|
if (!fEnumOK)
|
|
{
|
|
/* 1st record header generated */
|
|
fputc(RPTREC|1, bsRunfile);
|
|
fEnumOK = 1;
|
|
} else
|
|
fputc(RPTREC, bsRunfile);
|
|
cbRepeat = 0;
|
|
minRpt = MINEXP; /* 1st is out, so reset minRpt */
|
|
} else if (cbRepeat > 0)
|
|
{
|
|
cbEnum = cbRepeat;
|
|
while (cbRepeat-- > 0)
|
|
fputc(lastc, bsRunfile);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* EndPack - End the packing procedure: add the relocator module.
|
|
*/
|
|
void EndPack (prun)
|
|
RUNTYPE *prun; /* Pointer to runfile header */
|
|
{
|
|
long fpos; /* File position */
|
|
WORD cparPacked; /* # paras in packed image */
|
|
WORD cparUnpack; /* Size of Unpack module (paras) */
|
|
int i;
|
|
int crle; /* Count of relocs for a frame */
|
|
long cTmp; /* Temporary count */
|
|
long us; /* User's stack in minalloc */
|
|
long los; /* Low end of forbidden stack */
|
|
|
|
|
|
if (fseek(bsRunfile, 0L, 2)) /* Go to end of file */
|
|
Fatal(ER_ioerr, strerror(errno));
|
|
|
|
cTmp = (((((long)prun->cpnRes-1)<<5) - prun->cparDirectory) << 4) +
|
|
(prun->cbLastp ? prun->cbLastp : 512);
|
|
/* Get # bytes in expanded image */
|
|
cbRepeat += (WORD) (0xf & (0x10 - (0xf & cTmp)));
|
|
/* Make it look like image ends on
|
|
* paragraph boundary */
|
|
if (State == FINDREPEAT)
|
|
{
|
|
fputc(lastc, bsRunfile); /* Update last enum record */
|
|
cbEnum++;
|
|
}
|
|
minRpt = 1; /* Force final repeat rec. out */
|
|
EmitRecords(); /* Output the final record(s) */
|
|
|
|
cparExp = (short) ((cTmp + 0xf) >> 4);/* Save # paras in image */
|
|
|
|
/*
|
|
* Append the unpacking module (relocator-expander)
|
|
*/
|
|
fpos = ftell(bsRunfile); /* Save where Unpack begins */
|
|
|
|
/* Align Unpack on paragraph boundary */
|
|
while (fpos & 0x0f)
|
|
{
|
|
fpos++;
|
|
fputc(0xff, bsRunfile);
|
|
}
|
|
|
|
/* Make sure User stack won't stomp on unpack code */
|
|
|
|
us = toAdr20(prun->saStack, prun->raStackInit);
|
|
los = toAdr20((cTmp >> 4), raBadStack);
|
|
|
|
while ( us > los && us - los < szBadStack )
|
|
{
|
|
for (i = 0; i < 16; i++)
|
|
{
|
|
us--;
|
|
fpos++;
|
|
fputc(0xff, bsRunfile);
|
|
}
|
|
}
|
|
|
|
fflush(bsRunfile);
|
|
|
|
cparPacked = (WORD) ((fpos >> 4) - prun->cparDirectory);
|
|
if (cTmp < ((long)cparPacked << 4) + raMoveUnpack)
|
|
Fatal(ER_badpack);
|
|
|
|
/* Append relocator module (Unpack). This code depends
|
|
* closely on the structure of unpack.asm. */
|
|
|
|
/* Get length of relocation area */
|
|
for (crle = 0, i = 0; i < 16; i++)
|
|
crle += (mpframeRlc[i].count + 1) << 1;
|
|
|
|
/* Initialize stack of relocator module */
|
|
ipsave = prun->raStart;
|
|
cssave = prun->saStart;
|
|
#if defined( _WIN32 )
|
|
if (cbUnpack != sizeof(unpack))
|
|
Fatal(ER_badpack);
|
|
#endif
|
|
i = cbUnpack;
|
|
cbUnpack += (WORD)crle;
|
|
spsave = prun->raStackInit;
|
|
sssave = prun->saStack;
|
|
#ifdef M_BYTESWAP
|
|
bswap(Unpack, 7);
|
|
#endif
|
|
#if DOSX32
|
|
WriteExe(&SegStart, i);
|
|
#else
|
|
fwrite(UnpackModule, 1, i, bsRunfile);
|
|
#endif
|
|
/* Append optimized relocation records */
|
|
for (i = 0; i < 16; i++)
|
|
{
|
|
crle = mpframeRlc[i].count;
|
|
OutWord((WORD) crle);
|
|
WriteExe(mpframeRlc[i].rgRlc, crle * sizeof(WORD));
|
|
}
|
|
|
|
/* Correct header values */
|
|
fpos += cbUnpack;
|
|
prun->cbLastp = (WORD) (fpos & 0x1ff);
|
|
prun->cpnRes = (WORD) ((fpos + 511) >> 9);
|
|
prun->irleMax = 0;
|
|
cparUnpack = (cbUnpack + 0xf) >> 4;
|
|
prun->cparMinAlloc = (cparExp + max(prun->cparMinAlloc,(cparUnpack+8)))
|
|
- (cparPacked + cparUnpack);
|
|
if (prun->cparMaxAlloc < prun->cparMinAlloc)
|
|
prun->cparMaxAlloc = prun->cparMinAlloc;
|
|
prun->saStack = cparExp + cparUnpack;
|
|
prun->raStackInit = 128;
|
|
prun->raStart = raStartUnpack;
|
|
prun->saStart = cparPacked;
|
|
if (fseek(bsRunfile, 0L, 0))
|
|
Fatal(ER_ioerr, strerror(errno));
|
|
OutHeader((struct exe_hdr *) prun);
|
|
if (fseek(bsRunfile, fpos, 0))
|
|
Fatal(ER_ioerr, strerror(errno));
|
|
}
|
|
|
|
#ifdef M_BYTESWAP
|
|
/*
|
|
* Swap bytes for 1st n words in buffer.
|
|
*/
|
|
LOCAL bswap (buf, n)
|
|
REGISTER char *buf;
|
|
REGISTER int n;
|
|
{
|
|
REGISTER char swapb;
|
|
|
|
for ( ; n-- > 0 ; buf += 2)
|
|
{
|
|
swapb = buf[0];
|
|
buf[0] = buf[1];
|
|
buf[1] = swapb;
|
|
}
|
|
}
|
|
#endif
|
|
#endif /*FEXEPACK AND ODOS3EXE*/
|
|
|
|
/*
|
|
* The following routines concern packing segmented-executable format
|
|
* files.
|
|
*/
|
|
#if FALSE
|
|
#define MINREPEAT 32 /* Min length of iteration cousing compression */
|
|
|
|
LOCAL long vaLast; /* Virtual address */
|
|
LOCAL long vaStart; /* Virtual scanning start address */
|
|
LOCAL long BufEnd; /* Virtual address of buffer end */
|
|
#if EXE386
|
|
LOCAL long ra; /* Offset within packed segment */
|
|
#endif
|
|
LOCAL BYTE LastB;
|
|
LOCAL BYTE CurrentB;
|
|
LOCAL long VPageAddress; /* Virtual address of current page */
|
|
LOCAL WORD VPageOffset; /* Current position within virtual page */
|
|
LOCAL BYTE *PageBuffer; /* Virtual page buffer */
|
|
|
|
|
|
LOCAL BYTE NEAR GetFromVM()
|
|
{
|
|
|
|
if (VPageOffset == PAGLEN)
|
|
{
|
|
PageBuffer = mapva(VPageAddress, FALSE);
|
|
/* Fetch page */
|
|
VPageAddress += PAGLEN; /* Update page virtual address */
|
|
VPageOffset = 0; /* Init page offset */
|
|
}
|
|
return(PageBuffer[VPageOffset++]);
|
|
}
|
|
|
|
|
|
LOCAL WORD NEAR ScanWhileSame()
|
|
{
|
|
long l;
|
|
|
|
l = 2L; /* We are looking at two bytes in buffer */
|
|
while (CurrentB == LastB)
|
|
{
|
|
if (vaStart + l >= BufEnd)
|
|
return((WORD) l); /* We bump the buffer end */
|
|
|
|
CurrentB = GetFromVM();
|
|
l++;
|
|
}
|
|
return(l == 2L ? 0 : (WORD) (l - 1));
|
|
/* We went one byte too far to detect they are different */
|
|
}
|
|
|
|
|
|
LOCAL WORD NEAR ScanWhileDifferent()
|
|
{
|
|
long l;
|
|
|
|
l = 2L; /* We are looking at two bytes in buffer */
|
|
while (CurrentB != LastB)
|
|
{
|
|
if (vaStart + l >= BufEnd)
|
|
return((WORD) l); /* We bump the buffer end */
|
|
|
|
LastB = CurrentB;
|
|
CurrentB = GetFromVM();
|
|
l++;
|
|
}
|
|
return((WORD) (l - 2)); /* We went two bytes too far to detect they are the same */
|
|
}
|
|
|
|
|
|
LOCAL WORD NEAR AfterScanning(l)
|
|
WORD l; /* Length of scanned bytes */
|
|
{
|
|
vaStart += l; /* Update scan start address */
|
|
#if EXE386
|
|
ra += l; /* Update offset in segment */
|
|
#endif
|
|
if (vaStart + 2 >= BufEnd)
|
|
{ /* We need at least to bytes remaining */
|
|
return(FALSE); /* Buffer end */
|
|
}
|
|
else
|
|
{
|
|
if (LastB != CurrentB)
|
|
{ /* We stop at iterated and enumerated */
|
|
LastB = CurrentB; /* byte sequence, so we have move */
|
|
CurrentB = GetFromVM(); /* one byte forward */
|
|
}
|
|
return((WORD) TRUE);
|
|
}
|
|
}
|
|
|
|
|
|
LOCAL void NEAR OutEnum(void)
|
|
{
|
|
#if EXE386
|
|
if (ExeFormat == Exe386)
|
|
OutVm(vaLast, vaStart - vaLast);
|
|
else
|
|
{
|
|
#endif
|
|
OutWord(1);
|
|
OutWord((WORD) (vaStart - vaLast));
|
|
OutVm(vaLast, vaStart - vaLast);
|
|
#if EXE386
|
|
}
|
|
#endif
|
|
|
|
PageBuffer = mapva((VPageAddress - PAGLEN), FALSE);
|
|
/* Refetch page */
|
|
}
|
|
|
|
|
|
LOCAL void NEAR OutIter(SATYPE sa, WORD length)
|
|
{
|
|
#if EXE386
|
|
ITER idata; /* Iterated data description for range */
|
|
|
|
|
|
if (ExeFormat == Exe386)
|
|
{
|
|
idata.iterations = (DWORD) length;
|
|
idata.length = (DWORD) 1;
|
|
idata.data = (DWORD) LastB;
|
|
UpdateRanges(ShortIterData, sa, ra, &idata);
|
|
}
|
|
else
|
|
{
|
|
#endif
|
|
OutWord(length);
|
|
OutWord(1);
|
|
OutByte(bsRunfile, LastB);
|
|
#if EXE386
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* Out5Pack - Run a buffer through the compactor. Return value is
|
|
* starting position where data was written to output file.
|
|
*/
|
|
|
|
|
|
long Out5Pack (sa, packed)
|
|
SATYPE sa; /* File segment to be packed */
|
|
WORD *packed; /* TRUE if iterated records written */
|
|
{
|
|
WORD proceed; /* True if there are bytes to scan */
|
|
WORD length; /* Scanned bytes length */
|
|
long lfaStart; /* Starting file address */
|
|
|
|
|
|
lfaStart = ftell(bsRunfile); /* Get the starting address */
|
|
VPageAddress = AREASA(sa);
|
|
VPageOffset = PAGLEN;
|
|
*packed = FALSE;
|
|
if (mpsacbinit[sa] > 1L)
|
|
{ /* If buffer is big enough */
|
|
#if EXE386
|
|
ra = 0L; /* Offset within segment */
|
|
#endif
|
|
vaStart = VPageAddress;
|
|
vaLast = vaStart;
|
|
BufEnd = vaStart + mpsacbinit[sa];
|
|
LastB = GetFromVM();
|
|
CurrentB = GetFromVM();
|
|
proceed = (WORD) TRUE; /* Initialize */
|
|
|
|
while (proceed)
|
|
{
|
|
length = ScanWhileDifferent();
|
|
if (!(proceed = AfterScanning(length)))
|
|
break;
|
|
|
|
if ((length = ScanWhileSame()) > MINREPEAT)
|
|
{ /* If there are enough same bytes */
|
|
if (vaLast != vaStart)
|
|
OutEnum(); /* First write out preceeding diff. bytes */
|
|
|
|
OutIter(sa, length); /* Now write out iterated record */
|
|
proceed = AfterScanning(length);
|
|
*packed = (WORD) TRUE;
|
|
vaLast = vaStart;
|
|
}
|
|
else proceed = AfterScanning(length);
|
|
/* Otherwise enumerated record swallow this */
|
|
} /* small repeated record */
|
|
}
|
|
if (*packed)
|
|
{
|
|
if (vaLast != BufEnd)
|
|
{
|
|
vaStart = BufEnd;
|
|
OutEnum(); /* Write out any remainig bytes */
|
|
}
|
|
|
|
mpsacbinit[sa] = ftell(bsRunfile) - lfaStart;
|
|
/* Return number of written bytes */
|
|
return(lfaStart);
|
|
}
|
|
else
|
|
return(OutVm(AREASA(sa),mpsacbinit[sa]));
|
|
}
|
|
#endif /*FEXEPACK AND OSEGEXE*/
|