|
|
/* SCCSID = %W% %E% *//*
* Copyright Microsoft Corporation, 1983-1987** This Module contains Proprietary Information of Microsoft* Corporation and should be treated as Confidential.*/ /****************************************************************
* * * NEWCMD.C * * * * Support routines for command prompter. * * * ****************************************************************/
#include <minlit.h> /* Types and constants */
#include <bndtrn.h> /* The same */
#include <bndrel.h> /* Types and constants */
#include <lnkio.h> /* Linker I/O definitions */
#include <lnkmsg.h> /* Error messages */
#include <extern.h> /* External function declarations */
/*
* FUNCTION PROTOTYPES */
LOCAL int NEAR GetInputByte(char *prompt);LOCAL BYTE NEAR GetStreamByte(char *prompt);LOCAL void NEAR SetUpCommandLine(int argc, char **argv);LOCAL void NEAR FinishCommandLine(void);#if AUTOVM
BYTE FAR * NEAR FetchSym1(RBTYPE rb, WORD Dirty);#define FETCHSYM FetchSym1
#else
#define FETCHSYM FetchSym
#endif
#if OSMSDOS
char *stackbuf;#endif
LOCAL FTYPE fMoreCommandLine; /* More command line flag */LOCAL FTYPE fMoreIndirectFile; /* More-input-from-file flag */LOCAL BSTYPE bsIndir; /* File handle for indirect file */LOCAL FTYPE fEscNext;LOCAL FTYPE fNewLine = (FTYPE) TRUE;/* New command line */LOCAL FTYPE fStuffed; /* Put-back-character flag */LOCAL BYTE bStuffed; /* The character put back */LOCAL BYTE bSepLast; /* Last separator character */ /* Char to replace spaces with */LOCAL FTYPE fRedirect; /* True iff stdin not a device */LOCAL WORD fQuotted; /* TRUE if inside " ... " */LOCAL char *pszRespFile; /* Pointer to responce file name */LOCAL char MaskedChar;
#if TRUE
#define SETCASE(c) (c) /* Leave as is */
#else
#define SETCASE(c) UPPER(c) /* Force to upper case */
#endif
#if WIN_3
extern char far *fpszLinkCmdLine;#endif
#if AUTOVM
/*
* HACK ALERT !!!!!!!!!!!! * * This function is repeated here becouse of mixed medium model. * This the same code as in NEWSYM.c but maked here LOCAL. This * allows near calls to this function in all segments, otherwise * function must be called as far. */
extern short picur;
/****************************************************************
* * * FetchSym: * * * * This function fetches a symbol from the symbol table given * * its virtual address. The symbol may either be resident or * * in virtual memory. * * * ****************************************************************/
BYTE FAR * NEAR FetchSym1(rb,fDirty)RBTYPE rb; /* Virtual address */WORD fDirty; /* Dirty page flag */{ union { long vptr; /* Virtual pointer */ BYTE FAR *fptr; /* Far pointer */ struct { unsigned short offset; /* Offset value */ unsigned short seg; } /* Segmnet value */ ptr; } pointer; /* Different ways to describe pointer */
pointer.fptr = rb;
if(pointer.ptr.seg) /* If resident - segment value != 0 */ { picur = 0; /* Picur not valid */ return(pointer.fptr); /* Return pointer */ } pointer.fptr = (BYTE FAR *) mapva(AREASYMS + (pointer.vptr << SYMSCALE),fDirty); /* Fetch from virtual memory */ return(pointer.fptr);}#endif
// Strip path from file spec - leave drive letter and filename
void StripPath(BYTE *sb){ char Drive[_MAX_DRIVE]; char Dir[_MAX_DIR]; char Name[_MAX_FNAME]; char Ext[_MAX_EXT];
/* Decompose filename into four components */
sb[sb[0]+1] = '\0'; _splitpath(sb+1, Drive, Dir, Name, Ext);
/* Create modified path name */
_makepath(sb+1, Drive, NULL, Name, Ext); sb[0] = (BYTE) strlen(sb+1);}
/****************************************************************
* * * SetUpCommandLine: * * * * This function initializes the command line parser. * * * ****************************************************************/
LOCAL void NEAR SetUpCommandLine(int argc,char **argv){ fMoreCommandLine = (FTYPE) ((argc - 1) != 0 ? TRUE : FALSE); /* If command line not empty */ if (!_isatty(fileno(stdin))) /* Determine if stdin is a device */ fRedirect = (FTYPE) TRUE;}
/****************************************************************
* * * FinishCommandLine: * * * * This function takes no arguments. If command input has * * been coming from a file, then this function closes that * * file; otherwise, it has no effect. It does not return a * * meaningful value. * * * ****************************************************************/
LOCAL void NEAR FinishCommandLine(void) /* Close indirect file */{ fflush(stdout); /* Force to screen */ if(fMoreIndirectFile) /* If command input from file */ { fMoreIndirectFile = FALSE; /* No more indirect file */ fclose(bsIndir); /* Close indirect file */ }}
#if ECS
/*
* GetTxtChr : get the next character from a text file stream * * This routine handles mixed DBCS and ASCII characters as * follows: * * 1. The second byte of a DBCS character is returned in a * word with the high byte set to the lead byte of the character. * Thus the return value can be used in comparisions with * ASCII constants without being mistakenly matched. * * 2. A DBCS space character (0x8140) is returned as two * ASCII spaces (0x20). I.e. return a space the 1st and 2nd * times we're called. * * 3. ASCII characters and lead bytes of DBCS characters * are returned in the low byte of a word with the high byte * set to 0. */
int GetTxtChr (bs)BSTYPE bs;{ static int chBuf = -1; /* Character buffer */ int next; /* The next byte */ int next2; /* The one after that */
/* -1 in chBuf means it doesn't contain a valid character */
/* If we're not in the middle of a double-byte character,
* get the next byte and process it. */ if(chBuf == -1) { next = getc(bs); /* If this byte is a lead byte, get the following byte
* and store both as a word in chBuf. */ if(IsLeadByte(next)) { next2 = getc(bs); chBuf = (next << 8) | next2; /* If the pair matches a DBCS space, set the return value
* to ASCII space. */ if(chBuf == 0x8140) next = 0x20; } } /* Else we're in the middle of a double-byte character. */ else { /* If this is the 2nd byte of a DBCS space, set the return
* value to ASCII space. */ if(chBuf == 0x8140) next = 0x20; /* Else set the return value to the whole DBCS character */ else next = chBuf; /* Reset the character buffer */ chBuf = -1; } /* Return the next character */ return(next);}#endif
/****************************************************************
* * * GetInputByte: * * * * This function takes as its input a pointer to an asciz * * string with which to prompt the user when more input is * * necessary. The function returns a byte of input. It * * checks to make sure the byte is a printable ascii character * * or a carriage return (^M). * * * ****************************************************************/
LOCAL int NEAR GetInputByte(prompt)char *prompt; /* Pointer to prompt text */{ REGISTER unsigned b; /* Input byte */#if ECS || defined(_MBCS)
static FTYPE fInDBC; /* True iff in double-byte char */#endif
if(fMoreIndirectFile) /* If input from file */ { for(;;) /* Forever */ { b = GetTxtChr(bsIndir); /* Read a byte */ if(b == EOF || b == 032) break; /* Break on end of file */ if(fNewLine) /* If at start of line */ { if (prompt && !fNoEchoLrf) (*pfCputs)(prompt); /* Prompt the user */ fNewLine = FALSE; /* Not at beginning anymore */ } if (prompt && !fNoEchoLrf) {#if CRLF
/* Allow both ^J and ^M^J to terminate input lines. */
if(b == '\r') continue; if(b == '\n') (*pfCputc)('\r');#endif
(*pfCputc)(SETCASE(b)); /* Output byte */ } if(b == ';' && !fNoEchoLrf) NEWLINE(stdout); /* Follow escape by newline */ else if(b == '\n') fNewLine = (FTYPE) TRUE; /* Look for new line */ else if (b == '\t') b = ' '; /* Translate tabs to spaces */ if(b == '\n' || b >= ' ') return(SETCASE(b)); /* Return if valid char. */ } FinishCommandLine(); /* Close indirect file */ } if(fStuffed) /* If a byte saved */ { fStuffed = FALSE; /* Now we're unstuffed */ return(bStuffed); /* Return the stuffed byte */ } if(fMoreCommandLine) /* If more command line */ { for(;;) /* Forever */ { if (*lpszCmdLine == '\0') /* If at end of command line */ { fMoreCommandLine = FALSE; /* No more command line */ fNewLine = (FTYPE) TRUE;/* New command line */ return('\n'); /* Return '\n' */ } b = (WORD) (*lpszCmdLine++);/* Get next character */ if (b == '\\' && *lpszCmdLine == '"') { /* Skip escaped double quotes */ lpszCmdLine++; if (*lpszCmdLine == '\0') { fMoreCommandLine = FALSE; /* No more command line */ fNewLine = (FTYPE) TRUE; /* New command line */ fQuotted = FALSE; return('\n'); /* Return '\n' */ } else b = (WORD) (*lpszCmdLine++); }#if ECS || defined(_MBCS)
/* If this is a trailing byte of a DBCS char, set the high
* byte of b to nonzero, so b won't be confused with an ASCII * constant. */ if (fInDBC) { b |= 0x100; fInDBC = FALSE; } else fInDBC = (FTYPE) IsLeadByte(b);#endif
if (b >= ' ') return(SETCASE(b)); /* Return if valid char. */ } } for(;;) /* Forever */ { if(fNewLine) /* If at start of line */ { if(prompt && ((!fRedirect && !fNoprompt) || (!fEsc && fNoprompt))) /* If prompt and input from CON */ (*pfCputs)(prompt); /* Prompt the user */ fNewLine = FALSE; /* Not at beginning anymore */ } b = GetTxtChr(stdin); /* Read a byte from terminal */ if(b == EOF) b = ';'; /* Treat EOF like escape */ else if (b == '\t') b = ' '; /* Treat tab like space */ if(b == '\n') fNewLine = (FTYPE) TRUE; /* New line */ if(b == '\n' || b >= ' ') return(SETCASE(b)); /* Return if character is valid */ }}
/****************************************************************
* * * GetStreamByte: * * * * This function takes as its input a pointer to a string of * * text with which to prompt the user, if necessary. It * * returns a byte of command input, and opens an indirect file * * to do so if necessary. * * * ****************************************************************/
LOCAL BYTE NEAR GetStreamByte(prompt)char *prompt; /* Pointer to text of prompt */{ REGISTER WORD ich; /* Index variable */ SBTYPE filnam; /* File name buffer */ WORD b; /* A byte */#if OSMSDOS
extern char *stackbuf;#endif
if (((b = (WORD)GetInputByte(prompt)) == INDIR) && !fQuotted) { /* If user specifies indirect file */ if (fMoreIndirectFile) Fatal(ER_nestrf); /* Check for nesting */ DEBUGMSG("Getting response file name"); /* Debug message */ ich = 0; /* Initialize index */ while(ich < SBLEN - 1) /* Loop to get file name */ { b = (WORD)GetInputByte((char *) 0); /* Read in a byte */ fQuotted = fQuotted ? b != '"' : b == '"'; if ((!fQuotted && (b == ',' || b == '+' || b == ';' || b == ' ')) || b == CHSWITCH || b < ' ') break; /* Exit loop on non-name char. */ if (b != '"') filnam[ich++] = (char) b; /* Store in file name */ } if(b > ' ') /* If legal input character */ { fStuffed = (FTYPE) TRUE; /* Set flag */ bStuffed = (BYTE) b; /* Save character */ } filnam[ich] = '\0'; /* Null-terminate file name */ pszRespFile = _strdup(filnam); /* Duplicate file name */ DEBUGMSG(filnam); /* Debug message */ if((bsIndir = fopen(filnam,RDTXT)) == NULL) Fatal(ER_opnrf,filnam);#if OSMSDOS
setvbuf(bsIndir,stackbuf,_IOFBF,512);#endif
fMoreIndirectFile = (FTYPE) TRUE;/* Take input from file now */ b = (WORD)GetInputByte(prompt); /* Read a byte */ DEBUGVALUE(b); /* Debug info */ } return((BYTE) b); /* Return a byte */}
/****************************************************************
* * * GetLine: * * * * This function takes as its arguments the address of a * * buffer in which to return a line of command text and a * * pointer to a string with which to prompt the user, if * * necessary. In addition to reading a line, this function * * will set the global flag fEsc to true if the next * * character to be read is a semicolon. The function does not * * return a meaningful value. * * * ****************************************************************/
void NEAR GetLine(pcmdlin,prompt) /* Get a command line */BYTE *pcmdlin; /* Pointer to destination string */char *prompt; /* Pointer to text of prompt string */{ REGISTER WORD ich; /* Index */ WORD ich1; /* Index */ WORD ich2; /* Index */ BYTE b; /* A byte of input */ WORD fFirstTime; /* Boolean */
fFirstTime = (FTYPE) TRUE; /* Assume it is our first time */ bSepLast = bSep; /* Save last separator */ if(fEscNext) /* If escape character next */ { pcmdlin[0] = '\0'; /* No command line */ fEsc = (FTYPE) TRUE; /* Set global flag */ return; /* That's all for now */ } for(;;) /* Forever */ { fQuotted = FALSE; ich = 0; /* Initialize index */ while(ich < SBLEN - 1) /* While room in buffer */ { b = GetStreamByte(prompt); /* Get a byte */ fQuotted = fQuotted ? b != '"' : b == '"'; if (b == '\n' || (!fQuotted && (b == ',' || b == ';'))) { if (b == ';') fMoreCommandLine = FALSE; break; /* Leave loop on end of line */ } if (!(b == ' ' && ich == 0))/* Store if not a leading space */ { if (!fQuotted) { if (b == '+') { if (!MaskedChar) MaskedChar = b; b = chMaskSpace; } if (b == ' ' && !MaskedChar) MaskedChar = b; } pcmdlin[++ich] = b; } } /*
* If ich==SBLEN-1, last char cannot have been a line terminator * and buffer is full. If next input char is a line terminator, * OK, else error. */ if(ich == SBLEN - 1 && (b = GetStreamByte(prompt)) != '\n' && b != ',' && b != ';') { fflush(stdout); Fatal(ER_linmax); } while(ich) /* Loop to trim trailing spaces */ { if(pcmdlin[ich] != ' ') break; /* Break on non-space */ --ich; /* Decrement count */ } ich1 = 0; /* Initialize */ ich2 = 0; /* Initialize */ while(ich2 < ich) /* Loop to remove or replace spaces */ { ++ich2; if (pcmdlin[ich2] == '"') { // Start of quotted file name
while (ich2 < ich && pcmdlin[++ich2] != '"') pcmdlin[++ich1] = pcmdlin[ich2]; } else if (pcmdlin[ich2] != ' ' || chMaskSpace != 0 || fQuotted) { /* If not space or replacing spaces */ ++ich1; if(!fQuotted && pcmdlin[ich2] == ' ') pcmdlin[ich1] = chMaskSpace; /* Replace space if replacing */ else pcmdlin[ich1] = pcmdlin[ich2]; /* Else copy the non-space */ } } pcmdlin[0] = (BYTE) ich1; /* Set the length */ bSep = b; /* Save the separator */ if (ich || !fFirstTime || !((bSepLast == ',' && bSep == '\n') || (bSepLast == '\n' && bSep == ','))) break; /* Exit the loop */ fFirstTime = FALSE; /* No the first time */ bSepLast = ','; /* Comma is the field separator */ } fEscNext = (FTYPE) (b == ';'); /* Set flag */ fEsc = (FTYPE) (!ich && fEscNext); /* Set flag */}
/****************************************************************
* * * ParseCmdLine: * * * * This function takes no arguments and returns no meaningful * * value. It parses the command line. * * * ****************************************************************/
void ParseCmdLine(argc,argv) /* Parse the command line */int argc; /* Count of arguments */char **argv; /* Argument vector */{ SBTYPE sbFile; /* File name */ SBTYPE sbPrompt; /* Prompt text */ SBTYPE rgb; /* Command line buffer */ FTYPE fMoreInput; /* More input flag */ FTYPE fFirstTime; AHTEPTR pahte; /* Pointer to hash table entry */ FTYPE fNoList; /* True if no list file */ BYTE *p; WORD i;#if OSMSDOS
char buf[512]; /* File buffer */ extern char *stackbuf;
stackbuf = buf;#endif
#if WIN_3
lpszCmdLine = fpszLinkCmdLine;#endif
SetUpCommandLine(argc,argv); /* Initialize command line */ chMaskSpace = 0x1f; bsLst = stdout; /* Assume listing to console */ fLstFileOpen = (FTYPE) TRUE; /* So Fatal will flush it */ fFirstTime = fMoreCommandLine; do /* Do while more input */ { fMoreInput = FALSE; /* Assume no more input */ if (fFirstTime) GetLine(rgb, NULL); else GetLine(rgb, strcat(strcpy(sbPrompt,GetMsg(P_objprompt)), " [.obj]: ")); /* Get a line of command text */ if(!rgb[0]) break; /* Break if length 0 */ if(rgb[B2W(rgb[0])] == chMaskSpace) /* If last char is chMaskSpace */ { fMoreInput = (FTYPE) TRUE; /* More to come */ --rgb[0]; /* Decrement the length */ } BreakLine(rgb,ProcObject,chMaskSpace); /* Apply ProcObject() to line */#if CMDMSDOS
if (fFirstTime && !fNoBanner) DisplayBanner(); /* Display signon banner */#endif
if (fFirstTime && !fNoEchoLrf) { if (fMoreInput || (fMoreIndirectFile && fFirstTime)) { (*pfCputs)(strcat(strcpy(sbPrompt,GetMsg(P_objprompt)), " [.obj]: ")); /* Prompt the user */ rgb[B2W(rgb[0]) + 2] = '\0'; if (fMoreIndirectFile) { if (!fMoreInput && !fNewLine && !fEscNext) rgb[B2W(rgb[0]) + 1] = ','; else if (!fMoreInput && fNewLine) rgb[B2W(rgb[0]) + 1] = ' '; else if (rgb[B2W(rgb[0]) + 1] == chMaskSpace) rgb[B2W(rgb[0]) + 1] = '+'; } else if (rgb[B2W(rgb[0]) + 1] == chMaskSpace) rgb[B2W(rgb[0]) + 1] = '+';
for (i = 1; i <= rgb[0]; i++) if (rgb[i] == chMaskSpace) rgb[i] = MaskedChar; (*pfCputs)(&rgb[1]); /* And display his response */ if (fMoreInput || fNewLine || fEscNext) if (!fNoEchoLrf) NEWLINE(stdout); } } fFirstTime = FALSE; } while(fMoreInput); /* End of loop */#if OVERLAYS
if(fInOverlay) Fatal(ER_unmlpar); /* Check for parenthesis error
* See ProcObject() to find out * what is going on here. */#endif
chMaskSpace = 0; /* Remove spaces */ if(rhteFirstObject == RHTENIL) Fatal(ER_noobj); /* There must be some objects */#if OEXE
pahte = (AHTEPTR ) FETCHSYM(rhteFirstObject,FALSE); /* Fetch name of first object */ memcpy(sbFile,GetFarSb(pahte->cch),B2W(pahte->cch[0]) + 1); /* Copy name of first object */#if ODOS3EXE
if(fQlib) UpdateFileParts(sbFile,sbDotQlb); else if (fBinary) UpdateFileParts(sbFile,sbDotCom);/* Force extension to .COM */ else#endif
UpdateFileParts(sbFile,sbDotExe);/* Force extension to .EXE */#endif
#if OIAPX286
memcpy(sbFile,"\005a.out",6); /* a.out is default for Xenix */#endif
#if OSMSDOS
if(sbFile[2] == ':') sbFile[1] = (BYTE) (DskCur + 'a'); /* Get drive letter of default drive */ StripPath(sbFile); /* Strip off path specification */#endif
bufg[0] = 0; if(!fEsc) /* If command not escaped */ { strcat(strcpy(sbPrompt, GetMsg(P_runfile)), " ["); sbFile[1 + sbFile[0]] = '\0'; /* Build run file prompt */ /* Prompt for run file */ GetLine(bufg, strcat(strcat(sbPrompt, &sbFile[1]), "]: ")); PeelFlags(bufg); /* Peel flags */ if (B2W(bufg[0])) memcpy(sbFile,bufg,B2W(bufg[0]) + 1); /* Store user responce */ else { // Store only base name without extension
sbFile[0] -= 4; } } EnterName(sbFile,ATTRNIL,TRUE); /* Create hash tab entry for name */ rhteRunfile = vrhte; /* Save hash table address */#if OSMSDOS
if (sbFile[0] >= 2 && sbFile[2] == ':') chRunFile = sbFile[1]; /* If disk specified, use it */ else chRunFile = (BYTE) (DskCur + 'a');/* Else use current disk */#endif
fNoList = (FTYPE) (!vfMap && !vfLineNos); /* Set default flag value */#if OSMSDOS
memcpy(sbFile,"\002a:",3); /* Start with a drive spec */#else
sbFile[0] = '\0'; /* Null name */#endif
pahte = (AHTEPTR ) FETCHSYM(vrhte,FALSE); /* Fetch run file name */ UpdateFileParts(sbFile,GetFarSb(pahte->cch)); /* Use .EXE file name... */ UpdateFileParts(sbFile,sbDotMap); /* ...with .MAP extension */#if OSMSDOS
sbFile[1] = (BYTE) (DskCur + 'a'); /* Default to default drive */ StripPath(sbFile); /* Strip off path specification */#endif
fNoList = (FTYPE) (!vfMap && !vfLineNos); /* No list if not /M and not /LI */ if(!fEsc) /* If argument not defaulted */ { if(bSep == ',') fNoList = FALSE;/* There will be a list file */ if(fNoList) /* If no list file yet */ {#if OSMSDOS
memcpy(sbFile,"\007nul.map",8); /* Default null list name */#endif
#if OSXENIX
memcpy(sbFile,"\007nul.map",8); /* Default null list name */#endif
} strcat(strcpy(sbPrompt, GetMsg(P_listfile)), " ["); sbFile[1 + sbFile[0]] = '\0'; GetLine(rgb, strcat(strcat(sbPrompt, &sbFile[1]), "]: ")); /* Get map file name */ PeelFlags(rgb); /* Process any flags */ if(rgb[0]) /* If name given */ { fNoList = FALSE; /* There will (maybe) be a list file */ UpdateFileParts(sbFile,rgb); } } chMaskSpace = 0x1f; /* Change spaces to chMaskSpaces */ if(!fEsc) /* If argument not defaulted */ { strcat(strcpy(sbPrompt,GetMsg(P_libprompt)), " [.lib]: "); do /* Loop to get library names */ { fMoreInput = FALSE; /* Assume no more input */ GetLine(rgb, sbPrompt); if(fEsc || !rgb[0]) break; /* Exit loop if no more input */ if(rgb[B2W(rgb[0])] == chMaskSpace) /* If more to come */ { fMoreInput = (FTYPE) TRUE; /* Set flag to true */ --rgb[0]; /* Decrement length */ } BreakLine(rgb,AddLibrary,chMaskSpace); /* Apply AddLibrary() to lib name(s) */ } while(fMoreInput); /* End of loop */ }#if OSEGEXE AND NOT QCLINK
chMaskSpace = 0; /* Remove spaces */ rhteDeffile = RHTENIL; /* Assume no definitions file */ if(!fEsc) /* If argument not defaulted */ {#if OSMSDOS
GetLine(rgb, strcat(strcpy(sbPrompt,GetMsg(P_defprompt)), " [nul.def]: ")); /* Get def file name */ memcpy(sbPrompt,"\007nul.def",8); /* Default null definition file name */#endif
#if OSXENIX
GetLine(rgb, strcat(strcpy(sbPrompt,GetMsg(P_defprompt)), " [nul.def]: ")); /* Get def file name */ memcpy(sbPrompt,"\007nul.def",8); /* Default null definition file name */#endif
PeelFlags(rgb); /* Process any flags */ if(rgb[0]) /* If a name was given */ { UpdateFileParts(sbPrompt,rgb); /* Get file name */ memcpy(rgb,sbPrompt,B2W(sbPrompt[0]) + 1); /* Copy name */ UpdateFileParts(rgb,"\003NUL"); /* Replace name with null name */ if(!SbCompare(sbPrompt,rgb,TRUE)) { /* If name not null */ EnterName(sbPrompt,ATTRNIL,TRUE); /* Create hash tab entry for name */ rhteDeffile = vrhte; /* Save hash table address */ } } }#endif /* OSEGEXE */
FinishCommandLine(); /* Close indirect file (if any) */ fLstFileOpen = FALSE;#if OSMSDOS
rhteLstfile = RHTENIL; /* Assume no list file */#endif
if(!fNoList) /* If a listing wanted */ { memcpy(sbPrompt,sbFile,B2W(sbFile[0]) + 1); /* Copy full file name */ UpdateFileParts(sbPrompt,"\003NUL"); /* Change name only */ if(!SbCompare(sbFile,sbPrompt,TRUE)) { /* If name given not null device */ UpdateFileParts(sbPrompt,"\003CON"); /* Change name only */ if(!SbCompare(sbFile,sbPrompt,TRUE)) { /* If list file not console */ sbFile[B2W(++sbFile[0])] = '\0'; /* Null-terminate name */ if((bsLst = fopen(&sbFile[1],WRBIN)) == NULL) Fatal(ER_lstopn); /* Open listing file */#if OSMSDOS
#ifdef M_I386
if((p = GetMem(512)) != NULL)#else
if((p = malloc(512)) != NULL)#endif
setvbuf(bsLst,p,_IOFBF,512); EnterName(sbFile,ATTRNIL,TRUE); /* Create hash tab entry for name */ rhteLstfile = vrhte; /* Save hash table address */#endif
} else bsLst = stdout; /* Else list to console */#if OSMSDOS
if(bsLst == stdout) chListFile = (unsigned char) '\377'; /* List file is console */ else if(_isatty(fileno(bsLst))) chListFile = (unsigned char) '\377'; /* List file is some device */ else if(sbFile[2] == ':') /* Else if drive spec given */ chListFile = (BYTE) (sbFile[1] - 'a'); /* Save floppy drive number */ else chListFile = DskCur; /* Else list file on current floppy */#endif
fLstFileOpen = (FTYPE) TRUE;/* We have a list file */ } }#if FALSE AND OSMSDOS AND OWNSTDIO
/* If wer're using our own stdio, set stdout to unbuffered if it
* goes to console. * CAN'T do this because we now use standard fprintf. Only * stdio is custom made. */ if(_isatty(fileno(stdout))) { fflush(stdout); stdout->_flag |= _IONBF; }#endif
#if QCLINK OR Z2_ON
if (fZ2 && pszRespFile != NULL) _unlink(pszRespFile); if (pszRespFile != NULL) FFREE(pszRespFile);#endif
}
|
