able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/win32/winnls/nlstrans/locale.c
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

4538 lines
119 KiB
C
Raw Blame History

/*++
Copyright (c) 1991-1999, Microsoft Corporation All rights reserved.
Module Name:
locale.c
Abstract:
This file contains functions necessary to parse and write the locale
specific tables to a data file.
External Routines in this file:
ParseWriteLocale
Revision History:
12-10-91 JulieB Created.
03-10-00 lguindon Add explicit typecast to remove build errors
--*/
//
// Include Files.
//
#include "nlstrans.h"
//
// Constant Declarations.
//
#define OPT_CAL_FLAG 1
#define ERA_RANGE_FLAG 2
//
// Forward Declarations.
//
int
ParseLocaleInfo(
PLOCALE_HEADER pLocHdr,
PLOCALE_STATIC pLocStat,
PLOCALE_VARIABLE pLocVar,
PLOCALE_HEADER pLocCnt,
PSZ pszKeyWord);
int
ParseLine(
PSZ pszLine,
WORD *pInfo,
int BufSize,
BOOL fConvert);
int
ParseMultiLine(
PSZ pszLine,
WORD *pInfo,
int BufSize);
int ParseMultiLineSize(
PSZ pszLine,
WORD *pInfo,
int BufSize,
WORD *pNum,
int Flag);
int
GetLocaleInfoSize(
int *pSize);
int
ScanBuffer(
PSZ pszLine,
WORD *pInfo,
int BufSize,
BYTE *pszKey,
BOOL fConvert);
int
WriteLocaleInit(
FILE **ppOutputFile,
int NumLoc,
int OffLoc);
int
WriteLocaleInfo(
DWORD Locale,
int *pOffHdr,
int *pOffLoc,
PLOCALE_HEADER pLocHdr,
PLOCALE_STATIC pLocStat,
PLOCALE_VARIABLE pLocVar,
PLOCALE_HEADER pLocCnt,
FILE *pOutputFile);
int
WriteVariableLength(
PLOCALE_HEADER pLocCnt,
PLOCALE_VARIABLE pLocVar,
int *pTotalSize,
FILE *pOutputFile);
int
ParseWriteCalendar(
PCALENDAR_HEADER pCalHdr,
PCALENDAR_VARIABLE pCalVar,
PSZ pszKeyWord,
FILE *pOutputFile,
int OffHdr);
int
ParseCalendarInfo(
PCALENDAR_HEADER pCalHdr,
PCALENDAR_VARIABLE pCalVar,
PCALENDAR_HEADER pCalCnt,
PSZ pszKeyWord);
int
WriteCalendarInit(
FILE *pOutputFile,
int NumCal,
int OffCalHdr);
int
WriteCalendarInfo(
DWORD Calendar,
int *pOffHdr,
int *pOffCal,
int OffCalBegin,
PCALENDAR_HEADER pCalHdr,
PCALENDAR_VARIABLE pCalVar,
PCALENDAR_HEADER pCalCnt,
FILE *pOutputFile);
int
WriteCalendarVariableLength(
PCALENDAR_HEADER pCalCnt,
PCALENDAR_VARIABLE pCalVar,
int *pTotalSize,
FILE *pOutputFile);
int
ConvertUnicodeToWord(
WORD *pString,
WORD *pValue);
//-------------------------------------------------------------------------//
// EXTERNAL ROUTINES //
//-------------------------------------------------------------------------//
////////////////////////////////////////////////////////////////////////////
//
// ParseWriteLocale
//
// This routine parses the input file for the locale specific tables, and
// then writes the data to the output file. This routine is only entered
// when the LOCALE keyword is found. The parsing continues until the
// ENDLOCALE keyword is found.
//
// 12-10-91 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int ParseWriteLocale(
PLOCALE_HEADER pLocHdr,
PLOCALE_STATIC pLocStat,
PLOCALE_VARIABLE pLocVar,
PSZ pszKeyWord)
{
int Num; // number of locales
int OffHdr; // file offset to header info
int OffLoc; // file offset to locale info
DWORD LocId; // locale id
FILE *pOutputFile; // ptr to output file
LOCALE_HEADER LocCnt; // locale character counts
CALENDAR_HEADER CalHdr; // calendar header structure
CALENDAR_VARIABLE CalVar; // calendar variable structure
//
// Get size parameter.
//
if (GetSize(&Num))
return (1);
//
// Set up initial file pointer offsets.
//
// OffHdr = header size
// OffLoc = header size + (Number of locales * header entry size)
//
OffHdr = LOC_CAL_HDR_WORDS;
OffLoc = LOC_CAL_HDR_WORDS + (Num * LOCALE_HDR_WORDS);
//
// Initialize the output file and write the number of locales to
// the file. Also, in order to allow for the seek, write zeros
// in the file up to the first locale field.
//
if (WriteLocaleInit( &pOutputFile,
Num,
OffLoc ))
{
return (1);
}
//
// Parse all of the locales one by one. Write each one to the file
// separately to conserve memory.
//
for (; Num > 0; Num--)
{
//
// Initialize all Locale structures each time.
//
memset(pLocHdr, 0, sizeof(LOCALE_HEADER));
memset(pLocStat, 0, sizeof(LOCALE_STATIC));
memset(pLocVar, 0, sizeof(LOCALE_VARIABLE));
memset(&LocCnt, 0, sizeof(LOCALE_HEADER));
//
// Get the BEGINLOCALE keyword and locale id.
//
if (fscanf( pInputFile,
"%s %lx ;%*[^\n]",
pszKeyWord,
&LocId ) == 2)
{
if (_stricmp(pszKeyWord, "BEGINLOCALE") == 0)
{
if (Verbose)
printf("\n\nFound BEGINLOCALE keyword, LocaleID = %x\n\n",
LocId);
}
else
{
printf("Parse Error: Error reading BEGINLOCALE and Locale ID.\n");
fclose(pOutputFile);
return (1);
}
}
else
{
printf("Parse Error: Invalid Instruction '%s'.\n", pszKeyWord);
printf(" Expecting BEGINLOCALE keyword and Locale ID.\n");
fclose(pOutputFile);
return (1);
}
//
// Parse the locale information.
//
if (ParseLocaleInfo( pLocHdr,
pLocStat,
pLocVar,
&LocCnt,
pszKeyWord ))
{
printf("Parse Error: Language == %ws.\n", pLocStat->szILanguage);
fclose(pOutputFile);
return (1);
}
//
// Write the locale id, offset, and locale information to
// the output file.
//
if (WriteLocaleInfo( LocId,
&OffHdr,
&OffLoc,
pLocHdr,
pLocStat,
pLocVar,
&LocCnt,
pOutputFile ))
{
printf("Write Error: Language == %ws.\n", pLocStat->szILanguage);
fclose(pOutputFile);
return (1);
}
}
//
// Look for ENDLOCALE keyword.
//
if (fscanf(pInputFile, "%s", pszKeyWord) == 1)
{
if (_stricmp(pszKeyWord, "ENDLOCALE") == 0)
{
if (Verbose)
printf("\n\nFound ENDLOCALE keyword.\n");
}
else
{
//
// The ENDLOCALE keyword was not found. Return failure.
//
printf("Parse Error: Expecting ENDLOCALE keyword.\n");
fclose(pOutputFile);
return (1);
}
}
else
{
//
// The ENDLOCALE keyword was not found. Return failure.
//
printf("Parse Error: Expecting ENDLOCALE keyword.\n");
fclose(pOutputFile);
return (1);
}
//
// Look for CALENDAR keyword.
//
if (fscanf(pInputFile, "%s", pszKeyWord) == 1)
{
if (_stricmp(pszKeyWord, "CALENDAR") == 0)
{
if (Verbose)
printf("\n\nFound CALENDAR keyword.\n");
}
else
{
//
// The CALENDAR keyword was not found. Return failure.
//
printf("Parse Error: Expecting CALENDAR keyword.\n");
fclose(pOutputFile);
return (1);
}
}
else
{
//
// The CALENDAR keyword was not found. Return failure.
//
printf("Parse Error: Expecting CALENDAR keyword.\n");
fclose(pOutputFile);
return (1);
}
//
// Get the valid keywords for CALENDAR.
// Write the CALENDAR information to an output file.
//
if (ParseWriteCalendar( &CalHdr,
&CalVar,
pszKeyWord,
pOutputFile,
OffLoc ))
{
fclose(pOutputFile);
return (1);
}
//
// Close the output file.
//
fclose(pOutputFile);
//
// Return success.
//
printf("\nSuccessfully wrote output file %s\n", LOCALE_FILE);
return (0);
}
//-------------------------------------------------------------------------//
// INTERNAL ROUTINES //
//-------------------------------------------------------------------------//
////////////////////////////////////////////////////////////////////////////
//
// ParseLocaleInfo
//
// This routine parses the locale information from the input file. If an
// error is encountered, a 1 is returned.
//
// 12-10-91 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int ParseLocaleInfo(
PLOCALE_HEADER pLocHdr,
PLOCALE_STATIC pLocStat,
PLOCALE_VARIABLE pLocVar,
PLOCALE_HEADER pLocCnt,
PSZ pszKeyWord)
{
int Count; // number of characters written
WORD Tmp; // tmp place holder
//
// Read in the information associated with the language of a locale
// and store it in the locale structure.
//
if (!ParseLine( pszKeyWord,
pLocStat->szILanguage,
5,
TRUE ))
{
return (1);
}
pLocHdr->SLanguage = (sizeof(LOCALE_HEADER) + sizeof(LOCALE_STATIC)) /
sizeof(WORD);
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSLanguage,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SLanguage = (WORD)Count;
pLocHdr->SAbbrevLang = pLocHdr->SLanguage + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSAbbrevLang,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SAbbrevLang = (WORD)Count;
pLocHdr->SAbbrevLangISO = pLocHdr->SAbbrevLang + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSAbbrevLangISO,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SAbbrevLangISO = (WORD)Count;
pLocHdr->SNativeLang = pLocHdr->SAbbrevLangISO + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSNativeLang,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SNativeLang = (WORD)Count;
//
// Read in the information associated with the country of a locale
// and store it in the locale structure.
//
if (!ParseLine( pszKeyWord,
pLocStat->szICountry,
6,
TRUE ))
{
return (1);
}
pLocHdr->SCountry = pLocHdr->SNativeLang + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSCountry,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SCountry = (WORD)Count;
pLocHdr->SAbbrevCtry = pLocHdr->SCountry + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSAbbrevCtry,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SAbbrevCtry = (WORD)Count;
pLocHdr->SAbbrevCtryISO = pLocHdr->SAbbrevCtry + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSAbbrevCtryISO,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SAbbrevCtryISO = (WORD)Count;
pLocHdr->SNativeCtry = pLocHdr->SAbbrevCtryISO + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSNativeCtry,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SNativeCtry = (WORD)Count;
if (!ParseLine( pszKeyWord,
pLocStat->szIGeoId,
8,
TRUE ))
{
return (1);
}
//
// Read in the default language, country, and code pages of a locale
// and store it in the locale structure.
//
if (!ParseLine( pszKeyWord,
pLocStat->szIDefaultLang,
5,
TRUE ))
{
return (1);
}
if (!ParseLine( pszKeyWord,
pLocStat->szIDefaultCtry,
6,
TRUE ))
{
return (1);
}
if (!ParseLine( pszKeyWord,
pLocStat->szIDefaultACP,
6,
TRUE ))
{
return (1);
}
if (!ConvertUnicodeToWord( pLocStat->szIDefaultACP,
&(pLocStat->DefaultACP) ))
{
printf("Parse Error: Invalid IDEFAULTACP value %s\n",
pLocStat->szIDefaultACP);
return (1);
}
if (!ParseLine( pszKeyWord,
pLocStat->szIDefaultOCP,
6,
TRUE ))
{
return (1);
}
if (!ParseLine( pszKeyWord,
pLocStat->szIDefaultMACCP,
6,
TRUE ))
{
return (1);
}
if (!ParseLine( pszKeyWord,
pLocStat->szIDefaultEBCDICCP,
6,
TRUE ))
{
return (1);
}
//
// Read in the list separator, measurement info, and default paper size
// of a locale and store it in the locale structure.
//
pLocHdr->SList = pLocHdr->SNativeCtry + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSList,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SList = (WORD)Count;
if (!ParseLine( pszKeyWord,
pLocStat->szIMeasure,
2,
TRUE ))
{
return (1);
}
if (!ParseLine( pszKeyWord,
pLocStat->szIPaperSize,
2,
TRUE ))
{
return (1);
}
//
// Read in the digits information of a locale and store it in the
// locale structure.
//
pLocHdr->SDecimal = pLocHdr->SList + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSDecimal,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SDecimal = (WORD)Count;
pLocHdr->SThousand = pLocHdr->SDecimal + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSThousand,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SThousand = (WORD)Count;
pLocHdr->SGrouping = pLocHdr->SThousand + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSGrouping,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SGrouping = (WORD)Count;
if (!ParseLine( pszKeyWord,
pLocStat->szIDigits,
3,
TRUE ))
{
return (1);
}
if (!ParseLine( pszKeyWord,
pLocStat->szILZero,
2,
TRUE ))
{
return (1);
}
if (!ParseLine( pszKeyWord,
pLocStat->szINegNumber,
2,
TRUE ))
{
return (1);
}
pLocHdr->SNativeDigits = pLocHdr->SGrouping + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSNativeDigits,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SNativeDigits = (WORD)Count;
if (!ParseLine( pszKeyWord,
pLocStat->szIDigitSubstitution,
2,
TRUE ))
{
return (1);
}
//
// Read in the monetary information of a locale and store it in the
// locale structure.
//
pLocHdr->SCurrency = pLocHdr->SNativeDigits + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSCurrency,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SCurrency = (WORD)Count;
pLocHdr->SIntlSymbol = pLocHdr->SCurrency + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSIntlSymbol,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SIntlSymbol = (WORD)Count;
pLocHdr->SEngCurrName = pLocHdr->SIntlSymbol + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSEngCurrName,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SEngCurrName = (WORD)Count;
pLocHdr->SNativeCurrName = pLocHdr->SEngCurrName + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSNativeCurrName,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SNativeCurrName = (WORD)Count;
pLocHdr->SMonDecSep = pLocHdr->SNativeCurrName + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSMonDecSep,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SMonDecSep = (WORD)Count;
pLocHdr->SMonThousSep = pLocHdr->SMonDecSep + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSMonThousSep,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SMonThousSep = (WORD)Count;
pLocHdr->SMonGrouping = pLocHdr->SMonThousSep + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSMonGrouping,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SMonGrouping = (WORD)Count;
if (!ParseLine( pszKeyWord,
pLocStat->szICurrDigits,
3,
TRUE ))
{
return (1);
}
if (!ParseLine( pszKeyWord,
pLocStat->szIIntlCurrDigits,
3,
TRUE ))
{
return (1);
}
if (!ParseLine( pszKeyWord,
pLocStat->szICurrency,
2,
TRUE ))
{
return (1);
}
if (!ParseLine( pszKeyWord,
pLocStat->szINegCurr,
3,
TRUE ))
{
return (1);
}
//
// Read in the positive and negative sign information of a locale
// and store it in the locale structure.
//
pLocHdr->SPositiveSign = pLocHdr->SMonGrouping + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSPositiveSign,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SPositiveSign = (WORD)Count;
pLocHdr->SNegativeSign = pLocHdr->SPositiveSign + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSNegativeSign,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SNegativeSign = (WORD)Count;
//
// Read in the time information of a locale and store it
// in the locale structure.
//
pLocHdr->STimeFormat = pLocHdr->SNegativeSign + Count;
if (!(Count = ParseMultiLine( pszKeyWord,
pLocVar->szSTimeFormat,
MAX )))
{
return (1);
}
pLocCnt->STimeFormat = (WORD)Count;
pLocHdr->STime = pLocHdr->STimeFormat + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSTime,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->STime = (WORD)Count;
if (!ParseLine( pszKeyWord,
pLocStat->szITime,
2,
TRUE ))
{
return (1);
}
if (!ParseLine( pszKeyWord,
pLocStat->szITLZero,
2,
TRUE ))
{
return (1);
}
if (!ParseLine( pszKeyWord,
pLocStat->szITimeMarkPosn,
2,
TRUE ))
{
return (1);
}
pLocHdr->S1159 = pLocHdr->STime + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szS1159,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->S1159 = (WORD)Count;
pLocHdr->S2359 = pLocHdr->S1159 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szS2359,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->S2359 = (WORD)Count;
//
// Read in the short date information of a locale and store it
// in the locale structure.
//
pLocHdr->SShortDate = pLocHdr->S2359 + Count;
if (!(Count = ParseMultiLine( pszKeyWord,
pLocVar->szSShortDate,
MAX )))
{
return (1);
}
pLocCnt->SShortDate = (WORD)Count;
pLocHdr->SDate = pLocHdr->SShortDate + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSDate,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SDate = (WORD)Count;
if (!ParseLine( pszKeyWord,
pLocStat->szIDate,
2,
TRUE ))
{
return (1);
}
if (!ParseLine( pszKeyWord,
pLocStat->szICentury,
2,
TRUE ))
{
return (1);
}
if (!ParseLine( pszKeyWord,
pLocStat->szIDayLZero,
2,
TRUE ))
{
return (1);
}
if (!ParseLine( pszKeyWord,
pLocStat->szIMonLZero,
2,
TRUE ))
{
return (1);
}
//
// Read in the long date information of a locale and store it
// in the locale structure.
//
pLocHdr->SYearMonth = pLocHdr->SDate + Count;
if (!(Count = ParseMultiLine( pszKeyWord,
pLocVar->szSYearMonth,
MAX )))
{
return (1);
}
pLocCnt->SYearMonth = (WORD)Count;
pLocHdr->SLongDate = pLocHdr->SYearMonth + Count;
if (!(Count = ParseMultiLine( pszKeyWord,
pLocVar->szSLongDate,
MAX )))
{
return (1);
}
pLocCnt->SLongDate = (WORD)Count;
if (!ParseLine( pszKeyWord,
pLocStat->szILDate,
2,
TRUE ))
{
return (1);
}
if (!ParseLine( pszKeyWord,
pLocStat->szICalendarType,
3,
TRUE ))
{
return (1);
}
pLocHdr->IOptionalCalendar = pLocHdr->SLongDate + Count;
if (!(Count = ParseMultiLineSize( pszKeyWord,
pLocVar->szIOptionalCalendar,
MAX,
&Tmp,
OPT_CAL_FLAG )))
{
return (1);
}
pLocCnt->IOptionalCalendar = (WORD)Count;
if (!ParseLine(pszKeyWord,
pLocStat->szIFirstDayOfWeek,
2,
TRUE ))
{
return (1);
}
if (!ParseLine( pszKeyWord,
pLocStat->szIFirstWeekOfYear,
2,
TRUE ))
{
return (1);
}
//
// Read in the day information of a locale and store it in the
// locale structure.
//
pLocHdr->SDayName1 = pLocHdr->IOptionalCalendar + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSDayName1,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SDayName1 = (WORD)Count;
pLocHdr->SDayName2 = pLocHdr->SDayName1 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSDayName2,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SDayName2 = (WORD)Count;
pLocHdr->SDayName3 = pLocHdr->SDayName2 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSDayName3,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SDayName3 = (WORD)Count;
pLocHdr->SDayName4 = pLocHdr->SDayName3 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSDayName4,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SDayName4 = (WORD)Count;
pLocHdr->SDayName5 = pLocHdr->SDayName4 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSDayName5,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SDayName5 = (WORD)Count;
pLocHdr->SDayName6 = pLocHdr->SDayName5 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSDayName6,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SDayName6 = (WORD)Count;
pLocHdr->SDayName7 = pLocHdr->SDayName6 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSDayName7,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SDayName7 = (WORD)Count;
pLocHdr->SAbbrevDayName1 = pLocHdr->SDayName7 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSAbbrevDayName1,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SAbbrevDayName1 = (WORD)Count;
pLocHdr->SAbbrevDayName2 = pLocHdr->SAbbrevDayName1 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSAbbrevDayName2,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SAbbrevDayName2 = (WORD)Count;
pLocHdr->SAbbrevDayName3 = pLocHdr->SAbbrevDayName2 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSAbbrevDayName3,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SAbbrevDayName3 = (WORD)Count;
pLocHdr->SAbbrevDayName4 = pLocHdr->SAbbrevDayName3 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSAbbrevDayName4,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SAbbrevDayName4 = (WORD)Count;
pLocHdr->SAbbrevDayName5 = pLocHdr->SAbbrevDayName4 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSAbbrevDayName5,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SAbbrevDayName5 = (WORD)Count;
pLocHdr->SAbbrevDayName6 = pLocHdr->SAbbrevDayName5 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSAbbrevDayName6,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SAbbrevDayName6 = (WORD)Count;
pLocHdr->SAbbrevDayName7 = pLocHdr->SAbbrevDayName6 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSAbbrevDayName7,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SAbbrevDayName7 = (WORD)Count;
//
// Read in the month information of a locale and store it in the
// locale structure.
//
pLocHdr->SMonthName1 = pLocHdr->SAbbrevDayName7 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSMonthName1,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SMonthName1 = (WORD)Count;
pLocHdr->SMonthName2 = pLocHdr->SMonthName1 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSMonthName2,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SMonthName2 = (WORD)Count;
pLocHdr->SMonthName3 = pLocHdr->SMonthName2 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSMonthName3,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SMonthName3 = (WORD)Count;
pLocHdr->SMonthName4 = pLocHdr->SMonthName3 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSMonthName4,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SMonthName4 = (WORD)Count;
pLocHdr->SMonthName5 = pLocHdr->SMonthName4 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSMonthName5,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SMonthName5 = (WORD)Count;
pLocHdr->SMonthName6 = pLocHdr->SMonthName5 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSMonthName6,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SMonthName6 = (WORD)Count;
pLocHdr->SMonthName7 = pLocHdr->SMonthName6 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSMonthName7,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SMonthName7 = (WORD)Count;
pLocHdr->SMonthName8 = pLocHdr->SMonthName7 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSMonthName8,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SMonthName8 = (WORD)Count;
pLocHdr->SMonthName9 = pLocHdr->SMonthName8 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSMonthName9,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SMonthName9 = (WORD)Count;
pLocHdr->SMonthName10 = pLocHdr->SMonthName9 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSMonthName10,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SMonthName10 = (WORD)Count;
pLocHdr->SMonthName11 = pLocHdr->SMonthName10 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSMonthName11,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SMonthName11 = (WORD)Count;
pLocHdr->SMonthName12 = pLocHdr->SMonthName11 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSMonthName12,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SMonthName12 = (WORD)Count;
pLocHdr->SMonthName13 = pLocHdr->SMonthName12 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSMonthName13,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SMonthName13 = (WORD)Count;
pLocHdr->SAbbrevMonthName1 = pLocHdr->SMonthName13 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSAbbrevMonthName1,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SAbbrevMonthName1 = (WORD)Count;
pLocHdr->SAbbrevMonthName2 = pLocHdr->SAbbrevMonthName1 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSAbbrevMonthName2,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SAbbrevMonthName2 = (WORD)Count;
pLocHdr->SAbbrevMonthName3 = pLocHdr->SAbbrevMonthName2 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSAbbrevMonthName3,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SAbbrevMonthName3 = (WORD)Count;
pLocHdr->SAbbrevMonthName4 = pLocHdr->SAbbrevMonthName3 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSAbbrevMonthName4,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SAbbrevMonthName4 = (WORD)Count;
pLocHdr->SAbbrevMonthName5 = pLocHdr->SAbbrevMonthName4 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSAbbrevMonthName5,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SAbbrevMonthName5 = (WORD)Count;
pLocHdr->SAbbrevMonthName6 = pLocHdr->SAbbrevMonthName5 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSAbbrevMonthName6,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SAbbrevMonthName6 = (WORD)Count;
pLocHdr->SAbbrevMonthName7 = pLocHdr->SAbbrevMonthName6 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSAbbrevMonthName7,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SAbbrevMonthName7 = (WORD)Count;
pLocHdr->SAbbrevMonthName8 = pLocHdr->SAbbrevMonthName7 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSAbbrevMonthName8,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SAbbrevMonthName8 = (WORD)Count;
pLocHdr->SAbbrevMonthName9 = pLocHdr->SAbbrevMonthName8 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSAbbrevMonthName9,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SAbbrevMonthName9 = (WORD)Count;
pLocHdr->SAbbrevMonthName10 = pLocHdr->SAbbrevMonthName9 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSAbbrevMonthName10,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SAbbrevMonthName10 = (WORD)Count;
pLocHdr->SAbbrevMonthName11 = pLocHdr->SAbbrevMonthName10 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSAbbrevMonthName11,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SAbbrevMonthName11 = (WORD)Count;
pLocHdr->SAbbrevMonthName12 = pLocHdr->SAbbrevMonthName11 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSAbbrevMonthName12,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SAbbrevMonthName12 = (WORD)Count;
pLocHdr->SAbbrevMonthName13 = pLocHdr->SAbbrevMonthName12 + Count;
if (!(Count = ParseLine( pszKeyWord,
pLocVar->szSAbbrevMonthName13,
MAX,
TRUE )))
{
return (1);
}
pLocCnt->SAbbrevMonthName13 = (WORD)Count;
pLocHdr->SEndOfLocale = pLocHdr->SAbbrevMonthName13 + Count;
//
// Read in the font signature information of a locale and store it in
// the locale structure.
//
// NOTE: Don't want the null terminator on this string, so tell
// the parse routine that there is one more space in the buffer.
// This works because the buffer is filled with 0 initially, so
// no null terminator is added onto the end of the string.
// Instead, it will simply fill in the buffer with the
// MAX_FONTSIGNATURE amount of values.
//
if (!ParseLine( pszKeyWord,
pLocStat->szFontSignature,
MAX_FONTSIGNATURE + 1, // don't want null term
FALSE ))
{
return (1);
}
//
// Get szIPosSymPrecedes and szIPosSepBySpace from the szICurrency
// value.
//
// NOTE: All buffers initialized to 0, so no need to zero terminate.
//
switch (*(pLocStat->szICurrency))
{
case ( '0' ) :
{
*(pLocStat->szIPosSymPrecedes) = L'1';
*(pLocStat->szIPosSepBySpace) = L'0';
break;
}
case ( '1' ) :
{
*(pLocStat->szIPosSymPrecedes) = L'0';
*(pLocStat->szIPosSepBySpace) = L'0';
break;
}
case ( '2' ) :
{
*(pLocStat->szIPosSymPrecedes) = L'1';
*(pLocStat->szIPosSepBySpace) = L'1';
break;
}
case ( '3' ) :
{
*(pLocStat->szIPosSymPrecedes) = L'0';
*(pLocStat->szIPosSepBySpace) = L'1';
break;
}
default :
{
printf("Parse Error: Invalid ICURRENCY value.\n");
return (1);
}
}
//
// Get szIPosSignPosn, szINegSignPosn, szINegSymPrecedes, and
// szINegSepBySpace from the szINegCurr value.
//
// NOTE: All buffers initialized to 0, so no need to zero terminate.
//
switch (*(pLocStat->szINegCurr))
{
case ( '0' ) :
{
*(pLocStat->szIPosSignPosn) = L'3';
*(pLocStat->szINegSignPosn) = L'0';
*(pLocStat->szINegSymPrecedes) = L'1';
*(pLocStat->szINegSepBySpace) = L'0';
break;
}
case ( '1' ) :
{
switch (*((pLocStat->szINegCurr) + 1))
{
case ( 0 ) :
{
*(pLocStat->szIPosSignPosn) = L'3';
*(pLocStat->szINegSignPosn) = L'3';
*(pLocStat->szINegSymPrecedes) = L'1';
*(pLocStat->szINegSepBySpace) = L'0';
break;
}
case ( '0' ) :
{
*(pLocStat->szIPosSignPosn) = L'4';
*(pLocStat->szINegSignPosn) = L'4';
*(pLocStat->szINegSymPrecedes) = L'0';
*(pLocStat->szINegSepBySpace) = L'1';
break;
}
case ( '1' ) :
{
*(pLocStat->szIPosSignPosn) = L'2';
*(pLocStat->szINegSignPosn) = L'2';
*(pLocStat->szINegSymPrecedes) = L'1';
*(pLocStat->szINegSepBySpace) = L'1';
break;
}
case ( '2' ) :
{
*(pLocStat->szIPosSignPosn) = L'4';
*(pLocStat->szINegSignPosn) = L'4';
*(pLocStat->szINegSymPrecedes) = L'1';
*(pLocStat->szINegSepBySpace) = L'1';
break;
}
case ( '3' ) :
{
*(pLocStat->szIPosSignPosn) = L'3';
*(pLocStat->szINegSignPosn) = L'3';
*(pLocStat->szINegSymPrecedes) = L'0';
*(pLocStat->szINegSepBySpace) = L'1';
break;
}
case ( '4' ) :
{
*(pLocStat->szIPosSignPosn) = L'3';
*(pLocStat->szINegSignPosn) = L'0';
*(pLocStat->szINegSymPrecedes) = L'1';
*(pLocStat->szINegSepBySpace) = L'1';
break;
}
case ( '5' ) :
{
*(pLocStat->szIPosSignPosn) = L'1';
*(pLocStat->szINegSignPosn) = L'0';
*(pLocStat->szINegSymPrecedes) = L'0';
*(pLocStat->szINegSepBySpace) = L'1';
break;
}
default :
{
printf("Parse Error: Invalid INEGCURR value.\n");
return (1);
}
}
break;
}
case ( '2' ) :
{
*(pLocStat->szIPosSignPosn) = L'4';
*(pLocStat->szINegSignPosn) = L'4';
*(pLocStat->szINegSymPrecedes) = L'1';
*(pLocStat->szINegSepBySpace) = L'0';
break;
}
case ( '3' ) :
{
*(pLocStat->szIPosSignPosn) = L'2';
*(pLocStat->szINegSignPosn) = L'2';
*(pLocStat->szINegSymPrecedes) = L'1';
*(pLocStat->szINegSepBySpace) = L'0';
break;
}
case ( '4' ) :
{
*(pLocStat->szIPosSignPosn) = L'1';
*(pLocStat->szINegSignPosn) = L'0';
*(pLocStat->szINegSymPrecedes) = L'0';
*(pLocStat->szINegSepBySpace) = L'0';
break;
}
case ( '5' ) :
{
*(pLocStat->szIPosSignPosn) = L'1';
*(pLocStat->szINegSignPosn) = L'1';
*(pLocStat->szINegSymPrecedes) = L'0';
*(pLocStat->szINegSepBySpace) = L'0';
break;
}
case ( '6' ) :
{
*(pLocStat->szIPosSignPosn) = L'3';
*(pLocStat->szINegSignPosn) = L'3';
*(pLocStat->szINegSymPrecedes) = L'0';
*(pLocStat->szINegSepBySpace) = L'0';
break;
}
case ( '7' ) :
{
*(pLocStat->szIPosSignPosn) = L'4';
*(pLocStat->szINegSignPosn) = L'4';
*(pLocStat->szINegSymPrecedes) = L'0';
*(pLocStat->szINegSepBySpace) = L'0';
break;
}
case ( '8' ) :
{
*(pLocStat->szIPosSignPosn) = L'1';
*(pLocStat->szINegSignPosn) = L'1';
*(pLocStat->szINegSymPrecedes) = L'0';
*(pLocStat->szINegSepBySpace) = L'1';
break;
}
case ( '9' ) :
{
*(pLocStat->szIPosSignPosn) = L'3';
*(pLocStat->szINegSignPosn) = L'3';
*(pLocStat->szINegSymPrecedes) = L'1';
*(pLocStat->szINegSepBySpace) = L'1';
break;
}
default :
{
printf("Parse Error: Invalid INEGCURR value.\n");
return (1);
}
}
//
// Return success.
//
return (0);
}
////////////////////////////////////////////////////////////////////////////
//
// ParseLine
//
// This routine parses one line of the input file. This routine is only
// called to parse a line within the LOCALE keyword section.
// Returns the number of characters written to the buffer (0 means error).
//
// 12-10-91 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int ParseLine(
PSZ pszLine,
WORD *pInfo,
int BufSize,
BOOL fConvert)
{
int Num = 0; // number of strings read in
BYTE pszKey[MAX]; // keyword - ignored
//
// Get to next line of information.
// If no more strings could be read in, return an error.
//
if (fscanf(pInputFile, "%s", pszKey) == 0)
{
printf("Parse Error: Incomplete LOCALE information.\n");
return (0);
}
//
// Read in the rest of the line.
//
if (fgets(pszLine, MAX, pInputFile) == NULL)
{
*pInfo = 0;
return (1);
}
//
// Return the count of characters put in the buffer.
//
return (ScanBuffer( pszLine,
pInfo,
BufSize,
pszKey,
fConvert ));
}
////////////////////////////////////////////////////////////////////////////
//
// ParseMultiLine
//
// This routine parses multiple lines of the input file. This routine is only
// called to parse a set of lines within the LOCALE keyword section.
// Returns the number of characters written to the buffer (0 means error).
// This should only be called to parse multiple lines for ONE locale item.
//
// 12-10-91 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int ParseMultiLine(
PSZ pszLine,
WORD *pInfo,
int BufSize)
{
int Num = 0; // number of strings read in
BYTE pszKey[MAX]; // keyword - ignored
int Count = 0; // count of characters
int TmpCt; // ScanBuffer return count
WORD *pInfoPtr; // tmp ptr to pInfo buffer
//
// Get to next line of information.
// If no more strings could be read in, return an error.
//
if (fscanf(pInputFile, "%s", pszKey) == 0)
{
printf("Parse Error: Incomplete LOCALE information.\n");
return (0);
}
//
// Get size parameter.
//
if (GetLocaleInfoSize(&Num))
{
return (0);
}
//
// Check for num == 0.
//
if (Num == 0)
{
*pInfo = 0;
return (1);
}
//
// Read in the appropriate number of lines.
//
pInfoPtr = pInfo;
while (Num > 0)
{
//
// Read in the rest of the line. If nothing on the current line,
// go to the next line and try again.
//
if (fgets(pszLine, MAX, pInputFile) != NULL)
{
TmpCt = ScanBuffer( pszLine,
pInfoPtr,
BufSize - Count,
pszKey,
TRUE );
Num--;
pInfoPtr += TmpCt;
Count += TmpCt;
}
}
//
// Return the count of characters put in the buffer.
//
return (Count);
}
////////////////////////////////////////////////////////////////////////////
//
// ParseMultiLineSize
//
// This routine parses the IOPTIONALCALENDAR line and the SERARANGES line
// of the calendar input file. It stores the value as both a WORD and a
// string. It also stores the size of the information read in, including
// the 2 words for the value and the size.
//
// Returns the number of characters written to the buffer (0 means error).
//
// 12-10-91 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int ParseMultiLineSize(
PSZ pszLine,
WORD *pInfo,
int BufSize,
WORD *pNum,
int Flag)
{
int Num = 0; // number of strings read in
BYTE pszKey[MAX]; // keyword - ignored
int Count = 0; // count of characters
int TmpCt; // ScanBuffer return count
int Value; // value for sscanf
WORD *pInfoPtr; // tmp ptr to pInfo buffer
int Incr; // increment amount for buffer
//
// Get to next line of information.
// If no more strings could be read in, return an error.
//
if (fscanf(pInputFile, "%s", pszKey) == 0)
{
printf("Parse Error: Incomplete LOCALE information.\n");
return (0);
}
//
// Get size parameter.
//
if (GetLocaleInfoSize(&Num))
{
return (0);
}
//
// Save the number of ranges.
//
*pNum = (WORD)Num;
//
// Check for num == 0.
//
if (Num == 0)
{
*pInfo = 0;
return (1);
}
//
// Set the increment amount based on the Flag parameter.
//
Incr = (Flag == ERA_RANGE_FLAG) ? 4 : 2;
//
// Read in the appropriate number of lines.
//
pInfoPtr = pInfo;
while (Num > 0)
{
//
// If we're getting the era ranges, then we need to read in the
// month and day of the era before we read in the year.
//
// Ordering in Buffer:
// Month, Day, Year, Offset, Year String, Era Name String
//
if (Flag == ERA_RANGE_FLAG)
{
//
// Get the Month.
//
if (GetLocaleInfoSize(&Value))
{
return (0);
}
pInfoPtr[0] = (WORD)Value;
//
// Get the Day.
//
if (GetLocaleInfoSize(&Value))
{
return (0);
}
pInfoPtr[1] = (WORD)Value;
}
//
// Read in the rest of the line. If nothing on the current line,
// go to the next line and try again.
//
if (fgets(pszLine, MAX, pInputFile) != NULL)
{
TmpCt = ScanBuffer( pszLine,
pInfoPtr + Incr,
BufSize - Count - Incr,
pszKey,
TRUE );
TmpCt += Incr;
swscanf(pInfoPtr + Incr, L"%d", &Value);
pInfoPtr[Incr - 2] = (WORD)Value;
pInfoPtr[Incr - 1] = (WORD)TmpCt;
Num--;
pInfoPtr += TmpCt;
Count += TmpCt;
}
}
//
// Return the count of characters put in the buffer.
//
return (Count);
}
////////////////////////////////////////////////////////////////////////////
//
// GetLocaleInfoSize
//
// This routine gets the size of the table from the input file. If the
// size is not there, then an error is returned.
//
// 07-30-91 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int GetLocaleInfoSize(
int *pSize)
{
int NumItems; // number of items returned from fscanf
//
// Read the size from the input file.
//
NumItems = fscanf(pInputFile, "%d", pSize);
if (NumItems != 1)
{
printf("Parse Error: Error reading size value.\n");
return (1);
}
if (*pSize < 0)
{
printf("Parse Error: Invalid size value %d\n", *pSize);
return (1);
}
if (Verbose)
printf(" SIZE = %d\n", *pSize);
//
// Return success.
//
return (0);
}
////////////////////////////////////////////////////////////////////////////
//
// ScanBuffer
//
// This routine converts the given ansi buffer to a wide character buffer,
// removes leading and trailing white space, and then scans it for escape
// characters. The final buffer and the number of characters written to
// the buffer (0 means error) are returned.
//
// 12-10-91 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int ScanBuffer(
PSZ pszLine,
WORD *pInfo,
int BufSize,
BYTE *pszKey,
BOOL fConvert)
{
int Num = 0; // number of strings read in
WORD pwszTemp[MAX]; // first string of information
WORD *pwszInfoPtr; // ptr to string of information to store
int Count = 0; // count of characters
//
// Convert the ansi buffer to a wide char buffer and skip over any
// leading white space.
//
if (sscanf(pszLine, "%*[\t ]%255w[^\n]", pwszTemp) == 0)
{
//
// This should only happen if there is only white space on the line.
//
*pInfo = 0;
return (1);
}
//
// Remove trailing spaces.
//
// NOTE: Subtract 1 from the end of the string to skip over the
// null terminator. The line feed was already filtered out above.
//
pwszInfoPtr = pwszTemp + wcslen(pwszTemp) - 1;
while ((pwszInfoPtr != pwszTemp) &&
((*pwszInfoPtr == L' ') || (*pwszInfoPtr == L'\t')))
{
pwszInfoPtr--;
}
*(pwszInfoPtr + 1) = 0;
if (Verbose)
printf(" %s\t%ws\n", pszKey, pwszTemp);
//
// Buffer should be initialized to zero, so no need to
// zero terminate the string.
//
pwszInfoPtr = pwszTemp;
while ((*pwszInfoPtr != L'\n') && (*pwszInfoPtr != 0))
{
//
// Check output buffer size.
//
if (Count >= (BufSize - 1))
{
printf("WARNING: String is too long - truncating %s\n",
pszKey);
break;
}
//
// Check for escape sequence.
//
if (*pwszInfoPtr == L'\\')
{
pwszInfoPtr++;
if ((*pwszInfoPtr == L'x') || (*pwszInfoPtr == L'X'))
{
//
// Read in hex value.
//
// NOTE: All hex values MUST be 4 digits long -
// character may be ignored or hex values may be
// incorrect.
//
if (swscanf(pwszInfoPtr + 1, L"%4x", &Num) != 1)
{
printf("Parse Error: No number following \\x for %s.\n", pszKey);
return (0);
}
//
// Check for special character - 0xffff. Change it to a
// null terminator.
// This means that there is more than one string for one
// LCTYPE information.
//
if ((fConvert) && (Num == 0xffff))
{
*pInfo = (WORD)0;
}
else
{
*pInfo = (WORD)Num;
}
pInfo++;
pwszInfoPtr += 5;
Count++;
}
else if (*pwszInfoPtr == L'\\')
{
//
// Want to print out backslash, so do it.
//
*pInfo = *pwszInfoPtr;
pInfo++;
pwszInfoPtr++;
Count++;
}
else
{
//
// Escape character not followed by valid character.
//
printf("Parse Error: Invalid escape sequence for %s.\n",
pszKey);
return (0);
}
}
else
{
//
// Simply copy character. No special casing required.
//
*pInfo = *pwszInfoPtr;
pInfo++;
pwszInfoPtr++;
Count++;
}
}
//
// Return the count of characters put in the buffer.
//
return (Count + 1);
}
////////////////////////////////////////////////////////////////////////////
//
// WriteLocaleInit
//
// This routine opens the output file for writing and writes the number
// of locales as the first piece of data to the file.
//
// 12-10-91 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int WriteLocaleInit(
FILE **ppOutputFile,
int NumLoc,
int OffLoc)
{
WORD pDummy[MAX]; // dummy storage
DWORD dwValue; // temp storage value
//
// Make sure output file can be opened for writing.
//
if ((*ppOutputFile = fopen(LOCALE_FILE, "w+b")) == 0)
{
printf("Error opening output file %s.\n", LOCALE_FILE);
return (1);
}
if (Verbose)
printf("\n\nWriting output file %s...\n", LOCALE_FILE);
//
// Write the number of locales to the file.
//
dwValue = (DWORD)NumLoc;
if (FileWrite( *ppOutputFile,
&dwValue,
sizeof(DWORD),
1,
"Number of Locales" ))
{
fclose(*ppOutputFile);
return (1);
}
//
// Write zeros in the file to allow the seek to work.
//
memset(pDummy, 0, MAX * sizeof(WORD));
if (FileWrite( *ppOutputFile,
pDummy,
sizeof(WORD),
OffLoc,
"Locale File Header" ))
{
fclose(*ppOutputFile);
return (1);
}
//
// Seek back to the beginning of the locale header.
//
if (fseek( *ppOutputFile,
LOC_CAL_HDR_WORDS * sizeof(WORD),
0 ))
{
printf("Seek Error: Can't seek in file %s.\n", LOCALE_FILE);
return (1);
}
//
// Return success.
//
return (0);
}
////////////////////////////////////////////////////////////////////////////
//
// WriteLocaleInfo
//
// This routine writes the locale id, offset, and locale information to
// the output file. It needs to seek ahead to the correct position for the
// locale information, and then seeks back to the header position. The
// file positions are updated to reflect the next offsets.
//
// 12-10-91 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int WriteLocaleInfo(
DWORD Locale,
int *pOffHdr,
int *pOffLoc,
PLOCALE_HEADER pLocHdr,
PLOCALE_STATIC pLocStat,
PLOCALE_VARIABLE pLocVar,
PLOCALE_HEADER pLocCnt,
FILE *pOutputFile)
{
int Size; // size of locale information
int TotalSize = 0; // total size of the locale information
DWORD dwValue; // temp storage value
if (Verbose)
printf("\nWriting Locale Information for %x...\n", Locale);
//
// Write the locale id and offset to the locale information in
// the header area of the output file.
//
dwValue = (DWORD)(*pOffLoc);
if (FileWrite( pOutputFile,
&Locale,
sizeof(DWORD),
1,
"Locale ID" ) ||
FileWrite( pOutputFile,
&dwValue,
sizeof(DWORD),
1,
"Locale Info Offset" ))
{
return (1);
}
//
// Seek forward to locale info offset.
//
if (fseek( pOutputFile,
(*pOffLoc) * sizeof(WORD),
0 ))
{
printf("Seek Error: Can't seek in file %s.\n", LOCALE_FILE);
return (1);
}
//
// Write the locale information to the output file.
// Header Info
// Static Length Info
// Variable Length Info
//
TotalSize = Size = sizeof(LOCALE_HEADER) / sizeof(WORD);
if (FileWrite( pOutputFile,
pLocHdr,
sizeof(WORD),
Size,
"Locale Header" ))
{
return (1);
}
TotalSize += (Size = sizeof(LOCALE_STATIC) / sizeof(WORD));
if (FileWrite( pOutputFile,
pLocStat,
sizeof(WORD),
Size,
"Locale Static Info" ))
{
return (1);
}
if (WriteVariableLength( pLocCnt,
pLocVar,
&TotalSize,
pOutputFile ))
{
return (1);
}
//
// Set the offsets to their new values.
//
Size = *pOffLoc;
(*pOffHdr) += LOCALE_HDR_WORDS;
(*pOffLoc) += TotalSize;
//
// Make sure the size is not wrapping - can't be greater than
// a DWORD.
//
if (Size > *pOffLoc)
{
printf("Size Error: Offset is greater than a DWORD for locale %x.\n", Locale);
return (1);
}
//
// Seek back to the header offset.
//
if (fseek( pOutputFile,
(*pOffHdr) * sizeof(WORD),
0 ))
{
printf("Seek Error: Can't seek in file %s.\n", LOCALE_FILE);
return (1);
}
//
// Return success.
//
return (0);
}
////////////////////////////////////////////////////////////////////////////
//
// WriteVariableLength
//
// This routine writes the variable length locale information to the output
// file. It adds on to the total size of the locale information as it adds
// the variable length information.
//
// 12-10-91 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int WriteVariableLength(
PLOCALE_HEADER pLocCnt,
PLOCALE_VARIABLE pLocVar,
int *pTotalSize,
FILE *pOutputFile)
{
int Size; // size of string
*pTotalSize += (Size = pLocCnt->SLanguage);
if (FileWrite( pOutputFile,
pLocVar->szSLanguage,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SAbbrevLang);
if (FileWrite( pOutputFile,
pLocVar->szSAbbrevLang,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SAbbrevLangISO);
if (FileWrite( pOutputFile,
pLocVar->szSAbbrevLangISO,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SNativeLang);
if (FileWrite( pOutputFile,
pLocVar->szSNativeLang,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SCountry);
if (FileWrite( pOutputFile,
pLocVar->szSCountry,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SAbbrevCtry);
if (FileWrite( pOutputFile,
pLocVar->szSAbbrevCtry,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SAbbrevCtryISO);
if (FileWrite( pOutputFile,
pLocVar->szSAbbrevCtryISO,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SNativeCtry);
if (FileWrite( pOutputFile,
pLocVar->szSNativeCtry,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SList);
if (FileWrite( pOutputFile,
pLocVar->szSList,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SDecimal);
if (FileWrite( pOutputFile,
pLocVar->szSDecimal,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SThousand);
if (FileWrite( pOutputFile,
pLocVar->szSThousand,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SGrouping);
if (FileWrite( pOutputFile,
pLocVar->szSGrouping,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SNativeDigits);
if (FileWrite( pOutputFile,
pLocVar->szSNativeDigits,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SCurrency);
if (FileWrite( pOutputFile,
pLocVar->szSCurrency,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SIntlSymbol);
if (FileWrite( pOutputFile,
pLocVar->szSIntlSymbol,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SEngCurrName);
if (FileWrite( pOutputFile,
pLocVar->szSEngCurrName,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SNativeCurrName);
if (FileWrite( pOutputFile,
pLocVar->szSNativeCurrName,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SMonDecSep);
if (FileWrite( pOutputFile,
pLocVar->szSMonDecSep,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SMonThousSep);
if (FileWrite( pOutputFile,
pLocVar->szSMonThousSep,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SMonGrouping);
if (FileWrite( pOutputFile,
pLocVar->szSMonGrouping,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SPositiveSign);
if (FileWrite( pOutputFile,
pLocVar->szSPositiveSign,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SNegativeSign);
if (FileWrite( pOutputFile,
pLocVar->szSNegativeSign,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->STimeFormat);
if (FileWrite( pOutputFile,
pLocVar->szSTimeFormat,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->STime);
if (FileWrite( pOutputFile,
pLocVar->szSTime,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->S1159);
if (FileWrite( pOutputFile,
pLocVar->szS1159,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->S2359);
if (FileWrite( pOutputFile,
pLocVar->szS2359,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SShortDate);
if (FileWrite( pOutputFile,
pLocVar->szSShortDate,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SDate);
if (FileWrite( pOutputFile,
pLocVar->szSDate,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SYearMonth);
if (FileWrite( pOutputFile,
pLocVar->szSYearMonth,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SLongDate);
if (FileWrite( pOutputFile,
pLocVar->szSLongDate,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->IOptionalCalendar);
if (FileWrite( pOutputFile,
pLocVar->szIOptionalCalendar,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SDayName1);
if (FileWrite( pOutputFile,
pLocVar->szSDayName1,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SDayName2);
if (FileWrite( pOutputFile,
pLocVar->szSDayName2,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SDayName3);
if (FileWrite( pOutputFile,
pLocVar->szSDayName3,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SDayName4);
if (FileWrite( pOutputFile,
pLocVar->szSDayName4,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SDayName5);
if (FileWrite( pOutputFile,
pLocVar->szSDayName5,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SDayName6);
if (FileWrite( pOutputFile,
pLocVar->szSDayName6,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SDayName7);
if (FileWrite( pOutputFile,
pLocVar->szSDayName7,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SAbbrevDayName1);
if (FileWrite( pOutputFile,
pLocVar->szSAbbrevDayName1,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SAbbrevDayName2);
if (FileWrite( pOutputFile,
pLocVar->szSAbbrevDayName2,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SAbbrevDayName3);
if (FileWrite( pOutputFile,
pLocVar->szSAbbrevDayName3,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SAbbrevDayName4);
if (FileWrite( pOutputFile,
pLocVar->szSAbbrevDayName4,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SAbbrevDayName5);
if (FileWrite( pOutputFile,
pLocVar->szSAbbrevDayName5,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SAbbrevDayName6);
if (FileWrite( pOutputFile,
pLocVar->szSAbbrevDayName6,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SAbbrevDayName7);
if (FileWrite( pOutputFile,
pLocVar->szSAbbrevDayName7,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SMonthName1);
if (FileWrite( pOutputFile,
pLocVar->szSMonthName1,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SMonthName2);
if (FileWrite( pOutputFile,
pLocVar->szSMonthName2,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SMonthName3);
if (FileWrite( pOutputFile,
pLocVar->szSMonthName3,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SMonthName4);
if (FileWrite( pOutputFile,
pLocVar->szSMonthName4,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SMonthName5);
if (FileWrite( pOutputFile,
pLocVar->szSMonthName5,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SMonthName6);
if (FileWrite( pOutputFile,
pLocVar->szSMonthName6,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SMonthName7);
if (FileWrite( pOutputFile,
pLocVar->szSMonthName7,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SMonthName8);
if (FileWrite( pOutputFile,
pLocVar->szSMonthName8,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SMonthName9);
if (FileWrite( pOutputFile,
pLocVar->szSMonthName9,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SMonthName10);
if (FileWrite( pOutputFile,
pLocVar->szSMonthName10,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SMonthName11);
if (FileWrite( pOutputFile,
pLocVar->szSMonthName11,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SMonthName12);
if (FileWrite( pOutputFile,
pLocVar->szSMonthName12,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SMonthName13);
if (FileWrite( pOutputFile,
pLocVar->szSMonthName13,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SAbbrevMonthName1);
if (FileWrite( pOutputFile,
pLocVar->szSAbbrevMonthName1,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SAbbrevMonthName2);
if (FileWrite( pOutputFile,
pLocVar->szSAbbrevMonthName2,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SAbbrevMonthName3);
if (FileWrite( pOutputFile,
pLocVar->szSAbbrevMonthName3,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SAbbrevMonthName4);
if (FileWrite( pOutputFile,
pLocVar->szSAbbrevMonthName4,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SAbbrevMonthName5);
if (FileWrite( pOutputFile,
pLocVar->szSAbbrevMonthName5,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SAbbrevMonthName6);
if (FileWrite( pOutputFile,
pLocVar->szSAbbrevMonthName6,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SAbbrevMonthName7);
if (FileWrite( pOutputFile,
pLocVar->szSAbbrevMonthName7,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SAbbrevMonthName8);
if (FileWrite( pOutputFile,
pLocVar->szSAbbrevMonthName8,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SAbbrevMonthName9);
if (FileWrite( pOutputFile,
pLocVar->szSAbbrevMonthName9,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SAbbrevMonthName10);
if (FileWrite( pOutputFile,
pLocVar->szSAbbrevMonthName10,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SAbbrevMonthName11);
if (FileWrite( pOutputFile,
pLocVar->szSAbbrevMonthName11,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SAbbrevMonthName12);
if (FileWrite( pOutputFile,
pLocVar->szSAbbrevMonthName12,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pLocCnt->SAbbrevMonthName13);
if (FileWrite( pOutputFile,
pLocVar->szSAbbrevMonthName13,
sizeof(WORD),
Size,
"Locale Variable Info" ))
{
return (1);
}
//
// Return success.
//
return (0);
}
////////////////////////////////////////////////////////////////////////////
//
// ParseWriteCalendar
//
// This routine parses the input file for the calendar specific tables, and
// then writes the data to the output file. This routine is only entered
// when the CALENDAR keyword is found. The parsing continues until the
// ENDCALENDAR keyword is found.
//
// 12-10-91 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int ParseWriteCalendar(
PCALENDAR_HEADER pCalHdr,
PCALENDAR_VARIABLE pCalVar,
PSZ pszKeyWord,
FILE *pOutputFile,
int OffHdr)
{
int Num; // number of calendars
int OffCal; // file offset to calendar info
int OffCalBegin; // file offset to beginning of calendar info
DWORD CalId; // calendar id
CALENDAR_HEADER CalCnt; // calendar character counts
//
// Get size parameter.
//
if (GetSize(&Num))
return (1);
//
// Set up initial file pointer offsets.
//
// OffCal = (Number of calendars * header entry size)
//
OffCalBegin = OffHdr;
OffCal = Num * CALENDAR_HDR_WORDS;
//
// Initialize the output file and write the number of calendars to
// the file. Also, in order to allow for the seek, write zeros
// in the file up to the first calendar field.
//
if (WriteCalendarInit( pOutputFile,
Num,
OffHdr ))
{
return (1);
}
//
// Parse all of the calendars one by one. Write each one to the file
// separately to conserve memory.
//
for (; Num > 0; Num--)
{
//
// Initialize all Calendar structures each time.
//
memset(pCalHdr, 0, sizeof(CALENDAR_HEADER));
memset(pCalVar, 0, sizeof(CALENDAR_VARIABLE));
memset(&CalCnt, 0, sizeof(CALENDAR_HEADER));
//
// Get the BEGINCALENDAR keyword and calendar id.
//
if (fscanf( pInputFile,
"%s %ld ;%*[^\n]",
pszKeyWord,
&CalId ) == 2)
{
if (_stricmp(pszKeyWord, "BEGINCALENDAR") == 0)
{
if (Verbose)
printf("\n\nFound BEGINCALENDAR keyword, CalendarID = %d\n\n",
CalId);
}
else
{
printf("Parse Error: Error reading BEGINCALENDAR and Calendar ID.\n");
return (1);
}
}
else
{
printf("Parse Error: Invalid Instruction '%s'.\n", pszKeyWord);
printf(" Expecting BEGINCALENDAR keyword and Calendar ID.\n");
return (1);
}
//
// Parse the calendar information.
//
if (ParseCalendarInfo( pCalHdr,
pCalVar,
&CalCnt,
pszKeyWord ))
{
printf("Parse Error: Calendar == %d.\n", CalId);
return (1);
}
//
// Write the calendar id, offset, and calendar information to
// the output file.
//
if (WriteCalendarInfo( CalId,
&OffHdr,
&OffCal,
OffCalBegin,
pCalHdr,
pCalVar,
&CalCnt,
pOutputFile ))
{
printf("Write Error: Calendar == %d.\n", CalId);
return (1);
}
}
//
// Look for ENDCALENDAR keyword.
//
if (fscanf(pInputFile, "%s", pszKeyWord) == 1)
{
if (_stricmp(pszKeyWord, "ENDCALENDAR") == 0)
{
if (Verbose)
printf("\n\nFound ENDCALENDAR keyword.\n");
//
// Return success.
//
return (0);
}
}
//
// If this point is reached, then the ENDCALENDAR keyword was not
// found. Return failure.
//
printf("Parse Error: Expecting ENDCALENDAR keyword.\n");
return (1);
}
////////////////////////////////////////////////////////////////////////////
//
// ParseCalendarInfo
//
// This routine parses the calendar information from the input file. If an
// error is encountered, a 1 is returned.
//
// 12-10-91 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int ParseCalendarInfo(
PCALENDAR_HEADER pCalHdr,
PCALENDAR_VARIABLE pCalVar,
PCALENDAR_HEADER pCalCnt,
PSZ pszKeyWord)
{
int Count; // number of characters written
int Value; // hex value returned
//
// Read in the calendar id and store it in the calendar structure.
//
pCalHdr->SCalendar = sizeof(CALENDAR_HEADER) / sizeof(WORD);
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSCalendar,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SCalendar = (WORD)Count;
//
// Read in the two digit year max and store it in the calendar
// structure.
//
pCalHdr->STwoDigitYearMax = pCalHdr->SCalendar + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSTwoDigitYearMax,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->STwoDigitYearMax = (WORD)Count;
//
// Read in the range offsets and store them in the calendar structure.
//
pCalHdr->SEraRanges = pCalHdr->STwoDigitYearMax + Count;
if (!(Count = ParseMultiLineSize( pszKeyWord,
pCalVar->szSEraRanges,
MAX,
&(pCalHdr->NumRanges),
ERA_RANGE_FLAG )))
{
return (1);
}
pCalCnt->SEraRanges = (WORD)Count;
pCalCnt->NumRanges = pCalHdr->NumRanges;
//
// Read in the short date information and store it in the
// calendar structure.
//
pCalHdr->SShortDate = pCalHdr->SEraRanges + Count;
if (!(Count = ParseMultiLine( pszKeyWord,
pCalVar->szSShortDate,
MAX )))
{
return (1);
}
pCalCnt->SShortDate = (WORD)Count;
//
// Read in the year month information and store it in the
// calendar structure.
//
pCalHdr->SYearMonth = pCalHdr->SShortDate + Count;
if (!(Count = ParseMultiLine( pszKeyWord,
pCalVar->szSYearMonth,
MAX )))
{
return (1);
}
pCalCnt->SYearMonth = (WORD)Count;
//
// Read in the long date information and store it in the
// calendar structure.
//
pCalHdr->SLongDate = pCalHdr->SYearMonth + Count;
if (!(Count = ParseMultiLine( pszKeyWord,
pCalVar->szSLongDate,
MAX )))
{
return (1);
}
pCalCnt->SLongDate = (WORD)Count;
pCalHdr->SDayName1 = pCalHdr->SLongDate + Count;
//
// See if any day or month names exist.
//
if (fscanf(pInputFile, "%s", pszKeyWord) != 1)
{
printf("Parse Error: Error reading ERA keyword.\n");
return (1);
}
if (GetLocaleInfoSize(&Value))
return (1);
pCalHdr->IfNames = (WORD)Value;
pCalCnt->IfNames = (WORD)Value;
if (!Value)
{
pCalHdr->SCalendar -= CAL_NAME_HDR_SIZE;
pCalHdr->STwoDigitYearMax -= CAL_NAME_HDR_SIZE;
pCalHdr->SEraRanges -= CAL_NAME_HDR_SIZE;
pCalHdr->SShortDate -= CAL_NAME_HDR_SIZE;
pCalHdr->SYearMonth -= CAL_NAME_HDR_SIZE;
pCalHdr->SLongDate -= CAL_NAME_HDR_SIZE;
pCalHdr->SDayName1 -= CAL_NAME_HDR_SIZE;
//
// Return success. Don't read any more values for this
// calendar.
//
return (0);
}
//
// Read in the day information and store it in the
// calendar structure.
//
pCalHdr->SDayName1 = pCalHdr->SLongDate + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSDayName1,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SDayName1 = (WORD)Count;
pCalHdr->SDayName2 = pCalHdr->SDayName1 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSDayName2,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SDayName2 = (WORD)Count;
pCalHdr->SDayName3 = pCalHdr->SDayName2 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSDayName3,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SDayName3 = (WORD)Count;
pCalHdr->SDayName4 = pCalHdr->SDayName3 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSDayName4,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SDayName4 = (WORD)Count;
pCalHdr->SDayName5 = pCalHdr->SDayName4 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSDayName5,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SDayName5 = (WORD)Count;
pCalHdr->SDayName6 = pCalHdr->SDayName5 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSDayName6,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SDayName6 = (WORD)Count;
pCalHdr->SDayName7 = pCalHdr->SDayName6 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSDayName7,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SDayName7 = (WORD)Count;
pCalHdr->SAbbrevDayName1 = pCalHdr->SDayName7 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSAbbrevDayName1,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SAbbrevDayName1 = (WORD)Count;
pCalHdr->SAbbrevDayName2 = pCalHdr->SAbbrevDayName1 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSAbbrevDayName2,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SAbbrevDayName2 = (WORD)Count;
pCalHdr->SAbbrevDayName3 = pCalHdr->SAbbrevDayName2 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSAbbrevDayName3,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SAbbrevDayName3 = (WORD)Count;
pCalHdr->SAbbrevDayName4 = pCalHdr->SAbbrevDayName3 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSAbbrevDayName4,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SAbbrevDayName4 = (WORD)Count;
pCalHdr->SAbbrevDayName5 = pCalHdr->SAbbrevDayName4 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSAbbrevDayName5,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SAbbrevDayName5 = (WORD)Count;
pCalHdr->SAbbrevDayName6 = pCalHdr->SAbbrevDayName5 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSAbbrevDayName6,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SAbbrevDayName6 = (WORD)Count;
pCalHdr->SAbbrevDayName7 = pCalHdr->SAbbrevDayName6 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSAbbrevDayName7,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SAbbrevDayName7 = (WORD)Count;
//
// Read in the month information of a locale and store it in the
// locale structure.
//
pCalHdr->SMonthName1 = pCalHdr->SAbbrevDayName7 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSMonthName1,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SMonthName1 = (WORD)Count;
pCalHdr->SMonthName2 = pCalHdr->SMonthName1 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSMonthName2,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SMonthName2 = (WORD)Count;
pCalHdr->SMonthName3 = pCalHdr->SMonthName2 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSMonthName3,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SMonthName3 = (WORD)Count;
pCalHdr->SMonthName4 = pCalHdr->SMonthName3 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSMonthName4,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SMonthName4 = (WORD)Count;
pCalHdr->SMonthName5 = pCalHdr->SMonthName4 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSMonthName5,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SMonthName5 = (WORD)Count;
pCalHdr->SMonthName6 = pCalHdr->SMonthName5 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSMonthName6,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SMonthName6 = (WORD)Count;
pCalHdr->SMonthName7 = pCalHdr->SMonthName6 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSMonthName7,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SMonthName7 = (WORD)Count;
pCalHdr->SMonthName8 = pCalHdr->SMonthName7 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSMonthName8,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SMonthName8 = (WORD)Count;
pCalHdr->SMonthName9 = pCalHdr->SMonthName8 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSMonthName9,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SMonthName9 = (WORD)Count;
pCalHdr->SMonthName10 = pCalHdr->SMonthName9 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSMonthName10,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SMonthName10 = (WORD)Count;
pCalHdr->SMonthName11 = pCalHdr->SMonthName10 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSMonthName11,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SMonthName11 = (WORD)Count;
pCalHdr->SMonthName12 = pCalHdr->SMonthName11 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSMonthName12,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SMonthName12 = (WORD)Count;
pCalHdr->SMonthName13 = pCalHdr->SMonthName12 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSMonthName13,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SMonthName13 = (WORD)Count;
pCalHdr->SAbbrevMonthName1 = pCalHdr->SMonthName13 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSAbbrevMonthName1,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SAbbrevMonthName1 = (WORD)Count;
pCalHdr->SAbbrevMonthName2 = pCalHdr->SAbbrevMonthName1 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSAbbrevMonthName2,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SAbbrevMonthName2 = (WORD)Count;
pCalHdr->SAbbrevMonthName3 = pCalHdr->SAbbrevMonthName2 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSAbbrevMonthName3,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SAbbrevMonthName3 = (WORD)Count;
pCalHdr->SAbbrevMonthName4 = pCalHdr->SAbbrevMonthName3 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSAbbrevMonthName4,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SAbbrevMonthName4 = (WORD)Count;
pCalHdr->SAbbrevMonthName5 = pCalHdr->SAbbrevMonthName4 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSAbbrevMonthName5,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SAbbrevMonthName5 = (WORD)Count;
pCalHdr->SAbbrevMonthName6 = pCalHdr->SAbbrevMonthName5 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSAbbrevMonthName6,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SAbbrevMonthName6 = (WORD)Count;
pCalHdr->SAbbrevMonthName7 = pCalHdr->SAbbrevMonthName6 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSAbbrevMonthName7,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SAbbrevMonthName7 = (WORD)Count;
pCalHdr->SAbbrevMonthName8 = pCalHdr->SAbbrevMonthName7 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSAbbrevMonthName8,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SAbbrevMonthName8 = (WORD)Count;
pCalHdr->SAbbrevMonthName9 = pCalHdr->SAbbrevMonthName8 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSAbbrevMonthName9,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SAbbrevMonthName9 = (WORD)Count;
pCalHdr->SAbbrevMonthName10 = pCalHdr->SAbbrevMonthName9 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSAbbrevMonthName10,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SAbbrevMonthName10 = (WORD)Count;
pCalHdr->SAbbrevMonthName11 = pCalHdr->SAbbrevMonthName10 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSAbbrevMonthName11,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SAbbrevMonthName11 = (WORD)Count;
pCalHdr->SAbbrevMonthName12 = pCalHdr->SAbbrevMonthName11 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSAbbrevMonthName12,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SAbbrevMonthName12 = (WORD)Count;
pCalHdr->SAbbrevMonthName13 = pCalHdr->SAbbrevMonthName12 + Count;
if (!(Count = ParseLine( pszKeyWord,
pCalVar->szSAbbrevMonthName13,
MAX,
TRUE )))
{
return (1);
}
pCalCnt->SAbbrevMonthName13 = (WORD)Count;
pCalHdr->SEndOfCalendar = pCalHdr->SAbbrevMonthName13 + Count;
//
// Return success.
//
return (0);
}
////////////////////////////////////////////////////////////////////////////
//
// WriteCalendarInit
//
// This routine writes the number of calendars and the offset to the
// calendar information in the data file.
//
// 12-10-91 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int WriteCalendarInit(
FILE *pOutputFile,
int NumCal,
int OffCalHdr)
{
WORD pDummy[MAX]; // dummy storage
DWORD dwValue; // temp storage value
//
// Write the number of calendars to the file.
//
//
// Seek to NumCalendar offset.
//
if (fseek( pOutputFile,
LOC_NUM_CAL_WORDS * sizeof(WORD),
0 ))
{
printf("Seek Error: Can't seek in file %s.\n", LOCALE_FILE);
return (1);
}
//
// Write the number of calendars to the file.
//
dwValue = (DWORD)NumCal;
if (FileWrite( pOutputFile,
&dwValue,
sizeof(DWORD),
1,
"Number of Calendars" ))
{
return (1);
}
//
// Write the offset of calendar info to the file.
//
dwValue = (DWORD)OffCalHdr;
if (FileWrite( pOutputFile,
&dwValue,
sizeof(DWORD),
1,
"Offset of Calendar Info" ))
{
return (1);
}
//
// Seek to calendar header.
//
if (fseek( pOutputFile,
OffCalHdr * sizeof(WORD),
0 ))
{
printf("Seek Error: Can't seek in file %s.\n", LOCALE_FILE);
return (1);
}
//
// Write zeros in the file to allow the seek to work.
//
memset(pDummy, 0, MAX * sizeof(WORD));
if (FileWrite( pOutputFile,
pDummy,
sizeof(WORD),
NumCal * CALENDAR_HDR_WORDS,
"Calendar Header" ))
{
return (1);
}
//
// Seek back to the beginning of the calendar header.
//
if (fseek( pOutputFile,
OffCalHdr * sizeof(WORD),
0 ))
{
printf("Seek Error: Can't seek in file %s.\n", LOCALE_FILE);
return (1);
}
//
// Return success.
//
return (0);
}
////////////////////////////////////////////////////////////////////////////
//
// WriteCalendarInfo
//
// This routine writes the calendar id, offset, and calendar information to
// the output file. It needs to seek ahead to the correct position for the
// calendar information, and then seeks back to the header position. The
// file positions are updated to reflect the next offsets.
//
// 12-10-91 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int WriteCalendarInfo(
DWORD Calendar,
int *pOffHdr,
int *pOffCal,
int OffCalBegin,
PCALENDAR_HEADER pCalHdr,
PCALENDAR_VARIABLE pCalVar,
PCALENDAR_HEADER pCalCnt,
FILE *pOutputFile)
{
int Size; // size of locale information
int TotalSize = 0; // total size of the locale information
int NameSize; // size of name space to subtract
WORD wValue; // temp storage value
if (Verbose)
printf("\nWriting Calendar Information for %x...\n", Calendar);
//
// Write the calendar id and offset to the calendar information in
// the calendar header area of the output file.
//
wValue = (WORD)Calendar;
if (FileWrite( pOutputFile,
&wValue,
sizeof(WORD),
1,
"Calendar ID" ))
{
return (1);
}
wValue = (WORD)(*pOffCal);
if (FileWrite( pOutputFile,
&wValue,
sizeof(WORD),
1,
"Calendar Info Offset" ))
{
return (1);
}
//
// Seek forward to calendar info offset.
//
if (fseek( pOutputFile,
(OffCalBegin + (*pOffCal)) * sizeof(WORD),
0 ))
{
printf("Seek Error: Can't seek in file %s.\n", LOCALE_FILE);
return (1);
}
//
// Write the calendar information to the output file.
// Header Info
// Variable Length Info
//
NameSize = (pCalHdr->IfNames) ? 0 : CAL_NAME_HDR_SIZE;
TotalSize = Size = (sizeof(CALENDAR_HEADER) / sizeof(WORD)) - NameSize;
if (FileWrite( pOutputFile,
pCalHdr,
sizeof(WORD),
Size,
"Calendar Header" ))
{
return (1);
}
if (WriteCalendarVariableLength( pCalCnt,
pCalVar,
&TotalSize,
pOutputFile ))
{
return (1);
}
//
// Set the offsets to their new values.
//
(*pOffHdr) += CALENDAR_HDR_WORDS;
(*pOffCal) += TotalSize;
//
// Make sure the size is not wrapping - can't be greater than
// a DWORD.
//
if (*pOffCal > 0xffff)
{
printf("Size Error: Offset is greater than a WORD for calendar %d.\n", Calendar);
return (1);
}
//
// Seek back to the calendar header offset.
//
if (fseek( pOutputFile,
(*pOffHdr) * sizeof(WORD),
0 ))
{
printf("Seek Error: Can't seek in file %s.\n", LOCALE_FILE);
return (1);
}
//
// Return success.
//
return (0);
}
////////////////////////////////////////////////////////////////////////////
//
// WriteCalendarVariableLength
//
// This routine writes the variable length calendar information to the output
// file. It adds on to the total size of the calendar information as it adds
// the variable length information.
//
// 12-10-91 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int WriteCalendarVariableLength(
PCALENDAR_HEADER pCalCnt,
PCALENDAR_VARIABLE pCalVar,
int *pTotalSize,
FILE *pOutputFile)
{
int Size; // size of string
*pTotalSize += (Size = pCalCnt->SCalendar);
if (FileWrite( pOutputFile,
pCalVar->szSCalendar,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->STwoDigitYearMax);
if (FileWrite( pOutputFile,
pCalVar->szSTwoDigitYearMax,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SEraRanges);
if (FileWrite( pOutputFile,
pCalVar->szSEraRanges,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SShortDate);
if (FileWrite( pOutputFile,
pCalVar->szSShortDate,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SYearMonth);
if (FileWrite( pOutputFile,
pCalVar->szSYearMonth,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SLongDate);
if (FileWrite( pOutputFile,
pCalVar->szSLongDate,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
//
// See if any of the day or month names exist.
//
if (pCalCnt->IfNames == 0)
{
//
// Return success. Don't write any of the day or month names.
//
return (0);
}
*pTotalSize += (Size = pCalCnt->SDayName1);
if (FileWrite( pOutputFile,
pCalVar->szSDayName1,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SDayName2);
if (FileWrite( pOutputFile,
pCalVar->szSDayName2,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SDayName3);
if (FileWrite( pOutputFile,
pCalVar->szSDayName3,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SDayName4);
if (FileWrite( pOutputFile,
pCalVar->szSDayName4,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SDayName5);
if (FileWrite( pOutputFile,
pCalVar->szSDayName5,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SDayName6);
if (FileWrite( pOutputFile,
pCalVar->szSDayName6,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SDayName7);
if (FileWrite( pOutputFile,
pCalVar->szSDayName7,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SAbbrevDayName1);
if (FileWrite( pOutputFile,
pCalVar->szSAbbrevDayName1,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SAbbrevDayName2);
if (FileWrite( pOutputFile,
pCalVar->szSAbbrevDayName2,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SAbbrevDayName3);
if (FileWrite( pOutputFile,
pCalVar->szSAbbrevDayName3,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SAbbrevDayName4);
if (FileWrite( pOutputFile,
pCalVar->szSAbbrevDayName4,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SAbbrevDayName5);
if (FileWrite( pOutputFile,
pCalVar->szSAbbrevDayName5,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SAbbrevDayName6);
if (FileWrite( pOutputFile,
pCalVar->szSAbbrevDayName6,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SAbbrevDayName7);
if (FileWrite( pOutputFile,
pCalVar->szSAbbrevDayName7,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SMonthName1);
if (FileWrite( pOutputFile,
pCalVar->szSMonthName1,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SMonthName2);
if (FileWrite( pOutputFile,
pCalVar->szSMonthName2,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SMonthName3);
if (FileWrite( pOutputFile,
pCalVar->szSMonthName3,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SMonthName4);
if (FileWrite( pOutputFile,
pCalVar->szSMonthName4,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SMonthName5);
if (FileWrite( pOutputFile,
pCalVar->szSMonthName5,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SMonthName6);
if (FileWrite( pOutputFile,
pCalVar->szSMonthName6,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SMonthName7);
if (FileWrite( pOutputFile,
pCalVar->szSMonthName7,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SMonthName8);
if (FileWrite( pOutputFile,
pCalVar->szSMonthName8,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SMonthName9);
if (FileWrite( pOutputFile,
pCalVar->szSMonthName9,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SMonthName10);
if (FileWrite( pOutputFile,
pCalVar->szSMonthName10,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SMonthName11);
if (FileWrite( pOutputFile,
pCalVar->szSMonthName11,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SMonthName12);
if (FileWrite( pOutputFile,
pCalVar->szSMonthName12,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SMonthName13);
if (FileWrite( pOutputFile,
pCalVar->szSMonthName13,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SAbbrevMonthName1);
if (FileWrite( pOutputFile,
pCalVar->szSAbbrevMonthName1,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SAbbrevMonthName2);
if (FileWrite( pOutputFile,
pCalVar->szSAbbrevMonthName2,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SAbbrevMonthName3);
if (FileWrite( pOutputFile,
pCalVar->szSAbbrevMonthName3,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SAbbrevMonthName4);
if (FileWrite( pOutputFile,
pCalVar->szSAbbrevMonthName4,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SAbbrevMonthName5);
if (FileWrite( pOutputFile,
pCalVar->szSAbbrevMonthName5,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SAbbrevMonthName6);
if (FileWrite( pOutputFile,
pCalVar->szSAbbrevMonthName6,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SAbbrevMonthName7);
if (FileWrite( pOutputFile,
pCalVar->szSAbbrevMonthName7,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SAbbrevMonthName8);
if (FileWrite( pOutputFile,
pCalVar->szSAbbrevMonthName8,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SAbbrevMonthName9);
if (FileWrite( pOutputFile,
pCalVar->szSAbbrevMonthName9,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SAbbrevMonthName10);
if (FileWrite( pOutputFile,
pCalVar->szSAbbrevMonthName10,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SAbbrevMonthName11);
if (FileWrite( pOutputFile,
pCalVar->szSAbbrevMonthName11,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SAbbrevMonthName12);
if (FileWrite( pOutputFile,
pCalVar->szSAbbrevMonthName12,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
*pTotalSize += (Size = pCalCnt->SAbbrevMonthName13);
if (FileWrite( pOutputFile,
pCalVar->szSAbbrevMonthName13,
sizeof(WORD),
Size,
"Calendar Variable Info" ))
{
return (1);
}
//
// Return success.
//
return (0);
}
////////////////////////////////////////////////////////////////////////////
//
// ConvertUnicodeToWord
//
// This routine converts a Unicode string to a WORD value.
//
// 08-21-95 JulieB Created.
////////////////////////////////////////////////////////////////////////////
#define ISDIGIT(c) ((c) >= L'0' && (c) <= L'9')
int ConvertUnicodeToWord(
WORD *pString,
WORD *pValue)
{
UINT Val = 0;
while (*pString)
{
if (ISDIGIT(*pString))
{
Val *= 10;
Val += *pString - L'0';
pString++;
}
else
{
//
// Error.
//
return (0);
}
}
if (Val > 0xffff)
{
//
// Code page cannot be greater than a WORD value.
//
return (0);
}
*pValue = (WORD)Val;
return (1);
}
Reference in a new issue View git blame Copy permalink