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.
1633 lines
48 KiB
1633 lines
48 KiB
/*
|
|
* Copyright Microsoft Corporation, 1983-1989
|
|
*
|
|
* This Module contains Proprietary Information of Microsoft
|
|
* Corporation and should be treated as Confidential.
|
|
*/
|
|
/****************************************************************
|
|
* *
|
|
* FLAG PROCESSOR MODULE *
|
|
* *
|
|
****************************************************************/
|
|
|
|
#include <minlit.h> /* Types and constants */
|
|
#include <bndtrn.h> /* Types and constants */
|
|
#include <bndrel.h> /* Types and constants */
|
|
#include <lnkio.h> /* Linker I/O definitions */
|
|
#include <lnkmsg.h> /* Error messages */
|
|
#if OIAPX286
|
|
#include <xenfmt.h> /* x.out definitions */
|
|
#endif
|
|
#include <extern.h> /* External declarations */
|
|
#include <newexe.h> /* DOS & 286 .EXE format structure def.s */
|
|
#if EXE386
|
|
#include <exe386.h> /* 386 .EXE format structure def.s */
|
|
#endif
|
|
#include <process.h>
|
|
|
|
extern FTYPE fNoExtDic; /* Not searching extended dictionary */
|
|
|
|
LOCAL BYTE *osbSwitch; /* Switch pointer */
|
|
LOCAL MSGTYPE SwitchErr; /* Switch error number */
|
|
|
|
/*
|
|
* FUNCTION PROTOTYPES
|
|
*/
|
|
|
|
#if TIMINGS
|
|
LOCAL void NEAR SwShowTiming(void);
|
|
#endif // TIMINGS
|
|
#if PCODE
|
|
LOCAL void NEAR SwPCode(void);
|
|
#endif
|
|
LOCAL void NEAR SwAlign(void);
|
|
LOCAL void NEAR SwBatch(void);
|
|
#if ODOS3EXE
|
|
LOCAL void NEAR SwBinary(void);
|
|
#endif
|
|
LOCAL void NEAR SwCase(void);
|
|
LOCAL void NEAR SwCParMax(void);
|
|
LOCAL void NEAR SwDelexe(void);
|
|
LOCAL void NEAR SwDosExtend(void);
|
|
LOCAL void NEAR SwDosseg(void);
|
|
LOCAL void NEAR SwDSAlloc(void);
|
|
LOCAL void NEAR SwDynamic(void);
|
|
LOCAL void NEAR SwIdef(void);
|
|
LOCAL void NEAR SwOldOvl(void);
|
|
LOCAL void NEAR SwExePack(void);
|
|
LOCAL void NEAR SwFarCall(void);
|
|
#if EXE386
|
|
LOCAL void NEAR SwHeader(void);
|
|
#endif
|
|
#if NOT WIN_3
|
|
LOCAL void NEAR SwHelp(void);
|
|
LOCAL void NEAR SwShortHelp(void);
|
|
#endif
|
|
LOCAL void NEAR SwHigh(void);
|
|
#if ILINK
|
|
LOCAL void NEAR SwIncremental(void);
|
|
#endif
|
|
LOCAL void NEAR SwInfo(void);
|
|
LOCAL void NEAR SwIntNo(void);
|
|
#if (OSEGEXE AND defined(LEGO)) OR EXE386
|
|
LOCAL void NEAR SwKeepFixups(void);
|
|
#endif
|
|
#if EXE386
|
|
LOCAL void NEAR SwKeepVSize(void);
|
|
#endif
|
|
LOCAL void NEAR SwLineNos(void);
|
|
LOCAL void NEAR SwMap(void);
|
|
#if O68K
|
|
LOCAL void NEAR SwMac(void);
|
|
#endif /* O68K */
|
|
#if WIN_NT
|
|
LOCAL void NEAR SwMemAlign(void);
|
|
#endif
|
|
#if NOT EXE386
|
|
LOCAL void NEAR SwNewFiles(void);
|
|
#endif
|
|
LOCAL void NEAR SwNoDefLib(void);
|
|
LOCAL void NEAR SwNoExtDic(void);
|
|
LOCAL void NEAR SwNoFarCall(void);
|
|
LOCAL void NEAR SwNoGrp(void);
|
|
LOCAL void NEAR SwNologo();
|
|
LOCAL void NEAR SwNonulls(void);
|
|
LOCAL void NEAR SwNoPack(void);
|
|
LOCAL void NEAR SwNoUseReal(void);
|
|
LOCAL void NEAR SwPack(void);
|
|
LOCAL void NEAR SwPackData(void);
|
|
LOCAL void NEAR SwPackFunctions(void);
|
|
LOCAL void NEAR SwNoPackFunctions(void);
|
|
LOCAL void NEAR SwPadCode(void);
|
|
LOCAL void NEAR SwPadData(void);
|
|
LOCAL void NEAR SwPause(void);
|
|
LOCAL void NEAR SwPmType(void);
|
|
LOCAL void NEAR SwQuicklib(void);
|
|
LOCAL void NEAR SwSegments(void);
|
|
LOCAL void NEAR SwStack(void);
|
|
LOCAL void NEAR SwSymdeb(void);
|
|
LOCAL void NEAR SwWarnFixup(void);
|
|
#if DOSEXTENDER
|
|
LOCAL void NEAR SwRunReal(void);
|
|
#endif
|
|
#if QCLINK
|
|
LOCAL void NEAR SwZ1(void);
|
|
#endif
|
|
#if QCLINK OR Z2_ON
|
|
LOCAL void NEAR SwZ2 (void);
|
|
#endif
|
|
#if QCLINK
|
|
LOCAL void NEAR SwZincr(void);
|
|
#endif
|
|
LOCAL int NEAR ParseNo(unsigned long *pResult);
|
|
LOCAL int NEAR ParseStr(char *pResult);
|
|
LOCAL void NEAR BadFlag(unsigned char *psb, MSGTYPE errnum);
|
|
LOCAL int NEAR FPrefix(unsigned char *psb1,unsigned char *psb2);
|
|
|
|
|
|
|
|
|
|
/*
|
|
* ParseNo : Parse switch number
|
|
*
|
|
* Return value:
|
|
* 1 result stored in pointer
|
|
* 0 no switch given
|
|
* -1 error
|
|
*/
|
|
LOCAL int NEAR ParseNo(pResult)
|
|
unsigned long *pResult;
|
|
{
|
|
REGISTER char *s; /* String pointer */
|
|
REGISTER WORD ch; /* A character */
|
|
WORD strlen; /* String length */
|
|
WORD base = 10; /* Base to read constant in */
|
|
DWORD oldval;
|
|
|
|
oldval = *pResult = 0L; /* Initialize */
|
|
strlen = IFind(osbSwitch,':'); /* Look for a colon in the string */
|
|
if(strlen != INIL && strlen < (WORD) (B2W(osbSwitch[0]) - 1))
|
|
{ /* If switch form valid */
|
|
s = &osbSwitch[strlen + 2];
|
|
/* Set pointer past colon */
|
|
strlen = B2W(osbSwitch[0]) - strlen - 1;
|
|
/* Get length of string left */
|
|
if(*s == '0') /* If string starts with 0 */
|
|
{
|
|
if(strlen > 1 && ((WORD) s[1] & 0137) == 'X')
|
|
{ /* If string starts with "0x" */
|
|
base = 16; /* Change base to hexadecimal */
|
|
++s; /* Skip over "0" */
|
|
--strlen; /* Decrement length */
|
|
}
|
|
else base = 8; /* Else change to octal */
|
|
++s; /* Skip "0" (or "x") */
|
|
--strlen; /* Decrement length */
|
|
}
|
|
while(strlen--) /* While not at end of string */
|
|
{
|
|
ch = B2W(*s++); /* Get character */
|
|
if(ch >= '0' && ch <= '9') ch -= (WORD) '0';
|
|
/* Remove offset */
|
|
else if(ch >= 'A' && ch < 'A' + base - 10) ch -= (WORD) 'A' - 10;
|
|
/* Remove offset */
|
|
else if(ch >= 'a' && ch < 'a' + base - 10) ch -= (WORD) 'a' - 10;
|
|
/* Remove offset */
|
|
else /* Invalid character */
|
|
{
|
|
SwitchErr = ER_swbadnum;
|
|
return(-1); /* Error */
|
|
}
|
|
if((*pResult *= base) < oldval)
|
|
{
|
|
SwitchErr = ER_swbadnum;
|
|
return(-1); /* Error */
|
|
}
|
|
*pResult += ch;
|
|
oldval = *pResult;
|
|
}
|
|
return(1); /* Number is present */
|
|
}
|
|
else return(0); /* No number present */
|
|
}
|
|
|
|
/*
|
|
* ParseStr : Parse switch string
|
|
*
|
|
* Return value:
|
|
* 1 result stored in string
|
|
* 0 no switch string given
|
|
*/
|
|
|
|
LOCAL int NEAR ParseStr(pResult)
|
|
char *pResult; /* Length prefixed result */
|
|
{
|
|
REGISTER char *s; /* String pointer */
|
|
WORD strlen; /* String length */
|
|
|
|
*pResult = '\0'; /* Initialize */
|
|
strlen = IFind(osbSwitch,':'); /* Look for a colon in the string */
|
|
if(strlen != INIL && strlen < (WORD) (B2W(osbSwitch[0]) - 1))
|
|
{ /* If switch form valid */
|
|
s = &osbSwitch[strlen + 2];
|
|
/* Set pointer past colon */
|
|
strlen = B2W(osbSwitch[0]) - strlen - 1;
|
|
/* Get length of string left */
|
|
*pResult++ = (char) strlen; /* Store length */
|
|
|
|
while(strlen--) /* While not at end of string */
|
|
{
|
|
*pResult++ = (char) (*s++); /* Get character */
|
|
}
|
|
return(1); /* String is present */
|
|
}
|
|
else return(0); /* No stringr present */
|
|
}
|
|
|
|
|
|
#if PCODE
|
|
LOCAL void NEAR SwPCode(void)
|
|
{
|
|
|
|
SBTYPE SwString;
|
|
|
|
fNewExe = (FTYPE) TRUE;
|
|
fMPC = (FTYPE) TRUE;
|
|
|
|
if (ParseStr(SwString))
|
|
{
|
|
if(SwString[1] == 'n' || SwString[1] == 'N') // /PCODE:NOMPC
|
|
{
|
|
fIgnoreMpcRun = (FTYPE) TRUE;
|
|
fMPC = (FTYPE) FALSE;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
/***************************************************************/
|
|
/* Options common to all versions regardless of output format */
|
|
|
|
LOCAL void NEAR SwCase()
|
|
{
|
|
fIgnoreCase = (FTYPE) ~IGNORECASE; /* Toggle default case sensitivity */
|
|
}
|
|
|
|
LOCAL void NEAR SwLineNos() /* Line numbers requested */
|
|
{
|
|
vfLineNos = (FTYPE) TRUE; /* Set flag */
|
|
}
|
|
|
|
#if LOCALSYMS
|
|
LOCAL void NEAR SwLocals() /* Local symbols requested */
|
|
{
|
|
fLocals = (FTYPE) TRUE; /* Set flag */
|
|
}
|
|
#endif
|
|
|
|
#pragma check_stack(on)
|
|
|
|
LOCAL void NEAR SwMap() /* Link map requested */
|
|
{
|
|
SBTYPE SwString;
|
|
int rc;
|
|
|
|
vfMap = (FTYPE) TRUE; // Set flag
|
|
if ((rc = ParseStr(SwString)) <= 0) // Done if no num or error
|
|
return;
|
|
|
|
// The optional parameter following /MAP was originally intended
|
|
// to tell the linker how much to space to allocate for sorting
|
|
// more public symbols than the stack-based limit. Since we now
|
|
// dyamically allocate as much space as possible for sorting,
|
|
// the parameter is no longer necessary and its value is ignored.
|
|
// However, the side effect of suppressing the "sorted by name"
|
|
// list is retained.
|
|
|
|
if (SwString[1] == 'A' || SwString[1] == 'a')
|
|
fListAddrOnly = (FTYPE) TRUE; // /MAP:ADDRESS
|
|
|
|
else if (SwString[1] == 'F' || SwString[1] == 'f')
|
|
fFullMap = (FTYPE) TRUE; // /MAP:FULL or /MAP:full
|
|
}
|
|
|
|
|
|
LOCAL void NEAR SwNoDefLib() /* Do not search default library */
|
|
{
|
|
SBTYPE SwString;
|
|
SBTYPE LibName;
|
|
|
|
|
|
if (ParseStr(SwString))
|
|
{
|
|
vfNoDefaultLibrarySearch = FALSE;
|
|
/* Clear flag - selective library search */
|
|
strcpy(LibName, sbDotLib);
|
|
UpdateFileParts(LibName, SwString);
|
|
EnterName(LibName,ATTRSKIPLIB,TRUE);
|
|
}
|
|
else vfNoDefaultLibrarySearch = (FTYPE) TRUE;
|
|
/* Set flag */
|
|
}
|
|
|
|
#pragma check_stack(off)
|
|
|
|
LOCAL void NEAR SwNologo()
|
|
{
|
|
// if fNoprompt is already set then either
|
|
// a) /BATCH was specified, in which case /NOLOGO is redundant
|
|
// b) BATCH was in _MSC_IDE_FLAGS in which case fNoEchoLrf has not been
|
|
// set, and we want to suppress echoing of the response file
|
|
// (see CAVIAR 2378 [rm])
|
|
|
|
if (fNoprompt)
|
|
fNoEchoLrf = TRUE; /* Do not echo response file */
|
|
|
|
fNoBanner = TRUE; /* Do not display banner */
|
|
}
|
|
|
|
LOCAL void NEAR SwBatch() /* Do not prompt for files */
|
|
{
|
|
fNoEchoLrf = (FTYPE) TRUE; /* Do not echo response file */
|
|
fNoprompt = (FTYPE) TRUE; /* Do not prompt */
|
|
fPauseRun = FALSE; /* Disable /PAUSE */
|
|
fNoBanner = (FTYPE) TRUE; /* Do not display banner */
|
|
}
|
|
|
|
#if ODOS3EXE
|
|
LOCAL void NEAR SwBinary() /* Produce .COM file */
|
|
{
|
|
fBinary = (FTYPE) TRUE;
|
|
SwNonulls(); /* No nulls */
|
|
fFarCallTrans = (FTYPE) TRUE; /* Far call translation */
|
|
packLim = LXIVK - 36; /* Default limit is 64K - 36 */
|
|
fPackSet = (FTYPE) TRUE; /* Remember packLim was set */
|
|
}
|
|
#endif
|
|
|
|
#if SYMDEB
|
|
LOCAL void NEAR SwSymdeb() /* Symbolic debugging */
|
|
{
|
|
SBTYPE SwString;
|
|
|
|
|
|
fSymdeb = (FTYPE) TRUE;
|
|
if (ParseStr(SwString))
|
|
{
|
|
fCVpack = (FTYPE) (SwString[1] == 'c' || SwString[1] == 'C');
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if PERFORMANCE
|
|
LOCAL void NEAR SwVMPerf() /* Report on VM performance */
|
|
{
|
|
fPerformance = (FTYPE) TRUE; /* Set flag */
|
|
}
|
|
#endif
|
|
|
|
#if OSMSDOS
|
|
LOCAL void NEAR SwPause() /* Pause before writing executable */
|
|
{
|
|
fPauseRun = (FTYPE) TRUE; /* Set flag */
|
|
fNoprompt = FALSE; /* Disable /NOPROMPT */
|
|
}
|
|
#endif
|
|
|
|
LOCAL void NEAR SwStack() /* Set stack segment size */
|
|
{
|
|
unsigned long num;
|
|
int rc;
|
|
|
|
if((rc = ParseNo(&num)) < 0) /* Quit if error */
|
|
return;
|
|
#if EXE386
|
|
if(!rc || num > CBMAXSEG32 - 4L)
|
|
#else
|
|
if(!rc || num > LXIVK - 2L)
|
|
#endif
|
|
SwitchErr = ER_swstack;
|
|
else
|
|
#if EXE386
|
|
cbStack = num;
|
|
#else
|
|
cbStack = (WORD) num;
|
|
#endif
|
|
}
|
|
|
|
LOCAL void NEAR SwSegments() /* Set maximum number of segments */
|
|
{
|
|
unsigned long nsegs; /* Number of segments */
|
|
int rc;
|
|
|
|
if((rc = ParseNo(&nsegs)) <= 0) /* Quit if error or no argument */
|
|
return;
|
|
if(nsegs > (long) GSNMAX)
|
|
SwitchErr = ER_swseglim;
|
|
else
|
|
{
|
|
if ((nsegs + 3L) > GSNMAX)
|
|
gsnMax = GSNMAX;
|
|
else
|
|
gsnMax = (SNTYPE) nsegs; /* Else set limit */
|
|
}
|
|
}
|
|
|
|
#if EXE386
|
|
LOCAL void NEAR SwMemAlign(void)/* Set memory object alignment factor */
|
|
{
|
|
long align; /* Alignment size in bytes */
|
|
int rc;
|
|
|
|
if ((rc = ParseNo(&align)) < 0) /* Quit if error */
|
|
return;
|
|
if (rc && align >= 1)
|
|
{ /* If value in legal range */
|
|
for (objAlign = 32; objAlign != 0; --objAlign)
|
|
{ /* Loop to find log of align */
|
|
if ((1L << objAlign) & align)
|
|
break; /* Break when high bit found */
|
|
}
|
|
if ((1L << objAlign) == align)
|
|
return; /* Align must be power of two */
|
|
}
|
|
OutWarn(ER_alnbad); /* Output warning message */
|
|
objAlign = DFOBJALIGN; /* Use default value */
|
|
}
|
|
#endif
|
|
|
|
#if NOT EXE386
|
|
LOCAL void NEAR SwNewFiles(void)
|
|
{
|
|
vFlagsOthers |= NENEWFILES; /* Set flag */
|
|
}
|
|
#endif
|
|
|
|
#if FDEBUG
|
|
LOCAL void NEAR SwInfo() /* Turn on runtime debugging */
|
|
{
|
|
fDebug = (FTYPE) TRUE; /* Set flag */
|
|
}
|
|
#endif
|
|
|
|
#if LIBMSDOS
|
|
LOCAL void NEAR SwNoExtDic() /* Don't search extended dictionary */
|
|
{
|
|
fNoExtDic = (FTYPE) TRUE;
|
|
}
|
|
#endif
|
|
|
|
/***************************************************************/
|
|
/* Options for segmented executable format. */
|
|
|
|
#if OSEGEXE
|
|
LOCAL void NEAR SwAlign() /* Set segment alignment factor */
|
|
{
|
|
long align; /* Alignment size in byutes */
|
|
int rc;
|
|
|
|
if((rc = ParseNo(&align)) < 0) /* Quit if error */
|
|
return;
|
|
if(rc && align >= 1 && align <= 32768L)
|
|
{ /* If value in legal range */
|
|
for(fileAlign = 16; fileAlign != 0; --fileAlign)
|
|
{ /* Loop to find log of align */
|
|
if((1L << fileAlign) & align) break;
|
|
/* Break when high bit found */
|
|
}
|
|
if((1L << fileAlign) == align) return;
|
|
/* Align must be power of two */
|
|
}
|
|
OutWarn(ER_alnbad); /* Output warning message */
|
|
fileAlign = DFSAALIGN; /* Use default value */
|
|
}
|
|
#pragma check_stack(on)
|
|
#if OUT_EXP
|
|
LOCAL void NEAR SwIdef(void) /* Dump exports to a text file */
|
|
{
|
|
SBTYPE SwString;
|
|
int rc;
|
|
|
|
if ((rc = ParseStr(SwString)) <= 0) // Done if no string or error
|
|
{
|
|
bufExportsFileName[0] = '.'; // Use the default file name
|
|
return;
|
|
}
|
|
strcpy(bufExportsFileName, SwString);
|
|
}
|
|
#endif
|
|
#if NOT EXE386
|
|
LOCAL void NEAR SwPmType() /* /PMTYPE:<type> */
|
|
{
|
|
SBTYPE SwString;
|
|
|
|
|
|
if (ParseStr(SwString))
|
|
{
|
|
if (FPrefix("\002PM", SwString))
|
|
vFlags |= NEWINAPI;
|
|
else if (FPrefix("\003VIO", SwString))
|
|
vFlags |= NEWINCOMPAT;
|
|
else if (FPrefix("\005NOVIO", SwString))
|
|
vFlags |= NENOTWINCOMPAT;
|
|
else
|
|
OutWarn(ER_badpmtype, &osbSwitch[1]);
|
|
}
|
|
else
|
|
OutWarn(ER_badpmtype, &osbSwitch[1]);
|
|
}
|
|
#endif
|
|
|
|
#pragma check_stack(off)
|
|
|
|
LOCAL void NEAR SwWarnFixup()
|
|
{
|
|
fWarnFixup = (FTYPE) TRUE;
|
|
}
|
|
|
|
#if O68K
|
|
LOCAL void NEAR SwMac() /* Target is a Macintosh */
|
|
{
|
|
SBTYPE SwString;
|
|
|
|
f68k = fTBigEndian = fNewExe = (FTYPE) TRUE;
|
|
iMacType = (BYTE) (ParseStr(SwString) && FPrefix("\011SWAPPABLE", SwString)
|
|
? MAC_SWAP : MAC_NOSWAP);
|
|
|
|
/* If we are packing code to the default value, change the default. */
|
|
if (fPackSet && packLim == LXIVK - 36)
|
|
packLim = LXIVK / 2;
|
|
}
|
|
#endif /* O68K */
|
|
#endif /* OSEGEXE */
|
|
|
|
/***************************************************************/
|
|
/* Options shared by DOS3 and segmented exe formats. */
|
|
|
|
#if OEXE
|
|
/*
|
|
* HACK ALERT !!!!!!!!!!!!!!!
|
|
* Function SetDosseg is used to hide local call to SwDosseg().
|
|
* This function is called from ComRc1 (in NEWTP1.C).
|
|
*
|
|
*/
|
|
void SetDosseg(void)
|
|
{
|
|
SwDosseg();
|
|
}
|
|
|
|
|
|
LOCAL void NEAR SwDosseg() /* DOS Segment ordering switch given */
|
|
{
|
|
static FTYPE FirstTimeCalled = (FTYPE) TRUE; /* If true create symbols _edata */
|
|
/* and _end */
|
|
|
|
fSegOrder = (FTYPE) TRUE; /* Set switch */
|
|
if (FirstTimeCalled && vfPass1)
|
|
{
|
|
MkPubSym((BYTE *) "\006_edata",0,0,(RATYPE)0);
|
|
MkPubSym((BYTE *) "\007__edata",0,0,(RATYPE)0);
|
|
MkPubSym((BYTE *) "\004_end",0,0,(RATYPE)0);
|
|
MkPubSym((BYTE *) "\005__end",0,0,(RATYPE)0);
|
|
FirstTimeCalled = FALSE;
|
|
#if ODOS3EXE
|
|
if (cparMaxAlloc == 0)
|
|
cparMaxAlloc = 0xFFFF; /* Turn off /HIGH */
|
|
vfDSAlloc = FALSE; /* Turn off DS Allocation */
|
|
#endif
|
|
}
|
|
}
|
|
|
|
#if ODOS3EXE
|
|
LOCAL void NEAR SwDosExtend(void)
|
|
{
|
|
long mode; // Extender mode
|
|
int rc;
|
|
|
|
if ((rc = ParseNo(&mode)) < 0) // Quit if error
|
|
return;
|
|
|
|
if (rc)
|
|
dosExtMode = (WORD) mode;
|
|
fDOSExtended = (FTYPE) TRUE;
|
|
}
|
|
#endif
|
|
|
|
#if TIMINGS
|
|
LOCAL void NEAR SwShowTiming(void)
|
|
{
|
|
extern int fShowTiming;
|
|
|
|
fShowTiming = TRUE;
|
|
}
|
|
#endif // TIMINGS
|
|
#if USE_REAL
|
|
LOCAL void NEAR SwNoUseReal(void)
|
|
{
|
|
fSwNoUseReal = TRUE;
|
|
}
|
|
#endif
|
|
#if FEXEPACK
|
|
LOCAL void NEAR SwExePack() /* Set exepack switch */
|
|
{
|
|
#if QBLIB
|
|
/* If /QUICKLIB given, issue fatal error. */
|
|
if(fQlib)
|
|
Fatal(ER_swqe);
|
|
#endif
|
|
#if ODOS3EXE
|
|
if (cparMaxAlloc == 0)
|
|
OutWarn(ER_loadhi);
|
|
else
|
|
#endif
|
|
fExePack = (FTYPE) TRUE;
|
|
}
|
|
#endif
|
|
|
|
|
|
LOCAL void NEAR SwNonulls ()
|
|
{
|
|
extern FTYPE fNoNulls;
|
|
|
|
/*
|
|
* /NONULLSDOSSEG: just like /DOSSEG except do not insert
|
|
* 16 null bytes in _TEXT.
|
|
*/
|
|
SwDosseg();
|
|
fNoNulls = (FTYPE) TRUE;
|
|
}
|
|
|
|
|
|
LOCAL void NEAR SwNoFarCall() /* Disable far call optimization */
|
|
{
|
|
fFarCallTrans = FALSE;
|
|
}
|
|
|
|
void NEAR SwNoPack() /* Disable code packing */
|
|
{
|
|
fPackSet = (FTYPE) TRUE; /* Remember packLim was set */
|
|
packLim = 0L;
|
|
}
|
|
|
|
LOCAL void NEAR SwPack() /* Pack code segments */
|
|
{
|
|
int rc;
|
|
|
|
fPackSet = (FTYPE) TRUE; /* Remember packLim was set */
|
|
if((rc = ParseNo(&packLim)) < 0) /* Quit if error */
|
|
return;
|
|
if(!rc)
|
|
#if EXE386
|
|
packLim = CBMAXSEG32; /* Default limit is 4Gb */
|
|
#else
|
|
#if O68K
|
|
packLim = iMacType != MAC_NONE ? LXIVK / 2 : LXIVK - 36;
|
|
/* Default limit is 32K or 64K - 36 */
|
|
#else
|
|
packLim = LXIVK - 36; /* Default limit is 64K - 36 */
|
|
#endif
|
|
else if(packLim > LXIVK) /* If limit set too high */
|
|
SwitchErr = ER_swpack;
|
|
else if(packLim > LXIVK - 36)
|
|
OutWarn(ER_pckval);
|
|
#endif
|
|
}
|
|
|
|
LOCAL void NEAR SwPackData() /* Pack data segments */
|
|
{
|
|
int rc;
|
|
|
|
fPackData = (FTYPE) TRUE;
|
|
if((rc = ParseNo(&DataPackLim)) < 0)/* Quit if error */
|
|
return;
|
|
if(!rc)
|
|
#if EXE386
|
|
DataPackLim = CBMAXSEG32; /* Default limit is 4Gb */
|
|
#else
|
|
DataPackLim = LXIVK; /* Default limit is 64K */
|
|
else if(DataPackLim > LXIVK) /* If limit set too high */
|
|
SwitchErr = ER_swpack;
|
|
#endif
|
|
}
|
|
|
|
LOCAL void NEAR SwNoPackFunctions()// DO NOT eliminate uncalled COMDATs
|
|
{
|
|
fPackFunctions = (FTYPE) FALSE;
|
|
}
|
|
|
|
LOCAL void NEAR SwPackFunctions()// DO eliminate uncalled COMDATs
|
|
{
|
|
#if TCE
|
|
SBTYPE SwString;
|
|
int rc;
|
|
#endif
|
|
fPackFunctions = (FTYPE) TRUE;
|
|
#if TCE
|
|
if ((rc = ParseStr(SwString)) <= 0) // Done if no num or error
|
|
return;
|
|
if (SwString[1] == 'M' || SwString[1] == 'm')
|
|
{
|
|
fTCE = (FTYPE) TRUE; // /PACKF:MAX = perform TCE
|
|
fprintf(stdout, "\r\nTCE is active. ");
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
LOCAL void NEAR SwFarCall() /* Enable far call optimization */
|
|
{
|
|
fFarCallTrans = (FTYPE) TRUE;
|
|
}
|
|
#endif /* OEXE */
|
|
|
|
#if DOSEXTENDER
|
|
LOCAL void NEAR SwRunReal(void)
|
|
{
|
|
OutWarn(ER_rnotfirst);
|
|
}
|
|
#endif
|
|
|
|
/***************************************************************/
|
|
/* Options for DOS3 exe format. */
|
|
|
|
#if ODOS3EXE
|
|
LOCAL void NEAR SwDSAlloc() /* DS allocation requested */
|
|
{
|
|
if(!fSegOrder) vfDSAlloc = (FTYPE) TRUE; /* Set flag if not overridden */
|
|
}
|
|
|
|
#if OVERLAYS
|
|
LOCAL void NEAR SwDynamic(void)
|
|
{
|
|
unsigned long cThunks;
|
|
int rc;
|
|
|
|
if ((rc = ParseNo(&cThunks)) < 0)
|
|
return; /* Bad argument */
|
|
fDynamic = (FTYPE) TRUE;
|
|
fFarCallTrans = (FTYPE) TRUE;
|
|
fPackSet = (FTYPE) TRUE;
|
|
packLim = LXIVK - 36; /* Default limit is 64K - 36 */
|
|
if (!rc)
|
|
cThunks = 256;
|
|
else if (cThunks > LXIVK / OVLTHUNKSIZE)
|
|
{
|
|
char buf[17];
|
|
cThunks = LXIVK / OVLTHUNKSIZE;
|
|
OutWarn(ER_arginvalid, "DYNAMIC", _itoa((WORD)cThunks, buf, 10));
|
|
|
|
}
|
|
|
|
|
|
ovlThunkMax = (WORD) cThunks;
|
|
}
|
|
|
|
LOCAL void NEAR SwOldOvl(void)
|
|
{
|
|
fOldOverlay = (FTYPE) TRUE;
|
|
fDynamic = (FTYPE) FALSE;
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
LOCAL void NEAR SwHigh() /* Load high */
|
|
{
|
|
if(!fSegOrder)
|
|
{
|
|
#if FEXEPACK
|
|
if (fExePack == (FTYPE) TRUE)
|
|
{
|
|
OutWarn(ER_loadhi);
|
|
fExePack = FALSE;
|
|
}
|
|
#endif
|
|
cparMaxAlloc = 0; /* Dirty trick! */
|
|
}
|
|
}
|
|
|
|
#if OVERLAYS
|
|
LOCAL void NEAR SwIntNo()
|
|
{
|
|
unsigned long intno;
|
|
int rc;
|
|
|
|
if((rc = ParseNo(&intno)) < 0) /* Quit if error */
|
|
return;
|
|
if(rc == 0 || intno > 255) /* If no number or num exceeds 255 */
|
|
SwitchErr = ER_swovl;
|
|
else vintno = (BYTE) intno; /* Else store interrupt number */
|
|
}
|
|
#endif
|
|
|
|
LOCAL void NEAR SwCParMax()
|
|
{
|
|
unsigned long cparmax;
|
|
int rc;
|
|
|
|
if((rc = ParseNo(&cparmax)) < 0) /* Quit if error */
|
|
return;
|
|
if(rc == 0 || cparmax > 0xffffL) /* If no number or num exceeds ffff */
|
|
SwitchErr = ER_swcpar;
|
|
else cparMaxAlloc = (WORD) cparmax; /* Else store cparMaxAlloc */
|
|
}
|
|
|
|
LOCAL void NEAR SwNoGrp()
|
|
{
|
|
fNoGrpAssoc = (FTYPE) TRUE; /* Don't associate publics w/ groups */
|
|
}
|
|
#endif /* ODOS3EXE */
|
|
|
|
/***************************************************************/
|
|
/* Options for ILINK-version */
|
|
|
|
#if ILINK
|
|
LOCAL void NEAR SwIncremental() /* Incremental linking support */
|
|
{
|
|
//fIncremental = (FTYPE) !fZincr;
|
|
fIncremental = (FTYPE) FALSE; //INCR support dropped in 5.30.30
|
|
}
|
|
#endif
|
|
|
|
LOCAL void NEAR SwPadCode() /* Code padding */
|
|
{
|
|
long num;
|
|
int rc;
|
|
|
|
if((rc = ParseNo(&num)) < 0)
|
|
return;
|
|
/* PADCODE:xxx option specifies code padding size */
|
|
if(rc)
|
|
{
|
|
if(num < 0 || num > 0x8000)
|
|
SwitchErr = ER_swbadnum;
|
|
else cbPadCode = (WORD) num;
|
|
}
|
|
}
|
|
|
|
LOCAL void NEAR SwPadData() /* Data padding */
|
|
{
|
|
long num;
|
|
int rc;
|
|
|
|
if((rc = ParseNo(&num)) < 0)
|
|
return;
|
|
/* PADDATA:xxx option specifies data padding size */
|
|
if(rc)
|
|
{
|
|
if(num < 0 || num > 0x8000)
|
|
SwitchErr = ER_swbadnum;
|
|
else cbPadData = (WORD) num;
|
|
}
|
|
}
|
|
|
|
/***************************************************************/
|
|
/* Switches for segmented x.out format */
|
|
|
|
#if OIAPX286
|
|
LOCAL void NEAR SwAbsolute ()
|
|
{
|
|
if(!cbStack)
|
|
ParseNo(&absAddr);
|
|
}
|
|
|
|
LOCAL void NEAR SwNoPack() /* Disable code packing */
|
|
{
|
|
fPack = FALSE;
|
|
}
|
|
|
|
LOCAL void NEAR SwTextbias ()
|
|
{
|
|
long num;
|
|
|
|
if(ParseNo(&num) > 0)
|
|
stBias = num;
|
|
}
|
|
|
|
LOCAL void NEAR SwDatabias ()
|
|
{
|
|
long num;
|
|
|
|
if(ParseNo(&num) > 0)
|
|
stDataBias = num;
|
|
}
|
|
|
|
LOCAL void NEAR SwPagesize ()
|
|
{
|
|
long num;
|
|
|
|
if(ParseNo(&num) > 0)
|
|
cblkPage = num >> 9;
|
|
}
|
|
|
|
LOCAL void NEAR SwTextrbase ()
|
|
{
|
|
long num;
|
|
|
|
if(ParseNo(&num) > 0)
|
|
rbaseText = num;
|
|
}
|
|
|
|
LOCAL void NEAR SwDatarbase ()
|
|
{
|
|
long num;
|
|
|
|
if(ParseNo(&num) > 0)
|
|
rbaseData = num;
|
|
}
|
|
|
|
LOCAL void NEAR SwVmod ()
|
|
{
|
|
long num;
|
|
|
|
if(ParseNo(&num) <= 0)
|
|
return;
|
|
switch(num)
|
|
{
|
|
case 0:
|
|
xevmod = XE_VMOD;
|
|
break;
|
|
case 1:
|
|
xevmod = XE_EXEC | XE_VMOD;
|
|
break;
|
|
default:
|
|
SwitchErr = ER_swbadnum;
|
|
}
|
|
}
|
|
#endif /* OIAPX286 */
|
|
#if OXOUT OR OIAPX286
|
|
LOCAL void NEAR SwNosymbols ()
|
|
{
|
|
fSymbol = FALSE;
|
|
}
|
|
|
|
LOCAL void NEAR SwMixed ()
|
|
{
|
|
fMixed = (FTYPE) TRUE;
|
|
}
|
|
|
|
LOCAL void NEAR SwLarge ()
|
|
{
|
|
fLarge = (FTYPE) TRUE;
|
|
SwMedium();
|
|
}
|
|
|
|
LOCAL void NEAR SwMedium()
|
|
{
|
|
fMedium = (FTYPE) TRUE; /* Medium model */
|
|
fIandD = (FTYPE) TRUE; /* Separate code and data */
|
|
}
|
|
|
|
LOCAL void NEAR SwPure()
|
|
{
|
|
fIandD = (FTYPE) TRUE; /* Separate code and data */
|
|
}
|
|
#endif /* OXOUT OR OIAPX286 */
|
|
|
|
/* Options for linker profiling */
|
|
#if LNKPROF
|
|
char fP1stop = FALSE; /* Stop after pass 1 */
|
|
LOCAL void NEAR SwPass1()
|
|
{
|
|
fP1stop = (FTYPE) TRUE;
|
|
}
|
|
#endif /* LNKPROF */
|
|
|
|
/* Special options */
|
|
#if QBLIB
|
|
LOCAL void NEAR SwQuicklib() /* Create a QB userlibrary */
|
|
{
|
|
#if FEXEPACK
|
|
/* If /EXEPACK given, issue fatal error. */
|
|
if(fExePack)
|
|
Fatal(ER_swqe);
|
|
#endif
|
|
fQlib = (FTYPE) TRUE;
|
|
SwDosseg(); /* /QUICKLIB forces /DOSSEG */
|
|
fNoExtDic = (FTYPE) TRUE; /* /QUICKLIB forces /NOEXTDICTIONARY */
|
|
}
|
|
#endif
|
|
|
|
#if (QCLINK) AND NOT EXE386
|
|
typedef int (cdecl far * FARFPTYPE)(int, ...);/* Far function pointer type */
|
|
extern FARFPTYPE far *pfQTab; /* Table of addresses */
|
|
|
|
#pragma check_stack(on)
|
|
|
|
/*
|
|
* PromptQC : output a prompt to the QC prompt routine
|
|
*
|
|
* Call pfQTab[1] with parameters described below.
|
|
* Returns:
|
|
* always TRUE
|
|
*
|
|
* QCPrompt : display a message with a prompt
|
|
*
|
|
* void far QCPrompt (type, msg1, msg2, msg3, pResponse)
|
|
* short type; /* type of message, as follows:
|
|
* 0 = undefined
|
|
* 1 = edit field required (e.g. file name)
|
|
* 2 = wait for some action
|
|
* all other values undefined
|
|
* Any of the following fields may be NULL:
|
|
* char far *msg1; /* 1st message (error)
|
|
* char far *msg2; /* 2nd message (file name)
|
|
* char far *msg3; /* 3rd message (prompt text)
|
|
* char far *pResponse; /* Pointer to buffer in which to
|
|
* * store response.
|
|
*/
|
|
int cdecl PromptQC (sbNew,msg,msgparm,pmt,pmtparm)
|
|
BYTE *sbNew; /* Buffer for response */
|
|
MSGTYPE msg; /* Error message */
|
|
int msgparm; /* Message parameter */
|
|
MSGTYPE pmt; /* Prompt */
|
|
int pmtparm; /* Prompt parameter */
|
|
{
|
|
int type;
|
|
SBTYPE message;
|
|
SBTYPE prompt;
|
|
|
|
if(sbNew != NULL)
|
|
type = 1;
|
|
else
|
|
type = 2;
|
|
sprintf(message,GetMsg(msg),msgparm);
|
|
sprintf(prompt,GetMsg(pmt),pmtparm);
|
|
/* Return value of 1 means interrupt. */
|
|
if((*pfQTab[1])(type,(char far *) message,0L,(char far *)prompt,
|
|
(char far *) sbNew) == 1)
|
|
UserKill();
|
|
return(TRUE);
|
|
}
|
|
|
|
#pragma check_stack(off)
|
|
|
|
/*
|
|
* CputcQC : console character output routine for QC
|
|
*/
|
|
void CputcQC (ch)
|
|
int ch;
|
|
{
|
|
}
|
|
|
|
/*
|
|
* CputsQC : console string output routine for QC
|
|
*/
|
|
void CputsQC (str)
|
|
char *str;
|
|
{
|
|
}
|
|
|
|
|
|
/*
|
|
* SwZ1 : process /Z1:address
|
|
*
|
|
* /Z1 is a special undocumented switch for QC. It contains
|
|
* the address of a table of routines to use for console I/O.
|
|
*/
|
|
|
|
LOCAL void NEAR SwZ1 (void) /* Get address for message I/O */
|
|
{
|
|
long num;
|
|
extern FARFPTYPE far
|
|
*pfQTab; /* Table of addresses */
|
|
|
|
if(ParseNo(&num) <= 0)
|
|
return;
|
|
pfQTab = (FARFPTYPE far *) num;
|
|
pfPrompt = PromptQC;
|
|
fNoprompt = FALSE; /* Disable /NOPROMPT */
|
|
fNoBanner = (FTYPE) TRUE;
|
|
pfCputc = CputcQC;
|
|
pfCputs = CputsQC;
|
|
fZ1 = (FTYPE) TRUE;
|
|
}
|
|
/*
|
|
* /Zincr is a special undocumented switch for QC. It is required
|
|
* for "ILINK-breaking" errors. If ILINK encounters one of these errors,
|
|
* it ivokes the linker w /ZINCR which override /INCR.
|
|
*/
|
|
|
|
LOCAL void NEAR SwZincr(void)
|
|
{
|
|
fZincr = (FTYPE) TRUE;
|
|
}
|
|
#endif
|
|
|
|
#if Z2_ON OR (QCLINK AND NOT EXE386)
|
|
/*
|
|
* SwZ2 : process /Z2
|
|
*
|
|
* /Z2 is another special undocumented switch for QC.
|
|
* It causes deletion of responce file passed to the linker.
|
|
*/
|
|
|
|
LOCAL void NEAR SwZ2 (void)
|
|
{
|
|
fZ2 = (FTYPE) TRUE;
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
/* Structure for table of linker options */
|
|
struct option
|
|
{
|
|
char *sbSwitch; /* length-prefixed switch string */
|
|
#ifdef M68000
|
|
int (*proc)(); /* pointer to switch function */
|
|
#else
|
|
void (NEAR *proc)(); /* pointer to switch function */
|
|
#endif
|
|
};
|
|
|
|
|
|
/* Table of linker options */
|
|
LOCAL struct option switchTab[] =
|
|
{
|
|
#if NOT WIN_3
|
|
{ "\01?", SwShortHelp },
|
|
#endif
|
|
#if OIAPX286
|
|
{ "\017ABSOLUTEADDRESS", SwAbsolute },
|
|
#endif
|
|
#if OSEGEXE AND NOT QCLINK
|
|
{ "\011ALIGNMENT", SwAlign },
|
|
#endif
|
|
{ "\005BATCH", SwBatch },
|
|
#if LNKPROF
|
|
{ "\007BUFSIZE", SwBufsize },
|
|
#endif
|
|
#if SYMDEB
|
|
{ "\010CODEVIEW", SwSymdeb },
|
|
#endif
|
|
#if ODOS3EXE
|
|
{ "\014CPARMAXALLOC", SwCParMax },
|
|
#endif
|
|
#if OIAPX286
|
|
{ "\010DATABIAS", SwDatabias },
|
|
{ "\011DATARBASE", SwDatarbase },
|
|
#endif
|
|
|
|
#if ODOS3EXE
|
|
{ "\013DOSEXTENDER", SwDosExtend },
|
|
#endif
|
|
#if OEXE
|
|
{ "\006DOSSEG", SwDosseg },
|
|
#endif
|
|
#if ODOS3EXE
|
|
{ "\012DSALLOCATE", SwDSAlloc },
|
|
#if OVERLAYS
|
|
{ "\007DYNAMIC", SwDynamic },
|
|
#endif
|
|
#endif
|
|
#if FEXEPACK
|
|
{ "\007EXEPACK", SwExePack },
|
|
#endif
|
|
#if OEXE
|
|
{ "\022FARCALLTRANSLATION", SwFarCall },
|
|
#endif
|
|
#if EXE386
|
|
{ "\006HEADER", SwHeader },
|
|
#endif
|
|
#if NOT WIN_3
|
|
{ "\004HELP",
|
|
#if C8_IDE
|
|
SwShortHelp },
|
|
#else
|
|
SwHelp },
|
|
#endif
|
|
#endif
|
|
#if ODOS3EXE
|
|
{ "\004HIGH", SwHigh },
|
|
#endif
|
|
#if NOT IGNORECASE
|
|
{ "\012IGNORECASE", SwCase },
|
|
#endif
|
|
#if EXE386
|
|
{ "\016IMAGEALIGNMENT", SwMemAlign },
|
|
#endif
|
|
#if ILINK AND NOT IBM_LINK
|
|
{ "\013INCREMENTAL", SwIncremental },
|
|
#endif
|
|
#if FDEBUG
|
|
{ "\013INFORMATION", SwInfo },
|
|
#endif
|
|
#if OSEGEXE AND OUT_EXP
|
|
{ "\004IDEF", SwIdef },
|
|
#endif
|
|
#if (OSEGEXE AND defined(LEGO)) OR EXE386
|
|
{ "\012KEEPFIXUPS", SwKeepFixups },
|
|
#endif
|
|
#if EXE386
|
|
{ "\012KEEPVSIZE", SwKeepVSize },
|
|
#endif
|
|
#if OIAPX286
|
|
{ "\005LARGE", SwLarge },
|
|
#endif
|
|
{ "\013LINENUMBERS", SwLineNos },
|
|
#if LOCALSYMS
|
|
{ "\014LOCALSYMBOLS", SwLocals },
|
|
#endif
|
|
#if O68K
|
|
{ "\011MACINTOSH", SwMac },
|
|
#endif /* O68K */
|
|
{ "\003MAP", SwMap },
|
|
#if OXOUT OR OIAPX286
|
|
{ "\006MEDIUM", SwMedium },
|
|
{ "\005MIXED", SwMixed },
|
|
#endif
|
|
#if NOT EXE386
|
|
{ "\010KNOWEAS", SwNewFiles },
|
|
#endif
|
|
{ "\026NODEFAULTLIBRARYSEARCH",
|
|
SwNoDefLib },
|
|
#if LIBMSDOS
|
|
{ "\017NOEXTDICTIONARY", SwNoExtDic },
|
|
#endif
|
|
#if OEXE
|
|
{ "\024NOFARCALLTRANSLATION",
|
|
SwNoFarCall },
|
|
#endif
|
|
#if ODOS3EXE
|
|
{ "\022NOGROUPASSOCIATION", SwNoGrp },
|
|
#endif
|
|
#if IGNORECASE
|
|
{ "\014NOIGNORECASE", SwCase },
|
|
#endif
|
|
#if TIMINGS
|
|
{ "\002BT", SwShowTiming },
|
|
#endif // TIMINGS
|
|
{ "\006NOLOGO", SwNologo },
|
|
{ "\015NONULLSDOSSEG", SwNonulls },
|
|
{ "\012NOPACKCODE", SwNoPack },
|
|
{ "\017NOPACKFUNCTIONS", SwNoPackFunctions },
|
|
#if OXOUT OR OIAPX286
|
|
{ "\011NOSYMBOLS", SwNosymbols },
|
|
#endif
|
|
#if USE_REAL
|
|
{ "\011NOFREEMEM", SwNoUseReal },
|
|
#endif
|
|
#if OVERLAYS
|
|
{ "\012OLDOVERLAY", SwOldOvl },
|
|
#endif
|
|
{ "\007ONERROR", SwDelexe },
|
|
#if OVERLAYS
|
|
{ "\020OVERLAYINTERRUPT", SwIntNo },
|
|
#endif
|
|
{ "\010PACKCODE", SwPack },
|
|
{ "\010PACKDATA", SwPackData },
|
|
{ "\015PACKFUNCTIONS", SwPackFunctions },
|
|
#if ILINK AND NOT IBM_LINK
|
|
{ "\007PADCODE", SwPadCode },
|
|
{ "\007PADDATA", SwPadData },
|
|
#endif
|
|
#if OIAPX286
|
|
{ "\010PAGESIZE", SwPagesize },
|
|
#endif
|
|
#if OSMSDOS
|
|
{ "\005PAUSE", SwPause },
|
|
#endif
|
|
#if LNKPROF
|
|
{ "\005PASS1", SwPass1 },
|
|
#endif
|
|
#if PCODE
|
|
{ "\005PCODE", SwPCode },
|
|
#endif
|
|
#if OSEGEXE AND NOT (QCLINK OR EXE386)
|
|
{ "\006PMTYPE", SwPmType },
|
|
#endif
|
|
#if OXOUT OR OIAPX286
|
|
{ "\004PURE", SwPure },
|
|
#endif
|
|
#if QBLIB
|
|
{ "\014QUICKLIBRARY", SwQuicklib },
|
|
#endif
|
|
#if DOSEXTENDER AND NOT WIN_NT
|
|
{ "\001r", SwRunReal },
|
|
#endif
|
|
{ "\010SEGMENTS", SwSegments },
|
|
{ "\005STACK", SwStack },
|
|
#if OIAPX286
|
|
{ "010TEXTBIAS", SwTextbias },
|
|
{ "\011TEXTRBASE", SwTextrbase },
|
|
#endif
|
|
#if ODOS3EXE
|
|
{ "\004TINY", SwBinary },
|
|
#endif
|
|
#if PERFORMANCE
|
|
{ "\030VIRTUALMEMORYPERFORMANCE",
|
|
SwVMPerf },
|
|
#endif
|
|
#if OIAPX286
|
|
{ "\004VMOD", SwVmod },
|
|
#endif
|
|
#if OSEGEXE AND NOT QCLINK
|
|
{ "\011WARNFIXUP", SwWarnFixup },
|
|
#endif
|
|
#if OSEGEXE AND NOT EXE386 AND QCLINK
|
|
{ "\002Z1", SwZ1 },
|
|
#endif
|
|
#if Z2_ON OR QCLINK
|
|
{ "\002Z2", SwZ2 },
|
|
#endif
|
|
#if QCLINK
|
|
{ "\005ZINCR", SwZincr },
|
|
#endif
|
|
{ NULL, 0}
|
|
};
|
|
|
|
#if QCLINK
|
|
#define SWSTOP &switchTab[(sizeof(switchTab)/sizeof(struct option)) - 5]
|
|
#else
|
|
#if EXE386
|
|
#define SWSTOP &switchTab[(sizeof(switchTab)/sizeof(struct option)) - 2]
|
|
#else
|
|
#define SWSTOP &switchTab[(sizeof(switchTab)/sizeof(struct option)) - 2]
|
|
#endif
|
|
#endif
|
|
|
|
#define FIELDLENGTH 28
|
|
#if NOT WIN_3
|
|
LOCAL void NEAR SwShortHelp() /* Print valid switches */
|
|
{
|
|
struct option *pTab; /* Option table pointer */
|
|
int toggle = 1;
|
|
int n;
|
|
|
|
|
|
#if CMDMSDOS
|
|
/* Maybe display banner here, in case /NOLOGO seen first. */
|
|
|
|
DisplayBanner();
|
|
#endif
|
|
fputs(GetMsg(P_usage1),stdout);
|
|
fputs(GetMsg(P_usage2),stdout);
|
|
fputs(GetMsg(P_usage3),stdout);
|
|
fputs(GetMsg(P_switches),stdout);
|
|
NEWLINE(stdout);
|
|
for(pTab = switchTab; pTab < SWSTOP; ++pTab)
|
|
{
|
|
// Don't display undocumented swiches
|
|
|
|
if (pTab->proc == &SwNewFiles)
|
|
{
|
|
continue;
|
|
}
|
|
if (pTab->proc == &SwDosExtend)
|
|
{
|
|
continue;
|
|
}
|
|
#ifdef LEGO
|
|
#if OSEGEXE
|
|
if (pTab->proc == &SwKeepFixups)
|
|
continue;
|
|
#endif
|
|
#endif /* LEGO */
|
|
|
|
fputs(" /",stdout);
|
|
fwrite(&pTab->sbSwitch[1],1,B2W(pTab->sbSwitch[0]),stdout);
|
|
/* Output switches in two columns */
|
|
if(toggle ^= 1)
|
|
NEWLINE(stdout);
|
|
else for(n = FIELDLENGTH - B2W(pTab->sbSwitch[0]); n > 0; --n)
|
|
fputc(' ',stdout);
|
|
}
|
|
NEWLINE(stdout);
|
|
fflush(stdout);
|
|
#if USE_REAL
|
|
RealMemExit();
|
|
#endif
|
|
exit(0);
|
|
}
|
|
#endif
|
|
|
|
LOCAL void NEAR SwDelexe() // Supress .EXE generation if errors occur
|
|
{
|
|
SBTYPE SwString;
|
|
int rc;
|
|
|
|
vfMap = (FTYPE) TRUE; // Set flag
|
|
if ((rc = ParseStr(SwString)) == 0) // NOEXE not present
|
|
{
|
|
OutWarn(ER_opnoarg, "ONERROR");
|
|
return;
|
|
}
|
|
|
|
|
|
if (SwString[1] == 'N' || SwString[1] == 'n')
|
|
{
|
|
fDelexe = TRUE; // ONERROR:NOEXE
|
|
}
|
|
else
|
|
{ // ONERROR:????
|
|
OutWarn(ER_opnoarg, "ONERROR");
|
|
return;
|
|
}
|
|
}
|
|
|
|
#if (OSEGEXE AND defined(LEGO)) OR EXE386
|
|
|
|
LOCAL void NEAR SwKeepFixups(void)
|
|
{
|
|
fKeepFixups = (FTYPE) TRUE;
|
|
}
|
|
|
|
#endif
|
|
|
|
#if EXE386
|
|
|
|
LOCAL void NEAR SwHeader() // Set executable header size
|
|
{
|
|
int rc;
|
|
DWORD newSize;
|
|
|
|
if ((rc = ParseNo(&newSize)) < 0) // Quit if error
|
|
return;
|
|
if (rc)
|
|
hdrSize = ((newSize << 10) + 0xffffL) & ~0xffffL;
|
|
}
|
|
|
|
LOCAL void NEAR SwKeepVSize(void)
|
|
{
|
|
fKeepVSize = (FTYPE) TRUE;
|
|
}
|
|
|
|
#endif
|
|
|
|
#if NOT WIN_3
|
|
|
|
LOCAL void NEAR SwHelp() /* Print valid switches */
|
|
{
|
|
intptr_t exitCode;
|
|
char *pszPath;
|
|
char *pszQH;
|
|
char *pszHELPFILES;
|
|
char FAR *lpch;
|
|
char *pch;
|
|
int len;
|
|
|
|
|
|
// Try to use QuickHelp - this is tricky; We have stubbed the
|
|
// C run-time environment setup, so spawnlp has no way of
|
|
// searching the path. Here we first add the path to C run-time
|
|
// environemt table and then invoke spawnlp.
|
|
|
|
|
|
if (lpszPath)
|
|
{
|
|
// Recreate C run-time PATH variable
|
|
|
|
len = FSTRLEN(lpszPath);
|
|
if ((pszPath = calloc(len + 6, sizeof(char))) != NULL)
|
|
{
|
|
strcpy(pszPath, "PATH=");
|
|
for (lpch = lpszPath, pch = pszPath + 5; len > 0; len--)
|
|
*pch++ = *lpch++;
|
|
_putenv(pszPath);
|
|
}
|
|
}
|
|
if (lpszQH)
|
|
{
|
|
// Recreate C run-time QH variable
|
|
|
|
len = FSTRLEN(lpszQH);
|
|
if ((pszQH = calloc(len + 4, sizeof(char))) != NULL)
|
|
{
|
|
strcpy(pszQH, "QH=");
|
|
for (lpch = lpszQH, pch = pszQH + 3; len > 0; len--)
|
|
*pch++ = *lpch++;
|
|
_putenv(pszQH);
|
|
}
|
|
}
|
|
if (lpszHELPFILES)
|
|
{
|
|
// Recreate C run-time HELPFILES variable
|
|
|
|
len = FSTRLEN(lpszHELPFILES);
|
|
if ((pszHELPFILES = calloc(len + 12, sizeof(char))) != NULL)
|
|
{
|
|
strcpy(pszHELPFILES, "HELPFILES=");
|
|
for (lpch = lpszHELPFILES, pch = pszHELPFILES + 10; len > 0; len--)
|
|
*pch++ = *lpch++;
|
|
_putenv(pszHELPFILES);
|
|
}
|
|
}
|
|
#if USE_REAL
|
|
RealMemExit();
|
|
#endif
|
|
exitCode = _spawnlp(P_WAIT, "QH.EXE", "qh", "/u link.exe", NULL);
|
|
if (exitCode < 0 || exitCode == 3)
|
|
SwShortHelp();
|
|
exit(0);
|
|
}
|
|
#endif
|
|
|
|
/****************************************************************
|
|
* *
|
|
* BadFlag: *
|
|
* *
|
|
* This function takes as its argument a pointer to a length- *
|
|
* prefixed string containing an invalid switch. It goes *
|
|
* through the customary contortions of dying with grace. *
|
|
* *
|
|
****************************************************************/
|
|
|
|
LOCAL void NEAR BadFlag(psb,errnum)
|
|
BYTE *psb; /* Pointer to the bad switch */
|
|
MSGTYPE errnum; /* Error number */
|
|
{
|
|
psb[B2W(psb[0]) + 1] = '\0'; /* Null-terminate it */
|
|
Fatal(errnum,psb + 1);
|
|
}
|
|
|
|
/****************************************************************
|
|
* *
|
|
* FPrefix: *
|
|
* *
|
|
* This function takes as its arguments two pointers to *
|
|
* length-prefixed strings. It returns true if the second is *
|
|
* a prefix of the first. *
|
|
* *
|
|
****************************************************************/
|
|
|
|
LOCAL int NEAR FPrefix(psb1,psb2)
|
|
BYTE *psb1; /* Pointer to first string */
|
|
BYTE *psb2; /* Pointer to second string */
|
|
{
|
|
REGISTER WORD len; /* Length of string 2 */
|
|
|
|
if((len = B2W(psb2[0])) > B2W(psb1[0])) return(FALSE);
|
|
/* String 2 cannot be longer */
|
|
while(len) /* Compare the strings */
|
|
{
|
|
if(UPPER(psb2[len]) != UPPER(psb1[len])) return(FALSE);
|
|
/* Check for mismatch */
|
|
--len; /* Decrement index */
|
|
}
|
|
return(TRUE); /* 2 is a prefix of 1 */
|
|
}
|
|
|
|
/****************************************************************
|
|
* *
|
|
* ProcFlag: *
|
|
* *
|
|
* This function takes as its argument a length-prefixed *
|
|
* string containing a single '/-type' flag. It processes it, *
|
|
* but does not return a meaningful value. *
|
|
* *
|
|
****************************************************************/
|
|
|
|
void ProcFlag(psb) /* Process a flag */
|
|
BYTE *psb; /* Pointer to flag string */
|
|
{
|
|
struct option *pTab; /* Pointer to option table */
|
|
struct option *pTabMatch; /* Pointer to matching entry */
|
|
WORD ich3; /* Index */
|
|
WORD ich4; /* Index */
|
|
|
|
pTabMatch = NULL; /* Not found */
|
|
if((ich3 = IFind(psb,':')) == INIL)
|
|
ich3 = B2W(psb[0]); /* Get index to colon */
|
|
ich4 = B2W(psb[0]); /* Save the original length */
|
|
psb[0] = (BYTE) ich3; /* Set new length */
|
|
for(pTab = switchTab; pTab->sbSwitch; pTab++)
|
|
{ /* Loop thru switch table */
|
|
if(FPrefix(pTab->sbSwitch,psb))
|
|
{ /* If we've identified the switch */
|
|
if(pTabMatch) /* If there was a previous match */
|
|
BadFlag(psb,ER_swambig);/* Ambiguous switch */
|
|
pTabMatch = pTab; /* Save the match */
|
|
}
|
|
}
|
|
if(!pTabMatch) /* If no match found */
|
|
{
|
|
psb[psb[0]+1] = '\0';
|
|
OutWarn(ER_swunrecw,&psb[1]); /* Unrecognized switch */
|
|
return;
|
|
}
|
|
psb[0] = (BYTE) ich4; /* Restore original length */
|
|
osbSwitch = psb; /* Pass the switch implicitly */
|
|
SwitchErr = 0; /* Assume no error */
|
|
(*pTabMatch->proc)(); /* Invoke the processing procedure */
|
|
if(SwitchErr) BadFlag(psb,SwitchErr); /* Check for errors */
|
|
}
|
|
|
|
#pragma check_stack(on)
|
|
|
|
/****************************************************************
|
|
* *
|
|
* PeelFlags: *
|
|
* *
|
|
* This function takes as its argument a pointer to a length- *
|
|
* prefixed string of bytes. It "peels/processes all '/-type' *
|
|
* switches." It does not return a meaningful value. *
|
|
* *
|
|
****************************************************************/
|
|
|
|
void PeelFlags(psb) /* Peel/process flags */
|
|
BYTE *psb; /* Pointer to a byte string */
|
|
{
|
|
REGISTER WORD ich; /* Index */
|
|
SBTYPE sbFlags; /* The flags */
|
|
|
|
if((ich = IFind(psb,CHSWITCH)) != INIL)
|
|
{ /* If a switch found */
|
|
memcpy(&sbFlags[1],&psb[ich + 2],B2W(psb[0]) - ich - 1);
|
|
/* Move flags to flag buffer */
|
|
sbFlags[0] = (BYTE) ((psb[0]) - ich - 1);
|
|
/* Set the length of flags */
|
|
while(psb[ich] == ' ' && ich) --ich;
|
|
/* Delete trailing spaces */
|
|
psb[0] = (BYTE) ich; /* Reset length of input line */
|
|
ich = sbFlags[0];
|
|
while((sbFlags[ich] == ' ' ||
|
|
sbFlags[ich] == ';' ||
|
|
sbFlags[ich] == ',' ) && ich) --ich;
|
|
/* Delete unwanted characters */
|
|
sbFlags[0] = (BYTE) ich;
|
|
BreakLine(sbFlags,ProcFlag,CHSWITCH);
|
|
/* Process the switch */
|
|
}
|
|
}
|
|
|
|
#pragma check_stack(off)
|