1474 lines
38 KiB
C
1474 lines
38 KiB
C
/*++
|
|
|
|
Copyright (c) 1991-1996, Microsoft Corporation All rights reserved.
|
|
|
|
Module Name:
|
|
|
|
alloc.c
|
|
|
|
Abstract:
|
|
|
|
This file contains functions that will allocate the necessary memory
|
|
blocks.
|
|
|
|
External Routines in this file:
|
|
AllocateMB
|
|
AllocateGlyph
|
|
AllocateTopDBCS
|
|
AllocateDBCS
|
|
AllocateWCTable
|
|
Allocate8
|
|
Insert844
|
|
Insert844Map
|
|
AllocateTemp844
|
|
AllocateCTMap
|
|
AllocateGrid
|
|
AllocateLangException
|
|
AllocateLangExceptionNodes
|
|
AllocateSortDefault
|
|
AllocateReverseDW
|
|
AllocateDoubleCompression
|
|
AllocateIdeographLcid
|
|
AllocateExpansion
|
|
AllocateCompression
|
|
AllocateCompression2Nodes
|
|
AllocateCompression3Nodes
|
|
AllocateException
|
|
AllocateExceptionNodes
|
|
AllocateMultipleWeights
|
|
AllocateIdeographExceptions
|
|
Free844
|
|
FreeCTMap
|
|
|
|
Revision History:
|
|
|
|
07-30-91 JulieB Created.
|
|
|
|
--*/
|
|
|
|
|
|
|
|
//
|
|
// Include Files.
|
|
//
|
|
|
|
#include "nlstrans.h"
|
|
|
|
|
|
|
|
|
|
//
|
|
// Forward Declarations.
|
|
//
|
|
|
|
CT_MAP_VALUE
|
|
MapTrioToByte(
|
|
PCT_MAP pMap,
|
|
WORD Value1,
|
|
WORD Value2,
|
|
WORD Value3);
|
|
|
|
|
|
|
|
|
|
|
|
//-------------------------------------------------------------------------//
|
|
// EXTERNAL ROUTINES //
|
|
//-------------------------------------------------------------------------//
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// AllocateMB
|
|
//
|
|
// This routine allocates all structures needed for the MB table.
|
|
// If an error is encountered while allocating, an error is returned.
|
|
//
|
|
// 07-30-91 JulieB Created.
|
|
// 12-10-91 JulieB Modified for new table format.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int AllocateMB(
|
|
PCODEPAGE pCP)
|
|
{
|
|
//
|
|
// Allocate MB Table buffer.
|
|
// Set all entries in MB Table to zero.
|
|
//
|
|
if ((pCP->pMB = (PMB_TBL)malloc(MB_TABLE_SIZE * sizeof(WORD))) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer.\n");
|
|
return (1);
|
|
}
|
|
memset(pCP->pMB, 0, MB_TABLE_SIZE * sizeof(WORD));
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// AllocateGlyph
|
|
//
|
|
// This routine allocates all structures needed for the Glyph table.
|
|
// If an error is encountered while allocating, an error is returned.
|
|
// All entries in the glyph table are set equal to the entries in the
|
|
// MB table. If the MB table has not been read in yet, then an error
|
|
// is returned.
|
|
//
|
|
// 06-02-92 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int AllocateGlyph(
|
|
PCODEPAGE pCP)
|
|
{
|
|
int ctr; // loop counter
|
|
|
|
|
|
//
|
|
// Allocate Glyph Table buffer.
|
|
//
|
|
if ((pCP->pGlyph = (PGLYPH_TBL)malloc( GLYPH_TABLE_SIZE *
|
|
sizeof(WORD) )) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer.\n");
|
|
return (1);
|
|
}
|
|
|
|
//
|
|
// Make sure the MB table has already been read in at this point.
|
|
//
|
|
if ((!(pCP->WriteFlags & F_MB)) || (pCP->pMB == NULL))
|
|
{
|
|
printf("Parse Error: MBTABLE must be BEFORE GLYPHTABLE in file.\n");
|
|
return (1);
|
|
}
|
|
|
|
//
|
|
// Set all entries in the Glyph Table to the MB Table entries.
|
|
// All new glyph values will overwrite the appropriate MB entries
|
|
// in the glyph table.
|
|
//
|
|
for (ctr = 0; ((ctr < GLYPH_TABLE_SIZE) && (ctr < MB_TABLE_SIZE)); ctr++)
|
|
{
|
|
(pCP->pGlyph)[ctr] = (pCP->pMB)[ctr];
|
|
}
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// AllocateTopDBCS
|
|
//
|
|
// This routine allocates the initial DBCS array structure. If an error
|
|
// is encountered while allocating, an error is returned.
|
|
//
|
|
// 07-30-91 JulieB Created.
|
|
// 12-10-91 JulieB Modified for new table format.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int AllocateTopDBCS(
|
|
PCODEPAGE pCP,
|
|
int Size)
|
|
{
|
|
//
|
|
// Allocate initial DBCS array structure.
|
|
//
|
|
if ((pCP->pDBCS = (PDBCS_ARRAY)malloc( Size *
|
|
sizeof(PDBCS_RANGE) )) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer.\n");
|
|
return (1);
|
|
}
|
|
memset(pCP->pDBCS, 0, Size * sizeof(PDBCS_RANGE));
|
|
|
|
//
|
|
// Allocate offset area.
|
|
//
|
|
if ((pCP->pDBCSOff = (PDBCS_OFFSETS)malloc( DBCS_OFFSET_SIZE *
|
|
sizeof(WORD) )) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer.\n");
|
|
return (1);
|
|
}
|
|
memset(pCP->pDBCSOff, 0, DBCS_OFFSET_SIZE * sizeof(WORD));
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// AllocateDBCS
|
|
//
|
|
// This routine allocates all structures needed for the DBCS tables and
|
|
// ranges. If an error is encountered while allocating, an error is
|
|
// returned.
|
|
//
|
|
// 07-30-91 JulieB Created.
|
|
// 12-10-91 JulieB Modified for new table format.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int AllocateDBCS(
|
|
PCODEPAGE pCP,
|
|
int Low,
|
|
int High,
|
|
int Index)
|
|
{
|
|
PDBCS_RANGE pRange; // ptr to DBCS range
|
|
PDBCS_TBL_ARRAY pTblArray; // ptr to DBCS table array
|
|
int Ctr, Ctr2; // loop counters
|
|
int NumTables = High - Low + 1; // number of tables for range
|
|
WORD *pWordPtr; // ptr to dbcs buffer
|
|
|
|
|
|
//
|
|
// Allocate Range Structure.
|
|
//
|
|
if ((pRange = (PDBCS_RANGE)malloc(sizeof(DBCS_RANGE))) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer.\n");
|
|
return (1);
|
|
}
|
|
memset(pRange, 0, sizeof(DBCS_RANGE));
|
|
|
|
//
|
|
// Allocate Table Array.
|
|
//
|
|
if ((pTblArray = (PDBCS_TBL_ARRAY)malloc( NumTables *
|
|
sizeof(PDBCS_TBL) )) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer.\n");
|
|
return (1);
|
|
}
|
|
memset(pTblArray, 0, NumTables * sizeof(PDBCS_TBL));
|
|
|
|
//
|
|
// Allocate All Tables.
|
|
//
|
|
for (Ctr = 0; Ctr < NumTables; Ctr++)
|
|
{
|
|
//
|
|
// Allocate table.
|
|
//
|
|
if ((pTblArray[Ctr] = (PDBCS_TBL)malloc( DBCS_TABLE_SIZE *
|
|
sizeof(WORD) )) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer.\n");
|
|
return (1);
|
|
}
|
|
|
|
//
|
|
// Set all entries to the Unicode default character.
|
|
//
|
|
pWordPtr = (WORD *)(pTblArray[Ctr]);
|
|
for (Ctr2 = 0; Ctr2 < DBCS_TABLE_SIZE; Ctr2++)
|
|
{
|
|
pWordPtr[Ctr2] = (WORD)(pCP->UniDefaultChar);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Attach the tables to each other.
|
|
//
|
|
pRange->pDBCSTbls = pTblArray;
|
|
(pCP->pDBCS)[Index] = pRange;
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// AllocateWCTable
|
|
//
|
|
// This routine allocates the buffer for the Unicode to ANSI translation
|
|
// table. The buffer is (64K // Size) bytes in length.
|
|
//
|
|
// 05-28-92 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int AllocateWCTable(
|
|
PCODEPAGE pCP,
|
|
int Size)
|
|
{
|
|
int Ctr; // loop counter
|
|
WORD *pWordPtr; // ptr to wide character buffer
|
|
|
|
|
|
//
|
|
// Allocate translation table buffer.
|
|
//
|
|
if ((pCP->pWC = (PWC_ARRAY)malloc(WC_TABLE_SIZE * Size)) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer.\n");
|
|
return (1);
|
|
}
|
|
|
|
//
|
|
// Set all entries to the default character.
|
|
//
|
|
if (Size == sizeof(BYTE))
|
|
{
|
|
memset(pCP->pWC, (BYTE)(pCP->DefaultChar), WC_TABLE_SIZE);
|
|
}
|
|
else if (Size == sizeof(WORD))
|
|
{
|
|
pWordPtr = pCP->pWC;
|
|
for (Ctr = 0; Ctr < WC_TABLE_SIZE; Ctr++)
|
|
{
|
|
pWordPtr[Ctr] = pCP->DefaultChar;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
printf("Code Error: Bad 'Size' parameter for AllocateWCTable.\n");
|
|
return (1);
|
|
}
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Allocate8
|
|
//
|
|
// This routine allocates the top buffer for the 8:4:4 table.
|
|
//
|
|
// 07-30-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int Allocate8(
|
|
P844_ARRAY *pArr)
|
|
{
|
|
//
|
|
// Allocate top buffer for 8:4:4 table - 256 pointers.
|
|
//
|
|
if ((*pArr = (P844_ARRAY)malloc( TABLE_SIZE_8 *
|
|
sizeof(P844_ARRAY) )) == NULL)
|
|
{
|
|
printf("Error: Can't allocate top 8:4:4 buffer.\n");
|
|
return (1);
|
|
}
|
|
memset(*pArr, 0, TABLE_SIZE_8 * sizeof(P844_ARRAY));
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Insert844
|
|
//
|
|
// This routine inserts a WORD or DWORD value into an 8:4:4 table based on
|
|
// the Size parameter. It does so by allocating the appropriate buffers
|
|
// and filling in the third buffers with the appropriate WORD or DWORD value.
|
|
//
|
|
// 07-30-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int Insert844(
|
|
P844_ARRAY pArr,
|
|
WORD WChar,
|
|
DWORD Value,
|
|
int *cbBuf2,
|
|
int *cbBuf3,
|
|
int Size)
|
|
{
|
|
register int Index; // index into array
|
|
P844_ARRAY pTbl2; // pointer to second array
|
|
P844_ARRAY pTbl3; // pointer to third array
|
|
|
|
|
|
//
|
|
// Use the "8" index to get to the second table.
|
|
// Allocate it if necessary.
|
|
//
|
|
Index = GET8(WChar);
|
|
if ((pTbl2 = (P844_ARRAY)(pArr[Index])) == NULL)
|
|
{
|
|
//
|
|
// Allocate second table - 16 pointers.
|
|
//
|
|
if ((pTbl2 = (P844_ARRAY)malloc( TABLE_SIZE_4 *
|
|
sizeof(P844_ARRAY) )) == NULL)
|
|
{
|
|
printf("Error: Can't allocate second 8:4:4 buffer.\n");
|
|
return (1);
|
|
}
|
|
memset(pTbl2, 0, TABLE_SIZE_4 * sizeof(P844_ARRAY));
|
|
pArr[Index] = pTbl2;
|
|
|
|
//
|
|
// Keep track of how many "second buffer" allocations were made.
|
|
//
|
|
(*cbBuf2)++;
|
|
}
|
|
|
|
//
|
|
// Use the "high 4" index to get to the third table.
|
|
// Allocate it if necessary.
|
|
//
|
|
Index = GETHI4(WChar);
|
|
if ((pTbl3 = pTbl2[Index]) == NULL)
|
|
{
|
|
//
|
|
// Allocate third table - 16 words.
|
|
//
|
|
if ((pTbl3 = (P844_ARRAY)malloc(TABLE_SIZE_4 * Size)) == NULL)
|
|
{
|
|
printf("Error: Can't allocate third 8:4:4 buffer.\n");
|
|
return (1);
|
|
}
|
|
memset(pTbl3, 0, TABLE_SIZE_4 * Size);
|
|
pTbl2[Index] = pTbl3;
|
|
|
|
//
|
|
// Keep track of how many "third buffer" allocations were made.
|
|
//
|
|
(*cbBuf3)++;
|
|
}
|
|
|
|
//
|
|
// Use the "low 4" value to index into the third table.
|
|
// Save the value at this spot.
|
|
//
|
|
Index = GETLO4(WChar);
|
|
|
|
if (Size == sizeof(WORD))
|
|
{
|
|
((WORD *)pTbl3)[Index] = (WORD)Value;
|
|
}
|
|
else if (Size == sizeof(DWORD))
|
|
{
|
|
((DWORD *)pTbl3)[Index] = (DWORD)Value;
|
|
}
|
|
else
|
|
{
|
|
printf("Code Error: Bad 'Size' parameter for Insert844 Table.\n");
|
|
return (1);
|
|
}
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Insert844Map
|
|
//
|
|
// This routine inserts 3 WORD values into an 8:4:4 table. It does so by
|
|
// allocating the appropriate buffers and filling in the third buffers
|
|
// with a 1 BYTE value that is the mapping of the given 3 WORD trio.
|
|
//
|
|
// 10-29-93 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int Insert844Map(
|
|
P844_ARRAY pArr,
|
|
PCT_MAP pMap,
|
|
WORD WChar,
|
|
WORD Value1,
|
|
WORD Value2,
|
|
WORD Value3,
|
|
int *cbBuf2,
|
|
int *cbBuf3)
|
|
{
|
|
register int Index; // index into array
|
|
P844_ARRAY pTbl2; // pointer to second array
|
|
PCT_MAP_VALUE pTbl3; // pointer to third array
|
|
|
|
|
|
//
|
|
// Use the "8" index to get to the second table.
|
|
// Allocate it if necessary.
|
|
//
|
|
Index = GET8(WChar);
|
|
if ((pTbl2 = (P844_ARRAY)(pArr[Index])) == NULL)
|
|
{
|
|
//
|
|
// Allocate second table - 16 pointers + 1 word.
|
|
// The additional 1 word will be used when writing this table
|
|
// to avoid duplicates of the same table.
|
|
//
|
|
if ((pTbl2 = (P844_ARRAY)malloc( (TABLE_SIZE_4 + 1) *
|
|
sizeof(P844_ARRAY) )) == NULL)
|
|
{
|
|
printf("Error: Can't allocate second 8:4:4 buffer.\n");
|
|
return (1);
|
|
}
|
|
memset(pTbl2, 0, (TABLE_SIZE_4 + 1) * sizeof(P844_ARRAY));
|
|
pArr[Index] = pTbl2;
|
|
|
|
//
|
|
// Keep track of how many "second buffer" allocations were made.
|
|
//
|
|
(*cbBuf2)++;
|
|
}
|
|
|
|
//
|
|
// Use the "high 4" index to get to the third table.
|
|
// Allocate it if necessary.
|
|
//
|
|
Index = GETHI4(WChar);
|
|
if ((pTbl3 = pTbl2[Index]) == NULL)
|
|
{
|
|
//
|
|
// Allocate third table - 16 + 2 bytes.
|
|
// The 2 extra bytes will be used when writing the table.
|
|
//
|
|
if ((pTbl3 = (PCT_MAP_VALUE)malloc( (TABLE_SIZE_4 + 2) *
|
|
(sizeof(CT_MAP_VALUE)) )) == NULL)
|
|
{
|
|
printf("Error: Can't allocate third 8:4:4 buffer.\n");
|
|
return (1);
|
|
}
|
|
|
|
//
|
|
// The last field of the third table is used when writing to the
|
|
// data file to ensure that each table is written only ONCE
|
|
// (with muliple pointers to it). This field takes 1 WORD
|
|
// (2 bytes) and is initialized to 0.
|
|
//
|
|
memset(pTbl3, 0, (TABLE_SIZE_4 + 2) * (sizeof(CT_MAP_VALUE)));
|
|
pTbl2[Index] = pTbl3;
|
|
|
|
//
|
|
// Keep track of how many "third buffer" allocations were made.
|
|
//
|
|
(*cbBuf3)++;
|
|
}
|
|
|
|
//
|
|
// Use the "low 4" value to index into the third table.
|
|
// Save the values at this spot.
|
|
//
|
|
Index = GETLO4(WChar);
|
|
|
|
//
|
|
// Map 3 WORD CType trio to 1 BYTE value.
|
|
//
|
|
pTbl3[Index] = MapTrioToByte( pMap,
|
|
Value1,
|
|
Value2,
|
|
Value3 );
|
|
|
|
//
|
|
// Make sure the number of entries in the mapping table is
|
|
// not greater than MAX_CT_MAP_TBL_SIZE.
|
|
//
|
|
if (pMap->Length >= MAX_CT_MAP_TBL_SIZE)
|
|
{
|
|
printf("Error: CTYPE Mapping Table Too Large.\n");
|
|
return (1);
|
|
}
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// AllocateTemp844
|
|
//
|
|
// This routine allocates the temporary storage buffer for the 8:4:4
|
|
// table. This temporary buffer is used when writing to the output file.
|
|
// The size of the buffer is (TblSize * Size) bytes in length.
|
|
//
|
|
// 07-30-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int AllocateTemp844(
|
|
PVOID *ppArr,
|
|
int TblSize,
|
|
int Size)
|
|
{
|
|
//
|
|
// Allocate buffer of size TblSize.
|
|
//
|
|
if ((*ppArr = (PVOID)malloc(TblSize * Size)) == NULL)
|
|
{
|
|
printf("Error: Can't allocate temp 8:4:4 buffer.\n");
|
|
return (1);
|
|
}
|
|
memset(*ppArr, 0, TblSize * Size);
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// AllocateCTMap
|
|
//
|
|
// This routine allocates all structures needed for the ctype mapping table.
|
|
// If an error is encountered while allocating, an error is returned.
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int AllocateCTMap(
|
|
PCT_MAP *pMap)
|
|
{
|
|
//
|
|
// Allocate buffer mapping table.
|
|
//
|
|
if ((*pMap = (PCT_MAP)malloc(sizeof(CT_MAP))) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer for CType Mapping table.\n");
|
|
return (1);
|
|
}
|
|
memset(*pMap, 0, sizeof(CT_MAP));
|
|
|
|
//
|
|
// Allocate mapping table entries.
|
|
//
|
|
if (((*pMap)->pCTValues = (PCT_VALUES)malloc( MAX_CT_MAP_TBL_SIZE *
|
|
sizeof(CT_VALUES) )) == NULL)
|
|
{
|
|
printf("Error: Can't allocate CType mapping table with %d entries.\n",
|
|
MAX_CT_MAP_TBL_SIZE);
|
|
return (1);
|
|
}
|
|
|
|
//
|
|
// Set the first entry to 0 so that any third level table that maps
|
|
// to 0 will be C1 = 0, C2 = 0, and C3 = 0.
|
|
//
|
|
memset((*pMap)->pCTValues, 0, sizeof(CT_VALUES));
|
|
(*pMap)->Length = 1;
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// AllocateGrid
|
|
//
|
|
// This routine allocates the 2D grid for the composite table.
|
|
// The size passed in is the number of precomposed entries that need to
|
|
// go into the table. Since the exact size of the array is not known yet,
|
|
// the maximum possible size is allocated (size squared).
|
|
//
|
|
// 07-30-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int AllocateGrid(
|
|
PCOMP_GRID *pCompGrid,
|
|
int TblSize)
|
|
{
|
|
//
|
|
// Allocate 2D grid.
|
|
// The size of the grid is the TblSize squared plus one to save the
|
|
// size of the grid.
|
|
//
|
|
if ((*pCompGrid = (PCOMP_GRID)malloc( (TblSize * TblSize + 1) *
|
|
sizeof(WORD) )) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer.\n");
|
|
return (1);
|
|
}
|
|
memset(*pCompGrid, 0, (TblSize * TblSize + 1) * sizeof(WORD));
|
|
|
|
//
|
|
// Save the size of the grid in the first spot.
|
|
//
|
|
(*pCompGrid)[0] = (WORD)TblSize;
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// AllocateLangException
|
|
//
|
|
// This routine allocates the exception header and the exception table.
|
|
// The size of the table is determined by the TblSize parameter. The
|
|
// pointer to the header and the table are stored in the language
|
|
// structure.
|
|
//
|
|
// 08-30-95 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int AllocateLangException(
|
|
PLANG_EXCEPT pLangExcept,
|
|
int TblSize)
|
|
{
|
|
//
|
|
// Set the number of Exception entries in table.
|
|
//
|
|
pLangExcept->NumException = TblSize;
|
|
|
|
//
|
|
// Allocate buffer of size TblSize for Exception header.
|
|
//
|
|
if ((pLangExcept->pExceptHdr =
|
|
(PL_EXCEPT_HDR)malloc(TblSize * sizeof(L_EXCEPT_HDR))) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer for Exception Header.\n");
|
|
return (1);
|
|
}
|
|
memset(pLangExcept->pExceptHdr, 0, TblSize * sizeof(L_EXCEPT_HDR));
|
|
|
|
//
|
|
// Allocate buffer of size TblSize for Exception table.
|
|
//
|
|
if ((pLangExcept->pExceptTbl =
|
|
(PL_EXCEPT_TBL)malloc(TblSize * sizeof(PL_EXCEPT_NODE))) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer for Exception table.\n");
|
|
return (1);
|
|
}
|
|
memset(pLangExcept->pExceptTbl, 0, TblSize * sizeof(PL_EXCEPT_NODE));
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// AllocateLangExceptionNodes
|
|
//
|
|
// This routine allocates the exception nodes for the exception table.
|
|
// The size of the table is determined by the TblSize parameter. The
|
|
// pointer to the nodes is stored in the exception table at the Index
|
|
// given.
|
|
//
|
|
// 08-30-95 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int AllocateLangExceptionNodes(
|
|
PLANG_EXCEPT pLangExcept,
|
|
int TblSize,
|
|
int Index)
|
|
{
|
|
PL_EXCEPT_NODE pExcNode; // ptr to exception node
|
|
|
|
|
|
//
|
|
// Allocate buffer of size TblSize for Exception nodes.
|
|
//
|
|
if ((pExcNode = (PL_EXCEPT_NODE)malloc( TblSize *
|
|
sizeof(L_EXCEPT_NODE) )) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer for Exception Nodes.\n");
|
|
return (1);
|
|
}
|
|
memset(pExcNode, 0, TblSize * sizeof(L_EXCEPT_NODE));
|
|
|
|
//
|
|
// Set pointer in exception table.
|
|
//
|
|
(pLangExcept->pExceptTbl)[Index] = pExcNode;
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// AllocateSortDefault
|
|
//
|
|
// This routine allocates the sort default table - 64K DWORDS. The pointer
|
|
// to the new table is stored in the sortkey structure.
|
|
//
|
|
// 11-04-92 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int AllocateSortDefault(
|
|
PSORTKEY pSKey)
|
|
{
|
|
//
|
|
// Allocate buffer of size 64K DWORDS for sort default table.
|
|
//
|
|
if ((pSKey->pDefault = (PSKEY)malloc( SKEY_TBL_SIZE *
|
|
sizeof(SKEY) )) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer for sortkey default table.\n");
|
|
return (1);
|
|
}
|
|
memset(pSKey->pDefault, 0, SKEY_TBL_SIZE * sizeof(SKEY));
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// AllocateReverseDW
|
|
//
|
|
// This routine allocates the reverse diacritic weight table. The size of
|
|
// the table is determined by the TblSize parameter. The pointer to the
|
|
// new table is stored in the sorttables structure.
|
|
//
|
|
// 11-04-92 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int AllocateReverseDW(
|
|
PSORT_TABLES pSTbl,
|
|
int TblSize)
|
|
{
|
|
//
|
|
// Allocate buffer of size TblSize for RevrseDW table.
|
|
//
|
|
if ((pSTbl->pReverseDW = (PREV_DW)malloc( TblSize *
|
|
sizeof(REV_DW) )) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer for Reverse DW table.\n");
|
|
return (1);
|
|
}
|
|
memset(pSTbl->pReverseDW, 0, TblSize * sizeof(REV_DW));
|
|
|
|
//
|
|
// Set the number of ReverseDW entries in table.
|
|
//
|
|
pSTbl->NumReverseDW = TblSize;
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// AllocateDoubleCompression
|
|
//
|
|
// This routine allocates the double compression table. The size of
|
|
// the table is determined by the TblSize parameter. The pointer to the
|
|
// new table is stored in the sorttables structure.
|
|
//
|
|
// 11-04-92 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int AllocateDoubleCompression(
|
|
PSORT_TABLES pSTbl,
|
|
int TblSize)
|
|
{
|
|
//
|
|
// Allocate buffer of size TblSize for Double Compression table.
|
|
//
|
|
if ((pSTbl->pDblCompression =
|
|
(PDBL_COMPRESS)malloc(TblSize * sizeof(DBL_COMPRESS))) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer for Double Compression table.\n");
|
|
return (1);
|
|
}
|
|
memset(pSTbl->pDblCompression, 0, TblSize * sizeof(DBL_COMPRESS));
|
|
|
|
//
|
|
// Set the number of Double Compression entries in table.
|
|
//
|
|
pSTbl->NumDblCompression = TblSize;
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// AllocateIdeographLcid
|
|
//
|
|
// This routine allocates the ideograph lcid table. The size of
|
|
// the table is determined by the TblSize parameter. The pointer to the
|
|
// new table is stored in the sorttables structure.
|
|
//
|
|
// 09-01-93 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int AllocateIdeographLcid(
|
|
PSORT_TABLES pSTbl,
|
|
int TblSize)
|
|
{
|
|
//
|
|
// Allocate buffer of size TblSize for IdeographLcid table.
|
|
//
|
|
if ((pSTbl->pIdeographLcid =
|
|
(PIDEOGRAPH_LCID)malloc(TblSize * sizeof(IDEOGRAPH_LCID))) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer for Ideograph Lcid table.\n");
|
|
return (1);
|
|
}
|
|
memset(pSTbl->pIdeographLcid, 0, TblSize * sizeof(IDEOGRAPH_LCID));
|
|
|
|
//
|
|
// Set the number of Ideograph Lcid entries in table.
|
|
//
|
|
pSTbl->NumIdeographLcid = TblSize;
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// AllocateExpansion
|
|
//
|
|
// This routine allocates the expansion table. The size of
|
|
// the table is determined by the TblSize parameter. The pointer to the
|
|
// new table is stored in the sorttables structure.
|
|
//
|
|
// 11-04-92 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int AllocateExpansion(
|
|
PSORT_TABLES pSTbl,
|
|
int TblSize)
|
|
{
|
|
//
|
|
// Allocate buffer of size TblSize for Expansion table.
|
|
//
|
|
if ((pSTbl->pExpansion = (PEXPAND)malloc( TblSize *
|
|
sizeof(EXPAND) )) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer for Expansion table.\n");
|
|
return (1);
|
|
}
|
|
memset(pSTbl->pExpansion, 0, TblSize * sizeof(EXPAND));
|
|
|
|
//
|
|
// Set the number of Expansion entries in table.
|
|
//
|
|
pSTbl->NumExpansion = TblSize;
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// AllocateCompression
|
|
//
|
|
// This routine allocates the compression header and the compression table.
|
|
// The size of the table is determined by the TblSize parameter. The
|
|
// pointer to the header and the table are stored in the sorttables
|
|
// structure.
|
|
//
|
|
// 11-04-92 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int AllocateCompression(
|
|
PSORT_TABLES pSTbl,
|
|
int TblSize)
|
|
{
|
|
//
|
|
// Set the number of Compression entries in table.
|
|
//
|
|
pSTbl->NumCompression = TblSize;
|
|
|
|
//
|
|
// Allocate buffer of size TblSize for Compression header.
|
|
//
|
|
if ((pSTbl->pCompressHdr =
|
|
(PCOMPRESS_HDR)malloc(TblSize * sizeof(COMPRESS_HDR))) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer for Compression Header.\n");
|
|
return (1);
|
|
}
|
|
memset(pSTbl->pCompressHdr, 0, TblSize * sizeof(COMPRESS_HDR));
|
|
|
|
//
|
|
// Allocate buffer of size TblSize for Compression 2 table.
|
|
//
|
|
if ((pSTbl->pCompress2Tbl =
|
|
(PCOMPRESS_2_TBL)malloc( TblSize *
|
|
sizeof(PCOMPRESS_2_NODE) )) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer for Compression 2 table.\n");
|
|
return (1);
|
|
}
|
|
memset(pSTbl->pCompress2Tbl, 0, TblSize * sizeof(PCOMPRESS_2_NODE));
|
|
|
|
//
|
|
// Allocate buffer of size TblSize for Compression 3 table.
|
|
//
|
|
if ((pSTbl->pCompress3Tbl =
|
|
(PCOMPRESS_3_TBL)malloc( TblSize *
|
|
sizeof(PCOMPRESS_3_NODE) )) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer for Compression 3 table.\n");
|
|
return (1);
|
|
}
|
|
memset(pSTbl->pCompress3Tbl, 0, TblSize * sizeof(PCOMPRESS_3_NODE));
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// AllocateCompression2Nodes
|
|
//
|
|
// This routine allocates the compression 2 nodes for the compression table.
|
|
// The size of the table is determined by the TblSize parameter. The
|
|
// pointer to the nodes is stored in the compression table at the Index
|
|
// given.
|
|
//
|
|
// 11-04-92 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int AllocateCompression2Nodes(
|
|
PSORT_TABLES pSTbl,
|
|
int TblSize,
|
|
int Index)
|
|
{
|
|
PCOMPRESS_2_NODE pCompNode; // ptr to compression 2 node
|
|
|
|
|
|
//
|
|
// Allocate buffer of size TblSize for Compression nodes.
|
|
//
|
|
if ((pCompNode =
|
|
(PCOMPRESS_2_NODE)malloc( TblSize *
|
|
sizeof(COMPRESS_2_NODE) )) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer for Compression 2 Nodes.\n");
|
|
return (1);
|
|
}
|
|
memset(pCompNode, 0, TblSize * sizeof(COMPRESS_2_NODE));
|
|
|
|
//
|
|
// Set pointer in compression 2 table.
|
|
//
|
|
(pSTbl->pCompress2Tbl)[Index] = pCompNode;
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// AllocateCompression3Nodes
|
|
//
|
|
// This routine allocates the compression 3 nodes for the compression table.
|
|
// The size of the table is determined by the TblSize parameter. The
|
|
// pointer to the nodes is stored in the compression table at the Index
|
|
// given.
|
|
//
|
|
// 11-04-92 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int AllocateCompression3Nodes(
|
|
PSORT_TABLES pSTbl,
|
|
int TblSize,
|
|
int Index)
|
|
{
|
|
PCOMPRESS_3_NODE pCompNode; // ptr to compression 3 node
|
|
|
|
|
|
//
|
|
// Allocate buffer of size TblSize for Compression nodes.
|
|
//
|
|
if ((pCompNode =
|
|
(PCOMPRESS_3_NODE)malloc( TblSize *
|
|
sizeof(COMPRESS_3_NODE) )) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer for Compression 3 Nodes.\n");
|
|
return (1);
|
|
}
|
|
memset(pCompNode, 0, TblSize * sizeof(COMPRESS_3_NODE));
|
|
|
|
//
|
|
// Set pointer in compression 3 table.
|
|
//
|
|
(pSTbl->pCompress3Tbl)[Index] = pCompNode;
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// AllocateException
|
|
//
|
|
// This routine allocates the exception header and the exception table.
|
|
// The size of the table is determined by the TblSize parameter. The
|
|
// pointer to the header and the table are stored in the sorttables
|
|
// structure.
|
|
//
|
|
// 11-04-92 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int AllocateException(
|
|
PSORT_TABLES pSTbl,
|
|
int TblSize)
|
|
{
|
|
//
|
|
// Set the number of Exception entries in table.
|
|
//
|
|
pSTbl->NumException = TblSize;
|
|
|
|
//
|
|
// Allocate buffer of size TblSize for Exception header.
|
|
//
|
|
if ((pSTbl->pExceptHdr =
|
|
(PEXCEPT_HDR)malloc(TblSize * sizeof(EXCEPT_HDR))) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer for Exception Header.\n");
|
|
return (1);
|
|
}
|
|
memset(pSTbl->pExceptHdr, 0, TblSize * sizeof(EXCEPT_HDR));
|
|
|
|
//
|
|
// Allocate buffer of size TblSize for Exception table.
|
|
//
|
|
if ((pSTbl->pExceptTbl =
|
|
(PEXCEPT_TBL)malloc(TblSize * sizeof(PEXCEPT_NODE))) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer for Exception table.\n");
|
|
return (1);
|
|
}
|
|
memset(pSTbl->pExceptTbl, 0, TblSize * sizeof(PEXCEPT_NODE));
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// AllocateExceptionNodes
|
|
//
|
|
// This routine allocates the exception nodes for the exception table.
|
|
// The size of the table is determined by the TblSize parameter. The
|
|
// pointer to the nodes is stored in the exception table at the Index
|
|
// given.
|
|
//
|
|
// 11-04-92 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int AllocateExceptionNodes(
|
|
PSORT_TABLES pSTbl,
|
|
int TblSize,
|
|
int Index)
|
|
{
|
|
PEXCEPT_NODE pExcNode; // ptr to exception node
|
|
|
|
|
|
//
|
|
// Allocate buffer of size TblSize for Exception nodes.
|
|
//
|
|
if ((pExcNode = (PEXCEPT_NODE)malloc( TblSize *
|
|
sizeof(EXCEPT_NODE) )) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer for Exception Nodes.\n");
|
|
return (1);
|
|
}
|
|
memset(pExcNode, 0, TblSize * sizeof(EXCEPT_NODE));
|
|
|
|
//
|
|
// Set pointer in exception table.
|
|
//
|
|
(pSTbl->pExceptTbl)[Index] = pExcNode;
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// AllocateMultipleWeights
|
|
//
|
|
// This routine allocates the multiple weights table. The size of
|
|
// the table is determined by the TblSize parameter. The pointer to the
|
|
// new table is stored in the sorttables structure.
|
|
//
|
|
// 11-04-92 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int AllocateMultipleWeights(
|
|
PSORT_TABLES pSTbl,
|
|
int TblSize)
|
|
{
|
|
//
|
|
// Allocate buffer of size TblSize for Multiple Weights table.
|
|
//
|
|
if ((pSTbl->pMultiWeight = (PMULTI_WT)malloc( TblSize *
|
|
sizeof(MULTI_WT) )) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer for Multiple Weight table.\n");
|
|
return (1);
|
|
}
|
|
memset(pSTbl->pMultiWeight, 0, TblSize * sizeof(MULTI_WT));
|
|
|
|
//
|
|
// Set the number of Multiple Weight entries in table.
|
|
//
|
|
pSTbl->NumMultiWeight = TblSize;
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// AllocateIdeographExceptions
|
|
//
|
|
// This routine allocates the ideograph exception table. The size of
|
|
// the table is determined by the TblSize parameter. The pointer to the
|
|
// new table is stored in the ideograph exception structure.
|
|
//
|
|
// 09-01-93 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int AllocateIdeographExceptions(
|
|
PIDEOGRAPH_EXCEPT pIdeograph,
|
|
int TblSize,
|
|
int NumColumns)
|
|
{
|
|
//
|
|
// Allocate buffer of size TblSize for Ideograph Exception table.
|
|
//
|
|
if (NumColumns == 2)
|
|
{
|
|
if ((pIdeograph->pExcept =
|
|
(PIDEOGRAPH_NODE)malloc( TblSize *
|
|
sizeof(IDEOGRAPH_NODE) )) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer for Ideograph Exception table.\n");
|
|
return (1);
|
|
}
|
|
memset(pIdeograph->pExcept, 0, TblSize * sizeof(IDEOGRAPH_NODE));
|
|
|
|
pIdeograph->pExceptEx = NULL;
|
|
}
|
|
else if (NumColumns == 4)
|
|
{
|
|
if ((pIdeograph->pExceptEx =
|
|
(PIDEOGRAPH_NODE_EX)malloc( TblSize *
|
|
sizeof(IDEOGRAPH_NODE_EX) )) == NULL)
|
|
{
|
|
printf("Error: Can't allocate buffer for Ideograph Exception table.\n");
|
|
return (1);
|
|
}
|
|
memset(pIdeograph->pExceptEx, 0, TblSize * sizeof(IDEOGRAPH_NODE_EX));
|
|
|
|
pIdeograph->pExcept = NULL;
|
|
}
|
|
else
|
|
{
|
|
printf("Parse Error: The Number of Columns must be either 2 or 4.\n");
|
|
return (1);
|
|
}
|
|
|
|
//
|
|
// Set the number of ideograph exception entries in table.
|
|
//
|
|
pIdeograph->NumEntries = TblSize;
|
|
pIdeograph->NumColumns = NumColumns;
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Free844
|
|
//
|
|
// This routine frees the memory used by an 8:4:4 table pointed to by pArr.
|
|
//
|
|
// 07-30-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
void Free844(
|
|
P844_ARRAY pArr)
|
|
{
|
|
int Ctr1, Ctr2; // loop counters
|
|
P844_ARRAY pArr2; // ptr to second arrays
|
|
|
|
|
|
if (pArr != NULL)
|
|
{
|
|
for (Ctr1 = 0; Ctr1 < TABLE_SIZE_8; Ctr1++)
|
|
{
|
|
if ((pArr2 = (P844_ARRAY)(pArr[Ctr1])) != NULL)
|
|
{
|
|
for (Ctr2 = 0; Ctr2 < TABLE_SIZE_4; Ctr2++)
|
|
{
|
|
if (pArr2[Ctr2] != NULL)
|
|
{
|
|
free(pArr2[Ctr2]);
|
|
}
|
|
}
|
|
free(pArr2);
|
|
}
|
|
}
|
|
free(pArr);
|
|
}
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// FreeCTMap
|
|
//
|
|
// This routine frees the memory used by the ctype mapping table pointed
|
|
// to by pMap.
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
void FreeCTMap(
|
|
PCT_MAP pMap)
|
|
{
|
|
if (pMap != NULL)
|
|
{
|
|
free(pMap->pCTValues);
|
|
free(pMap);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
//-------------------------------------------------------------------------//
|
|
// INTERNAL ROUTINES //
|
|
//-------------------------------------------------------------------------//
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// MapTrioToByte
|
|
//
|
|
// This routine searches through the mapping table for the given CType trio.
|
|
// If it already exists, the entry value is returned. Otherwise, it adds
|
|
// the new trio to the mapping table and returns the new entry value.
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
CT_MAP_VALUE MapTrioToByte(
|
|
PCT_MAP pMap,
|
|
WORD Value1,
|
|
WORD Value2,
|
|
WORD Value3)
|
|
{
|
|
PCT_VALUES pEntry; // ptr to entry
|
|
CT_MAP_VALUE EntryNum; // entry number
|
|
int Ctr; // loop counter
|
|
|
|
|
|
//
|
|
// Search through the current entries to see if the ctype trio
|
|
// already exists.
|
|
//
|
|
for (Ctr = 0; Ctr < pMap->Length; Ctr++)
|
|
{
|
|
//
|
|
// Check the entry.
|
|
//
|
|
if ( ((pMap->pCTValues[Ctr]).CType1 == Value1) &&
|
|
((pMap->pCTValues[Ctr]).CType2 == Value2) &&
|
|
((pMap->pCTValues[Ctr]).CType3 == Value3) )
|
|
{
|
|
//
|
|
// Entry already exists. Return the entry number.
|
|
//
|
|
if (Verbose)
|
|
printf("Mapping Entry %d:\tCT1 = %x\tCT2 = %x\tCT3 = %x\n",
|
|
Ctr, Value1, Value2, Value3);
|
|
|
|
return (Ctr);
|
|
}
|
|
}
|
|
|
|
//
|
|
// The given CType trio does not yet exist in the table.
|
|
// Add the new trio entry to the table and increment the
|
|
// total number of entries.
|
|
//
|
|
pEntry = &(pMap->pCTValues[pMap->Length]);
|
|
pEntry->CType1 = Value1;
|
|
pEntry->CType2 = Value2;
|
|
pEntry->CType3 = Value3;
|
|
|
|
EntryNum = (CT_MAP_VALUE)(pMap->Length);
|
|
|
|
pMap->Length++;
|
|
|
|
if (Verbose)
|
|
printf("Mapping New Entry %d:\tCT1 = %x\tCT2 = %x\tCT3 = %x\n",
|
|
EntryNum, Value1, Value2, Value3);
|
|
|
|
//
|
|
// Return the new entry number.
|
|
//
|
|
return (EntryNum);
|
|
}
|
|
|
|
|