/************************************************************/
/* Windows Write, Copyright 1985-1992 Microsoft Corporation */
/************************************************************/
/* fileutil.c -- WRITE file-related utilities */
#define NOVIRTUALKEYCODES
#define NOCTLMGR
#define NOWINMESSAGES
#define NOWINSTYLES
#define NOCLIPBOARD
#define NOGDICAPMASKS
#define NOSYSMETRICS
#define NOMENUS
#define NOCOMM
#define NOSOUND
#include <windows.h>
#include "mw.h"
#include "doslib.h"
#include "str.h"
#include "machdefs.h"
#include "cmddefs.h"
#include "propdefs.h"
#include "fkpdefs.h"
#include "docdefs.h"
#include "debug.h"
#include "editdefs.h"
#include "wwdefs.h"
#define NOKCCODES
#include "ch.h"
/*** FNormSzFile - Normalize MSDOS filename
*
* Converts a MSDOS filename into an unambiguous representation
*
* ENTRY: szFile - a filename; drive, path, and extension
* are optional
* dty - the type of the document file (used to determine
* extensions)
* EXIT: szNormal - A normalized filename
* RETURNS: FALSE - Errors found in filename (szNormal left undefined)
* TRUE - No errors found in filename ( but there may be some
* that we didn't find )
*
* The form of the filename on entry is:
*
* { <drive-letter>: }{ <amb-path> }<filename>{.<extension>}
*
* The form of the normalized filename is:
*
* <drive-letter>:<unamb-path><filename>.<extension>
*
* Where all alphabetics in the normalized name are in upper case
* and <unamb-path> contains no "." or ".." uses nor any forward
* slashes.
*
* All attributes required in the normalized filename and not
* provided in the szFile are taken from the defaults:
* drive - current (DOS)
* path - current (DOS)
* extension - derived from the passed dty
*
* It is permissible to call this routine with szFile containing a path
* name instead of a filename. The resulting szNormal will be backslash
* terminated if szFile was, not if szFile was not.
* "" is converted into the current path
*
* WARNING: The paths "." and ".." will produce errors
* (but ".\" and "..\" are OK)
*
******
*NOTE* szFile is expected in OEM; szNormal is returned as ANSI!
******
*
*/
FNormSzFile( szNormal, szFile, dty )
CHAR *szNormal;
CHAR *szFile;
int dty;
{
/* Treat separators like terminators */
#define FIsTermCh( ch ) ((ch) == '\0' || (ch) == ',' || (ch == ' ') || \
(ch) == '+' || (ch) == '\011')
extern CHAR *mpdtyszExt [];
CHAR szPath [cchMaxFile];
CHAR szFileT[cchMaxFile];
int cchPath;
CHAR *pchFileEye=&szFileT[0]; /* We read szFile with the Eye */
CHAR *pchNormPen; /* and write szNormal with the Pen */
CHAR *pchNormPath;
CHAR *pchPath;
/* Assert( CchSz( szFile ) <= cchMaxFile );*/
if (CchSz(szFile) > cchMaxFile)
return(FALSE);
#if WINVER >= 0x300
/* Convert input filename, which is passed in OEM,
to ANSI so entire return pathname will be ANSI */
OemToAnsi((LPSTR) szFile, (LPSTR) szFileT);
#endif
#ifdef DBCS
/* Get current (DOS) path: "X:\...\...\" */
if( IsDBCSLeadByte(*szFileT) )
cchPath = CchCurSzPath(szPath, 0 );
else
cchPath = CchCurSzPath(szPath, szFileT [1]==':' ?
(pchFileEye+=2,(ChUpper(szFileT [0])-('A'-1))):0 );
if( cchPath < 3 )
#else
/* Get current (DOS) path: "X:\...\...\" */
if ((cchPath = CchCurSzPath(&szPath [0], szFileT [1]==':' ?
(pchFileEye+=2,(ChUpper(szFileT [0])-('A'-1))):0 )) < 3)
#endif
{ /* Hardcore error -- could not get path */
extern int ferror;
if (FpeFromCchDisk(cchPath) == fpeNoDriveError)
Error( IDPMTNoPath );
ferror = TRUE; /* Windows already reported this one */
return FALSE;
}
#if WINVER >= 0x300
{
CHAR szT[cchMaxFile];
/* CchCurSzPath returns OEM; we should only be dealing
with ANSI filenames at this level! ..pault 1/11/90 */
bltsz(szPath, szT);
OemToAnsi((LPSTR) szT, (LPSTR) szPath);
}
#endif
/* Write Drive Letter and colon */
CopyChUpper( &szPath [0], &szNormal [0], 2 );
pchNormPen = pchNormPath = &szNormal [2];
pchPath = &szPath [2];
cchPath -= 2;
/* Now we have pchNormPen, pchPath, pchFileEye pointing at their path names */
/* Write path name */
if ( (*pchFileEye == '\\') || (*pchFileEye =='/') )
{ /* "\....." -- basis is root */
*pchFileEye++;
*(pchNormPen++) = '\\';
}
else
{ /* ".\" OR "..\" OR <text> -- basis is current path */
CopyChUpper( pchPath, pchNormPen, cchPath );
pchNormPen += cchPath - 1;
}
for ( ;; )
{ /* Loop until we have built the whole szNormal */
register CHAR ch=*(pchFileEye++);
register int cch;
Assert( *(pchNormPen - 1) == '\\' );
Assert( (pchNormPen > pchNormPath) &&
(pchNormPen <= &szNormal [cchMaxFile]));
if ( FIsTermCh( ch ) )
/* We get here if there is no filename portion */
/* This means we have produced a path name */
{
*pchNormPen = '\0';
break;
}
if ( ch == '.' )
if ( ((ch = *(pchFileEye++)) == '\\') || (ch == '/') )
/* .\ and ./ do nothing */
continue;
else if ( ch == '.' )
if ( ((ch = *(pchFileEye++)) == '\\') || (ch == '/') )
{ /* ..\ and ../ back up by one directory */
for ( pchNormPen-- ; *(pchNormPen-1) != '\\' ; pchNormPen-- )
if ( pchNormPen <= pchNormPath )
/* Can't back up, already at root */
return FALSE;
continue;
}
else
/* ERROR: .. not followed by slash */
return FALSE;
else
/* Legal file and path names do not begin with periods */
return FALSE;
/* Filename or Path -- copy ONE directory or file name */
for ( cch = 1; !FIsTermCh(ch) && ( ch != '\\') && ( ch != '/' ) ; cch++ )
#ifdef DBCS
{
if(IsDBCSLeadByte(ch))
{
pchFileEye++;
cch++;
}
ch = *(pchFileEye++);
}
#else
ch = *(pchFileEye++);
#endif
/* Check if filename too long or if full pathname will be too long ..pt */
if ( cch > cchMaxLeaf || cch+cchPath >= cchMaxFile)
/* Directory or file name too long */
return FALSE;
CopyChUpper( pchFileEye - cch, pchNormPen, cch );
pchNormPen += cch;
if ( ch == '/' )
*(pchNormPen-1) = '\\';
else if ( FIsTermCh( ch ) )
{ /* Filename looks good, add extension & exit */
*(pchNormPen-1) = '\0';
/* kludge alert: if dtyNormNoExt then don't add extension unless
there's one already there to be overwritten. (6.21.91) v-dougk */
if ((dty != dtyNormNoExt) ||
index(szNormal,'.'))
AppendSzExt( &szNormal [0],
mpdtyszExt [ (dty == dtyNormNoExt) ? dtyNormal : dty ],
FALSE );
break;
}
} /* Endfor (loop to build szNormal) */
/* If there is anything but whitespace after the filename, then it is illegal */
pchFileEye--; /* Point at the terminator */
Assert( FIsTermCh( *pchFileEye ));
for ( ;; )
{
#ifdef DBCS
CHAR ch = *(pchFileEye=AnsiNext(pchFileEye));
#else
CHAR ch = *(pchFileEye++);
#endif
if (ch == '\0')
break;
else if ((ch != ' ') && (ch != '\011'))
/* Non-whitespace after filename; return failure */
return FALSE;
}
Assert( CchSz(szNormal) <= cchMaxFile );
return TRUE;
}
/* Parses the cch chars stored in rgch. Returns true if string is a valid
filename. If the string is not a valid name, pichError is updated to have
ich of first illegal Char in the name. */
/* NOTE: this routine is tuned for ASCII on MS-DOS */
BOOL
FValidFile(rgch, ichMax, pichError) /* filename presumed to be ANSI */
register char rgch[];
int ichMax;
int *pichError;
{
int ich;
register int ichStart;
CHAR ch;
int cchBase;
int ichDot = iNil;
for (ichStart = 0; ichStart < ichMax;)
{
/* Does the file name begin with ".\" or "..\"? */
if (rgch[ichStart] == '.' &&
(rgch[ichStart + 1] == '\\' || rgch[ichStart + 1] == '/'))
{
ichStart += 2;
}
else if (rgch[ichStart] == '.' && rgch[ichStart + 1] == '.' &&
(rgch[ichStart + 2] == '\\' || rgch[ichStart + 2] == '/'))
{
ichStart += 3;
}
else
{
break;
}
}
cchBase = ichStart;
if (ichStart >= ichMax)
{
ich = ichStart;
goto badchar;
}
/* Are all characters legal? */
for(ich = ichStart; ich < ichMax; ich++)
{
ch = rgch[ich];
/* range check */
#ifndef DBCS
if ((unsigned char)ch >= 0x80)
/* To allow international filenames, pass everything above 128 */
continue;
if (ch < '!' || ch > '~')
goto badchar;
#endif
switch(ch)
{
default:
#ifdef DBCS
goto CheckDBCS;
#else
continue;
#endif
case '.':
if (ichDot != iNil || ich == cchBase)
/* More than one dot in the name */
/* Or null filename */
goto badchar;
ichDot = ich;
#ifdef DBCS
goto CheckDBCS;
#else
continue;
#endif
case ':':
if ( ich != 1 || !(isalpha(rgch[0])))
goto badchar;
/* fall through */
case '\\':
case '/':
/* note end of the drive or path */
if (ich + 1 == ichMax)
goto badchar;
cchBase = ich+1;
ichDot = iNil;
#ifdef DBCS
goto CheckDBCS;
#else
continue;
#endif
case '"':
#ifdef WRONG
/* This IS a legal filename char! ..pault 10/26/89 */
case '#':
#endif
case '*':
case '+':
case ',':
case ';':
case '<':
case '=':
case '>':
case '?':
case '[':
case ']':
case '|':
goto badchar;
}
#ifdef DBCS
CheckDBCS:
if(IsDBCSLeadByte(ch)) ich++;
#endif /* DBCS */
}
/* Are there no more than eight chars before the '.'? */
if(((ichDot == -1) ? ichMax : ichDot) - cchBase > 8)
{
ich = 8+cchBase;
goto badchar;
}
/* If there is no '.' we are fine */
if(ichDot == iNil)
return true;
/* Are there no more than three chars after the '.'? */
if(ichMax - ichDot - 1 > 3)
{
ich = ichDot + 3 + 1;
goto badchar;
}
return true;
badchar:
*pichError += ich;
return false;
}
#ifdef DBCS
CopyChUpper( szSource, szDest, cch )
register CHAR *szSource;
register CHAR *szDest;
int cch;
{
while(cch){
if( IsDBCSLeadByte( *szSource ) ){
*szDest++ = *szSource++;
*szDest++ = *szSource++;
cch--;
} else
*szDest++ = ChUpper( *szSource++ );
cch--;
}
}
#else
CopyChUpper( szSource, szDest, cch )
CHAR *szSource;
CHAR *szDest;
register int cch;
{
register CHAR ch;
while (cch--)
{
ch = *(szSource++);
*(szDest++) = ChUpper( ch );
}
}
#endif
/*** AppendSzExt - append extension to filename
*
* Append extension (assumed to contain the ".") to passed filename.
* Assumes call allocated enough string space for the append
* if fOverride is TRUE, overrides any existing extension
* if fOverride is FALSE, appends extension only if szFile has
* no current extension
*/
AppendSzExt( szFile, szExt, fOverride )
CHAR *szFile;
CHAR *szExt;
int fOverride;
{
#define cchMaxExt 3
CHAR *pch=NULL;
int cch;
register int cchT;
register int chT;
/* pch <-- pointer to the '.' for szFile's extension (if any) */
cch = cchT = CchSz( szFile ) - 1;
while (--cchT > cch - (cchMaxExt + 2))
if ((chT=szFile[ cchT ]) == '.')
{
pch = &szFile[ cchT ];
break;
}
else if ((chT == '\\') || (chT == '/'))
/* Catches the weird case: szFile == "C:\X.Y\J" */
break;
if (pch == NULL)
/* No explicit extension: APPEND */
CchCopySz( szExt, szFile + CchSz( szFile ) - 1 );
else if ( fOverride )
/* Override explicit extension */
CchCopySz( szExt, pch );
}
