|
|
/*++
Copyright (c) 1993 Microsoft Corporation
Module Name:
Unitext.c
Abstract:
Main module for unicode <--> ansi/oem text file translator.
This program converts files between unicode and multibyte character sets (ansi or oem). Usage is a follows:
unitext [-m|-u] [-o|-a|-<nnn>] [-z] <src_file> <dst_file>
Author:
Ted Miller (tedm) 16-June-1993
Revision History:
--*/
#include "unitext.h"
#include <wchar.h>
//
// Globals and prototypes for use within this module.
//
//
// Unicode argc/argv.
//
int _argcW;PWCHAR *_argvW;
//
// Codepage for multibyte file.
//
DWORD CodePage = (DWORD)(-1);
//
// File handles.
//
HANDLE SourceFileHandle,TargetFileHandle;
//
// Size of source file.
//
DWORD SourceFileSize;
//
// Type of the multibyte file (source or destination).
//
DWORD MultibyteType = TFILE_NONE;
//
// Conversion type.
//
DWORD ConversionType = CONVERT_NONE;DWORD ConversionOption = CHECK_NONE;DWORD ConversionCheck = CHECK_NONE;
//
// Filenames.
//
LPWSTR SourceFilename = NULL, TargetFilename = NULL;
BOOL_ParseCommandLineArgs( VOID );
VOID_CheckFilesAndOpen( VOID );
VOID__cdeclmain( VOID ){ //
// Get command line arguments.
//
if(!InitializeUnicodeArguments(&_argcW,&_argvW)) { ErrorAbort(MSG_INSUFFICIENT_MEMORY); }
//
// Parse command line arguments.
//
if(!_ParseCommandLineArgs()) { ErrorAbort(MSG_USAGE); }
//
// Check source and destination files.
//
_CheckFilesAndOpen();
//
// Perform conversion.
//
switch(ConversionType) {
case MB_TO_UNICODE:
MultibyteTextFileToUnicode( SourceFilename, TargetFilename, SourceFileHandle, TargetFileHandle, SourceFileSize, CodePage );
break;
case UNICODE_TO_MB:
UnicodeTextFileToMultibyte( SourceFilename, TargetFilename, SourceFileHandle, TargetFileHandle, SourceFileSize, CodePage );
break; }
CloseHandle(SourceFileHandle); CloseHandle(TargetFileHandle);
//
// Clean up and exit.
//
FreeUnicodeArguments(_argcW,_argvW);}
BOOL_ParseCommandLineArgs( VOID )
/*++
Routine Description:
Parse command line arguments.
Arguments:
None. Uses globals _argcW and _argvW.
Return Value:
FALSE if invalid arguments specified.
--*/
{ int argc; PWCHAR *argv; PWCHAR arg;
//
// Initialize local variables.
//
argc = _argcW; argv = _argvW;
//
// Skip argv[0] (the program name).
//
if(argc) { argc--; argv++; }
while(argc) {
arg = *argv;
if((*arg == L'-') || (*arg == L'/')) {
switch(*(++arg)) {
case L'a': case L'A':
// if already specifed, error
if(MultibyteType != TFILE_NONE) { return(FALSE); } MultibyteType = TFILE_ANSI; break;
case L'o': case L'O':
// if already specifed, error
if(MultibyteType != TFILE_NONE) { return(FALSE); } MultibyteType = TFILE_OEM; break;
case L'm': case L'M':
if(ConversionType != CONVERT_NONE) { return(FALSE); }
ConversionType = MB_TO_UNICODE; break;
case L'u': case L'U':
if(ConversionType != CONVERT_NONE) { return(FALSE); }
ConversionType = UNICODE_TO_MB; break; case L'z': case L'Z': if(ConversionCheck != CHECK_NONE) { return(FALSE); }
ConversionCheck = CHECK_CONVERSION; break;
default:
if(iswdigit(*arg)) {
if((CodePage != (DWORD)(-1)) || (MultibyteType != TFILE_NONE)) { return(FALSE); }
swscanf(arg,L"%u",&CodePage);
MultibyteType = TFILE_USERCP;
} else {
return(FALSE); }
break; }
} else {
if(SourceFilename == NULL) {
SourceFilename = arg;
} else if(TargetFilename == NULL) {
TargetFilename = arg;
} else {
return(FALSE); }
}
argv++; argc--; }
//
// Must have source, destination filenames.
//
if(!SourceFilename || !TargetFilename) { return(FALSE); }
return(TRUE);}
VOID_CheckFilesAndOpen( VOID )
/*++
Routine Description:
Open the source and destination files, and try to make a guess about the type of the source file. If we think the source file is a different type than the user specified, print a warning.
Also check the codepage given by the user.
Arguments:
None.
Return Value:
None. Does not return if a serious error occurs.
--*/
{ DWORD SourceFileType; UCHAR FirstPartOfSource[256]; DWORD ReadSize;
//
// Determine and check codepage. Default to oem.
//
switch(MultibyteType) { case TFILE_ANSI: CodePage = GetACP(); case TFILE_USERCP: break; default: // oem or none.
CodePage = GetOEMCP(); break; }
if(!IsValidCodePage(CodePage)) { ErrorAbort(MSG_BAD_CODEPAGE,CodePage); }
//
// Try to open the source file.
//
SourceFileHandle = CreateFileW( SourceFilename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL );
if(SourceFileHandle == INVALID_HANDLE_VALUE) { ErrorAbort(MSG_CANT_OPEN_SOURCE,SourceFilename,GetLastError()); }
//
// Attempt to determine to determine the size of the source file.
//
SourceFileSize = GetFileSize(SourceFileHandle,NULL); if(SourceFileSize == -1) { ErrorAbort(MSG_CANT_GET_SIZE,SourceFilename,GetLastError()); }
//
// Filter out 0-length files here.
//
if(!SourceFileSize) { ErrorAbort(MSG_ZERO_LENGTH,SourceFilename); }
//
// Assume multibyte.
//
SourceFileType = TFILE_MULTIBYTE;
//
// Read first 256 bytes of file and call win32 api
// to determine if the text is probably unicode.
//
ReadSize = min(SourceFileSize,256); MyReadFile(SourceFileHandle,FirstPartOfSource,ReadSize,SourceFilename); if(IsTextUnicode(FirstPartOfSource,ReadSize,NULL)) { SourceFileType = TFILE_UNICODE; }
//
// If the user did not specify a conversion type, set it here
// based on the above test.
//
if(ConversionType == CONVERT_NONE) {
ConversionType = (SourceFileType == TFILE_UNICODE) ? UNICODE_TO_MB : MB_TO_UNICODE; } else {
if(ConversionCheck == CHECK_CONVERSION) { if(ConversionType == UNICODE_TO_MB) { ConversionOption = CHECK_IF_NOT_UNICODE; } else if(ConversionType == MB_TO_UNICODE) { ConversionOption = CHECK_ALREADY_UNICODE; } else { ConversionOption = CHECK_NONE; } }
//
// check if the file is UNICODE and we are trying to convert from MB_TO_UNICODE
// then issue an warning and exit
if((ConversionType == MB_TO_UNICODE) && (SourceFileType == TFILE_UNICODE) && (ConversionOption == CHECK_ALREADY_UNICODE)) { CloseHandle(SourceFileHandle); MsgPrintfW(MSG_ERR_SRC_IS_UNICODE,SourceFilename); FreeUnicodeArguments(_argcW,_argvW); exit(0); }
//
// check if the file is not unicode and if we are trying to convert from
// unicode to MB, then issue an warning and exit
if((ConversionType == UNICODE_TO_MB) && (SourceFileType != TFILE_UNICODE) && (ConversionOption == CHECK_IF_NOT_UNICODE)) { CloseHandle(SourceFileHandle); MsgPrintfW(MSG_ERR_SRC_IS_MB,SourceFilename); FreeUnicodeArguments(_argcW,_argvW); exit(0); } //
// Check to see if what we guessed is what the user asked for.
// If not, issue a warning.
//
if((ConversionType == UNICODE_TO_MB) && (SourceFileType != TFILE_UNICODE)) { MsgPrintfW(MSG_WARN_SRC_IS_MB,SourceFilename); } else { if((ConversionType == MB_TO_UNICODE) && (SourceFileType == TFILE_UNICODE)) { MsgPrintfW(MSG_WARN_SRC_IS_UNICODE,SourceFilename); } } }
//
// Try to create target file.
//
TargetFileHandle = CreateFileW( TargetFilename, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
if(TargetFileHandle == INVALID_HANDLE_VALUE) { ErrorAbort(MSG_CANT_OPEN_TARGET,TargetFilename,GetLastError()); }}
|
