archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-xp/Source/XPSP1/NT/shell/osshell/fontfldr/ole2map/pan1ptbl.c

1382 lines
43 KiB
Raw Permalink Blame History

/***************************************************************************
* PAN1PTBL.C - ElseWare PANOSE(tm) Font Mapper penalty database.
*
* $keywords: pan1ptbl.c 1.9 15-Apr-94 3:53:54 PM$
*
* This is a stand-alone program that writes a 'C' style header file
* containing the penalty tables for the font mapper. The tables are
* in MEMORY format, e.g., they use Intel or Motorola byte ordering
* depending on the platform upon which the program is compiled.
*
* This program should accompany ELSEPAN.C, the ElseWare PANOSE Mapper
* source code, which assumes the output from this program is in a file
* named PAN1PTBL.H.
*
* The command-line is as follows:
*
* pan1ptbl [-b] [-v] [-l] [-d] <in-filename> <out-filename>
*
* where:
*
* -b means produce a binary file (instead of a 'C' struct)
* -v means get from and put to version control
* -l means precede the struct with the keyword FAR
* -d means dump the database to the screen
* <in-filename> is the name of the text file containing the
* penalty database (PAN1PTBL.TXT)
* <out-filename> is the name of the output file (PAN1PTBL.H)
*
* The '-b' switch causes the MEMORY representation of the struct to be
* dumped to file (in binary form). The normal behavior (no '-b' switch)
* is to produce a text file containing a C-style declaration of the
* struct.
*
* The '-v' switch presumes the user has Sorcerer's Apprentice, and causes
* a 'vout' of pan1ptbl.h followed by a 'vin' of the newly generated file.
* Notice that Sorcerer's Apprentice ignores the transaction if the file
* is not different from the previous revision.
*
* The '-l' switch causes the database to be declared 'FAR,' which in
* DOS and Windows large model programs causes the data structure to be
* placed in its own data segment.
*
* The '-d' switch causes a textual description of the database to be
* dumped to stdout for debugging purposes.
*
* Copyright (C) 1991-93 ElseWare Corporation. All rights reserved.
***************************************************************************/
#define ELSE_MAPPER_CORE
#define NOELSEPANDATA
#include "elsepan.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#ifdef MACINTOSH
#include "osutils.h"
#endif /* MACINTOSH */
#ifdef MACINTOSH
# define SZ_DATABASE "DATABASE"
# define SZ_TABLE "TABLE"
# define PT_strupr(p) uprstring((p), FALSE)
BOOL PT_strcmpi(char *s, char *t) {
uprstring(s, FALSE);
return strcmp(s, t);
}
#else /* WINDOWS */
# define SZ_DATABASE TEXT("Database")
# define SZ_TABLE TEXT("Table")
# define PT_strupr(p) _strupr(p)
# define PT_strcmpi(s, t) _strcmpi(s, t)
#endif
static EW_BOOL bReadDB(FILE *fpin, EW_BOOL bBuildIt);
static EW_BOOL bReadPTbl(FILE *fpin, EW_BOOL bBuildIt,
EW_BOOL bExpectSquare, char *pLnBuf, int iBufSize,
EW_PTBL_MEM *pPTbl, EW_BYTE *pDataBuf);
static int iGetCompressKind(EW_BYTE *pDataBuf,
int iRow, int iCol, int iNoFit);
static EW_BOOL bAddUniqueTable(EW_PTBL_MEM *pPTbl, int iSize);
static int iReadData(FILE *fpin, char *pLnBuf, int iBufSize,
EW_BYTE *pDataBuf);
static EW_BOOL bGetLine(char *pBuf, int iLen, FILE *fpin);
static void vShowDB(void);
static EW_BOOL bShowDupTbl(EW_PTBL_MEM *pPTbl);
static EW_BYTE s_buf[8192];
static EW_USHORT s_unOffs;
static int s_iLnPos;
/***************************************************************************
* FUNCTION: main
*
* PURPOSE: Write the file PAN1PTBL.H, which is a 'C'-style .H file
* containing the declaration of the memory copy of the
* penalty database.
*
* RETURNS: The program returns 0 if it succeeds, 1 if there is a failure.
***************************************************************************/
int main (
int argc,
char *argv[])
{
int i;
int j;
int iRet = 1;
EW_BOOL bDumpBin = FALSE;
EW_BOOL bDoVCS = FALSE;
EW_BOOL bMakeFar = FALSE;
EW_BOOL bShowDB = FALSE;
time_t ltime;
EW_PDICT_MEM *pHead = (EW_PDICT_MEM *)s_buf;
FILE *fpin;
FILE *fpout;
char *p;
char *pszInFileNm;
char *pszOutFileNm;
char szIncNm[64];
char szTime[64];
printf("ElseWare Penalty Table Maker v1.2\n");
/* Display 'usage' message if the minimum number of parameters
* was not recieved.
*/
if( argc < 3 ) {
printf("Usage: pan1ptbl [-b] [-v] [-l] [-d] <infile> <outfile>\n");
printf(" -b means dump in binary form (not C-struct)\n");
printf(" -v means get from and put to version control\n");
printf(" -l means precede the struct with the keyword FAR\n");
printf(" -d dump the database to the screen\n");
printf(" <infile> is the text penalty database (PAN1PTBL.TXT)\n");
printf(" <outfile> is the output file (PAN1PTBL.H)\n");
goto backout0;
}
/* Set flags.
*/
for( p = argv[i = 1]; i < (argc - 2 ); p = argv[++i]) {
if( p[0] != '-' ) {
printf("Expected command line flag at '%s,' pan1ptbl aborted.\n", p);
goto backout0;
}
switch( p[1] ) {
case 'b':
case 'B':
bDumpBin = TRUE;
break;
case 'v':
case 'V':
bDoVCS = TRUE;
break;
case 'l':
case 'L':
bMakeFar = TRUE;
break;
case 'd':
case 'D':
bShowDB = TRUE;
break;
default:
printf("Unrecognized command line flag '%s' ignored.\n", p);
break;
}
}
/* Make sure the last few params are not flags (should be
* file names).
*/
if( *p == '-' ) {
printf("Expected input file name at '%s,' pan1ptbl ignored.\n", p);
goto backout0;
}
PT_strupr(pszInFileNm = p);
p = argv[argc - 1];
if( *p == '-' ) {
printf("Expected output file name at '%s,' pan1ptbl ignored.\n", p);
goto backout0;
}
PT_strupr(pszOutFileNm = p);
/* Extract the file from version control if we're supposed to
* do that (Sorcerer's Apprentice is assumed).
*/
if( bDoVCS ) {
#ifdef WINDOWS
char cmd[128];
sprintf(cmd, "vout %s", pszOutFileNm);
if( system(cmd ) != 0) {
printf("Failed to get %s from version control, pan1ptbl aborted.\n",
pszOutFileNm);
goto backout0;
}
#endif /* WINDOWS */
#ifdef MACINTOSH
printf("VCS mode not valid on the Macintosh. Continuing anyway...\n");
#endif /* MACINTOSH */
}
/* Open the input file.
*/
if( !(fpin = fopen(pszInFileNm, "rt" ))) {
printf("Could not open input file %s, pan1ptbl aborted.\n",
pszInFileNm);
goto backout0;
}
/* Create the output file.
*/
if( bDumpBin ) {
fpout = fopen(pszOutFileNm, "wb");
} else {
fpout = fopen(pszOutFileNm, "wt");
}
if( !fpout ) {
printf("Could not open output file %s, pan1ptbl aborted.\n",
pszOutFileNm);
if( bDoVCS ) {
#ifdef WINDOWS
char cmd[128];
sprintf(cmd, "vadmin u %s", pszOutFileNm);
if( system(cmd ) != 0) {
printf("Failed to unlock %s from version control.\n",
pszOutFileNm);
}
#endif /* WINDOWS */
}
goto backout1;
}
/* Build the database.
*/
s_iLnPos = 0;
if( !bReadDB(fpin, FALSE )) {
goto backout2;
}
rewind(fpin);
s_iLnPos = 0;
if( !bReadDB(fpin, TRUE )) {
goto backout2;
}
printf("%s: %u bytes in database.\n", pszOutFileNm, pHead->unSizeDB);
if( bShowDB ) {
vShowDB();
}
/* If we're writing binary, then dump it now and exit.
*/
if( bDumpBin ) {
fwrite(s_buf, pHead->unSizeDB, 1, fpout);
goto webedun;
}
/* 'C' header write.
*
* Write the file containing the 'C' structure that defines
* the penalty database.
*/
if( time(&ltime )) {
strcpy(szTime, asctime(localtime(&ltime)));
szTime[strlen(szTime) - 1] = '\0';
} else {
szTime[0] = '\0';
}
strcpy(szIncNm, "__");
if( (p = strrchr(pszOutFileNm, '\\' )) ||
( p = strrchr(pszOutFileNm, ':' ))) {
strcat(szIncNm, &p[1]);
} else {
strcat(szIncNm, pszOutFileNm);
}
if( p = strchr(szIncNm, '.' )) {
*p = '_';
}
strcat(szIncNm, "__");
if( bDoVCS ) {
fprintf(fpout,
"/*\044change:Updated by PAN1PTBL.EXE on %s.\044*/\n", szTime);
}
fprintf(fpout,
"/***************************************************************************\n");
fprintf(fpout,
" * %s - ElseWare PANOSE(tm) default penalty tables.\n", pszOutFileNm);
fprintf(fpout,
" *\n");
if( bDoVCS ) {
fprintf(fpout,
" * $keywords: pan1ptbl.c 1.9 15-Apr-94 3:53:54 PM$\n");
fprintf(fpout,
" *\n");
}
fprintf(fpout,
" * This file was generated by PAN1PTBL.EXE.\n");
fprintf(fpout,
" *\n");
fprintf(fpout,
" * This file contains the penalty tables for the PANOSE 1.0 font\n");
fprintf(fpout,
" * mapper. It was generated from the file %s.\n", pszInFileNm);
fprintf(fpout,
" *\n");
fprintf(fpout,
" * Penalty database structure version %x.%02x.\n",
PANOSE_PENALTY_VERS / 0x100,
PANOSE_PENALTY_VERS % 0x100);
fprintf(fpout,
" *\n");
if( !bDoVCS ) {
fprintf(fpout,
" * File created %s.\n", szTime);
fprintf(fpout,
" *\n");
}
fprintf(fpout,
" * Copyright( C ) 1992-93 ElseWare Corporation. All rights reserved.\n");
fprintf(fpout,
" ***************************************************************************/\n");
fprintf(fpout,
"\n");
fprintf(fpout,
"#ifndef %s\n", szIncNm);
fprintf(fpout,
"#define %s\n", szIncNm);
fprintf(fpout,
"\n");
fprintf(fpout,
"/***************************************************************************\n");
fprintf(fpout,
" * PENALTY DATABASE\n");
fprintf(fpout,
" *\n");
fprintf(fpout,
" * Below is the default penalty database for the PANOSE font\n");
fprintf(fpout,
" * mapper. It is in the MEMORY format.\n");
fprintf(fpout,
" *\n");
fprintf(fpout,
" * Look at PAN1PTBL.C to see how this is created.\n");
fprintf(fpout,
" ***************************************************************************/\n");
if( bMakeFar ) {
fprintf(fpout,
"EW_BYTE FAR s_panDB[] = {");
} else {
fprintf(fpout,
"EW_BYTE s_panDB[] = {");
}
for( i = 1, p = s_buf; i < (int )pHead->unSizeDB; ) {
fprintf(fpout, "\n ");
for( j = 0; (i < (int )pHead->unSizeDB) &&( j < 10 );
++i, ++j, ++p) {
fprintf(fpout, " 0x%02x,",( EW_BYTE )*p);
}
}
if( j == 10 ) {
fprintf(fpout, "\n ");
}
fprintf(fpout,
" 0x%02x\n};\n",( EW_BYTE )*p);
fprintf(fpout,
"\n");
fprintf(fpout,
"#endif /* ifndef %s */\n", szIncNm);
if( bDoVCS ) {
fprintf(fpout,
"\n");
fprintf(fpout,
"/***************************************************************************\n");
fprintf(fpout,
" * Revision log:\n");
fprintf(fpout,
" ***************************************************************************/\n");
fprintf(fpout,
"/*\n");
fprintf(fpout,
" * \044log\044\n");
fprintf(fpout,
" */\n");
}
webedun:
fclose(fpout);
fpout = NULL;
/* Return the file to version control.
*/
if( bDoVCS ) {
#ifdef WINDOWS
char cmd[128];
sprintf(cmd, "vin -c\"File updated by PAN1PTBL.EXE %s\" %s",
szTime, pszOutFileNm);
if( system(cmd ) != 0) {
printf("Failed to put %s into version control.\n", pszOutFileNm);
}
#endif /* WINDOWS */
}
iRet = 0;
goto backout1;
backout2:
fclose(fpout);
backout1:
fclose(fpin);
backout0:
return( iRet );
}
/***************************************************************************
* FUNCTION: bReadDB
*
* PURPOSE: Read the text penalty database. This routine is called twice:
* once to gather statistics, and then a second time to fill in
* everything else.
*
* RETURNS: The function returns TRUE if parses the whole file without
* detecting errors.
***************************************************************************/
static EW_BOOL bReadDB(
FILE *fpin,
EW_BOOL bBuildIt)
{
int i;
int j;
int w;
int iNumTbl;
EW_BOOL bUseAtoB;
EW_PDICT_MEM *pHead =( EW_PDICT_MEM * )s_buf;
EW_PIND_MEM *pInd = pHead->pind;
EW_BYTE *pWt = NULL;
EW_ATOB_MEM *pAtoB = NULL;
EW_ATOB_ITEM_MEM *pAtoBItem = NULL;
EW_PTBL_MEM *pPTbl = NULL;
char szBuf[256];
char szKey[128];
/* First pass: init header. On the second pass it contains
* the count of dictionaries in the database.
*/
if( bBuildIt ) {
s_unOffs = sizeof(EW_PDICT_MEM) +
( sizeof(EW_PIND_MEM ) *( pHead->unNumDicts - 1 ));
} else {
pHead->unVersion = PANOSE_PENALTY_VERS;
pHead->unByteOrder = PTBL_BYTE_ORDER;
pHead->unNumDicts = 0;
pHead->unSizeDB = 0;
s_unOffs = sizeof(EW_PDICT_MEM);
}
/* Get the first line.
*/
if( !bGetLine(szBuf, sizeof(szBuf ), fpin)) {
printf("No data found in the input file, pan1ptbl aborted.\n");
return( FALSE );
}
/* For each database.
*
* Look for [ Database ]
*/
while( (sscanf(szBuf, "[ %s ]", szKey ) == 1) &&
( PT_strcmpi(szKey, "Database" ) == 0)) {
/* Init vars.
*/
iNumTbl = 0;
bUseAtoB = FALSE;
pWt = NULL;
pAtoB = NULL;
pAtoBItem = NULL;
pPTbl = NULL;
/* If we're really building then set up the vars
* to recieve the tables.
*/
if( bBuildIt ) {
/* The weight array is always exactly 10 bytes long,
* initialized to all zeroes. The first byte contains
* the weight for the family digit, which does not
* have a penalty table associated with it.
*/
pWt = &s_buf[s_unOffs];
pInd->unOffsWts = s_unOffs;
memset(pWt, 0, j =( sizeof(EW_BYTE ) * NUM_PAN_DIGITS));
++pWt;
s_unOffs += j;
/* For the A-to-B remapping array, the offset
* variable in the index contains the count of
* items from the first pass. Use that to set
* up the array.
*/
if( pInd->unOffsAtoB > 0 ) {
pAtoB =( EW_ATOB_MEM * )&s_buf[s_unOffs];
pAtoBItem = pAtoB->AtoBItem;
i = pInd->unOffsAtoB;
pInd->unOffsAtoB = s_unOffs;
memset((char *)pAtoB, 0, j =( sizeof(EW_ATOB_MEM ) +
( sizeof(EW_ATOB_ITEM_MEM ) *( i - 1 ))));
pAtoB->unNumAtoB = i;
s_unOffs += j;
} else {
i = NUM_PAN_DIGITS - 1;
}
/* Set up penalty table pointer.
*/
pPTbl =( EW_PTBL_MEM * )&s_buf[s_unOffs];
pInd->unOffsPTbl = s_unOffs;
memset((char *)pPTbl, 0, j =( sizeof(EW_PTBL_MEM ) * i));
s_unOffs += j;
} else {
pInd->jFamilyA = 0;
pInd->jFamilyB = 0;
pInd->jDefAnyPenalty = 0;
pInd->jDefNoFitPenalty = 10;
pInd->jDefMatchPenalty = 0;
pInd->jReserved = 0;
pInd->unOffsWts = 0;
pInd->unOffsAtoB = 0;
pInd->unOffsPTbl = 0;
}
/* Look for row = <PANOSE-family-digit-for-row>
*/
if( !bGetLine(szBuf, sizeof(szBuf ), fpin) ||
( sscanf(szBuf, "row = %d", &i ) != 1)) {
printf("%d: Expected 'row' statement, pan1ptbl aborted.\n",
s_iLnPos);
return( FALSE );
}
if( (i < PANOSE_NOFIT ) ||( i > MAX_PAN1_FAMILY )) {
printf("%d: Row PANOSE digit out of range, pan1ptbl aborted.\n",
s_iLnPos);
return( FALSE );
}
pInd->jFamilyA = i;
/* Look for col = <PANOSE-family-digit-for-column>
*/
if( !bGetLine(szBuf, sizeof(szBuf ), fpin) ||
( sscanf(szBuf, "col = %d", &i ) != 1)) {
printf("%d: Expected 'col' statement, pan1ptbl aborted.\n",
s_iLnPos);
return( FALSE );
}
if( (i < PANOSE_NOFIT ) ||( i > MAX_PAN1_FAMILY )) {
printf("%d: Column PANOSE digit out of range, pan1ptbl aborted.\n",
s_iLnPos);
return( FALSE );
}
pInd->jFamilyB = i;
/* Read in a table heading:
*
* [ Table : <ind-row> : <ind-col> : <default-weight> ]
*/
if( !bGetLine(szBuf, sizeof(szBuf ), fpin)) {
printf("%d: Expected penalty table after database header, pan1ptbl aborted.\n",
s_iLnPos);
return( FALSE );
}
/* For each table.
*/
while ((sscanf(szBuf, "[ %s : %d : %d : %d ]",
szKey, &i, &j, &w) == 4) &&( PT_strcmpi(szKey, "Table" ) == 0)) {
/* Make sure indices in range.
*/
if( (i <= 0 ) ||( j <= 0 ) ||
( i >= NUM_PAN_DIGITS ) ||( j >= NUM_PAN_DIGITS )) {
printf("%d: Digit index out of range, pan1ptbl aborted.\n",
s_iLnPos);
return( FALSE );
}
/* Test non-zero weight.
*/
if( !w && !bBuildIt ) {
printf("%d: Warning: Weight value of zero.\n", s_iLnPos);
}
/* Detect need for A-to-B remapping array. This happens
* when the row-ind != col-ind or when the inds do not
* count from 1 to 9.
*/
if( (i != j ) ||( i != (iNumTbl + 1 ))) {
bUseAtoB = TRUE;
}
/* Attempt to read the table.
*
* This routine bumps s_unOffs.
*/
if (!bReadPTbl(fpin, bBuildIt,
( EW_BOOL )((i == j) &&( pInd->jFamilyA == pInd->jFamilyB )),
szBuf, sizeof(szBuf), pPTbl, &s_buf[s_unOffs])) {
return( FALSE );
}
/* Pick up default weight value and A-to-B settings.
*/
if( bBuildIt ) {
*pWt++ = w;
if( pAtoBItem ) {
pAtoBItem->jAttrA = i;
pAtoBItem->jAttrB = j;
{
EW_ATOB_ITEM_MEM *pAtoBCmp = pAtoB->AtoBItem;
for( ; pAtoBCmp < pAtoBItem; ++pAtoBCmp ) {
if( (pAtoBCmp->jAttrA == pAtoBItem->jAttrA ) &&
( pAtoBCmp->jAttrB == pAtoBItem->jAttrB )) {
printf("%u: Row & col pair used in a previous table, pan1ptbl aborted.\n",
s_iLnPos);
return( FALSE );
}
}
}
++pAtoBItem;
}
++pPTbl;
}
++iNumTbl;
}
/* End of dictionary handling.
*/
if( !iNumTbl ) {
printf("%d: Expected penalty table header, pan1ptbl aborted.\n",
s_iLnPos);
return( FALSE );
}
/* Verify count of tables: there should be exactly 9 without
* an A-to-B remapping array.
*/
if( bUseAtoB ) {
if( bBuildIt ) {
if( iNumTbl != (int )pAtoB->unNumAtoB) {
printf("%d: Second-pass: Error in AtoB count.\n", s_iLnPos);
return( FALSE );
}
} else if( iNumTbl > (NUM_PAN_DIGITS - 1 )) {
printf("%d: Cannot have more that %u tables, pan1ptbl aborted.\n",
s_iLnPos,( int )(NUM_PAN_DIGITS - 1));
return( FALSE );
} else {
/* Save the count of tables here for second pass.
*/
pInd->unOffsAtoB = iNumTbl;
}
} else if( iNumTbl != (NUM_PAN_DIGITS - 1 )) {
printf("%d: Expected exactly %d tables, pan1ptbl aborted.\n",
s_iLnPos,( int )(NUM_PAN_DIGITS - 1));
return( FALSE );
}
/* Bump count of dictionaries, as we successfully read one.
*/
if( !bBuildIt ) {
++pHead->unNumDicts;
s_unOffs += sizeof(EW_PIND_MEM);
}
++pInd;
}
if( !pHead->unNumDicts ) {
printf("No penalty dictionaries found, pan1ptbl aborted.\n");
return( FALSE );
}
if( bBuildIt ) {
pHead->unSizeDB = s_unOffs;
}
return( TRUE );
}
/***************************************************************************
* FUNCTION: bReadPTbl
*
* PURPOSE: Read, validate, and compress a table.
*
* RETURNS: The function returns TRUE if it succesfully processes the
* table, FALSE if it does not.
***************************************************************************/
static EW_BOOL bReadPTbl(
FILE *fpin,
EW_BOOL bBuildIt,
EW_BOOL bExpectSquare,
char *pLnBuf,
int iBufSize,
EW_PTBL_MEM *pPTbl,
EW_BYTE *pDataBuf)
{
int i;
int j;
int k;
int iNoFit;
int iCol;
int iRow;
*pDataBuf = 0;
/* Read in the data table.
*
* First line is the column headings.
*/
if( !(iCol = iReadData(fpin, pLnBuf, iBufSize, &pDataBuf[1] ))) {
printf("%d: Expected table data, pan1ptbl aborted.\n", s_iLnPos);
return( FALSE );
}
++iCol;
/* Read the remaining rows, watching for the same number of columns.
*/
for (iRow = 1; (i = iReadData(fpin, pLnBuf, iBufSize,
&pDataBuf[iRow * iCol]));
++iRow) {
if( i != iCol ) {
printf("%d: Inconsistent number of columns, pan1ptbl aborted.\n",
s_iLnPos);
return( FALSE );
}
}
/* Test for table too small.
*/
if( (iRow < 5 ) ||( iCol < 5 )) {
printf("%d: The table is too small, pan1ptbl aborted.\n", s_iLnPos);
return( FALSE );
}
/* Look for a square table.
*/
if( bExpectSquare && (iRow != iCol )) {
printf("%d: Expected a square table( #row = #col ), pan1ptbl aborted.\n",
s_iLnPos);
return( FALSE );
}
/* Test 'any' penalties. They should all equal zero.
*/
for (i = 1, j = iCol;
( i < j ) &&( (i == 2 ) ||( pDataBuf[iCol + i] == 0 ));
++i)
;
if( i >= j ) {
for (i = 1, j = iRow;
( i < j ) &&( (i == 2 ) ||( pDataBuf[(iCol * i ) + 1] == 0));
++i)
;
}
if( i < j ) {
printf("%d: All 'any' penalties should be zero, pan1ptbl aborted.\n",
s_iLnPos);
return( FALSE );
}
/* Test 'no-fit' penalties. They should all have the same value.
*/
iNoFit = pDataBuf[iCol + 2];
for (i = 1, j = iCol;
( i < j ) &&( pDataBuf[(iCol * 2 ) + i] ==( EW_BYTE )iNoFit);
++i)
;
if( i >= j ) {
for (i = 1, j = iRow;
( i < j ) &&( pDataBuf[(iCol * i ) + 2] ==( EW_BYTE )iNoFit);
++i)
;
}
if( i < j ) {
printf("%d: All 'no-fit' penalties should match, pan1ptbl aborted.\n",
s_iLnPos);
return( FALSE );
}
/* If we're just scanning, then we're done collecting info.
*/
if( !bBuildIt || !pPTbl ) {
return( TRUE );
}
/* Init table.
*/
pPTbl->jRangeLast =( (iRow > iCol ) ? iRow : iCol) - 2;
pPTbl->unOffsTbl = 0;
pPTbl->unTblSize = 0;
k = 0;
/* Determine the compression type, and then copy the table
* based upon the type.
*/
switch (pPTbl->jCompress =
( EW_BYTE )iGetCompressKind(pDataBuf, iRow, iCol, iNoFit)) {
case PAN_COMPRESS_C0:
/* C0 compression: suck in the whole table except
* the any and no-fit values. This table is preceded
* by a header containing the row and column dimensions.
*/
{
EW_PTBL_C0_MEM *pPC0 =( EW_PTBL_C0_MEM * )&pDataBuf[k];
pPC0->jARangeLast =( EW_BYTE )iRow - 2;
pPC0->jBRangeLast =( EW_BYTE )iCol - 2;
pPC0->jReserved = 0;
k +=( sizeof(EW_PTBL_C0_MEM ) - sizeof(EW_BYTE));
}
for( i = 3; i < iRow; ++i ) {
for( j = 3; j < iCol; ++j, ++k ) {
pDataBuf[k] = pDataBuf[(i * iCol) + j];
}
}
bAddUniqueTable(pPTbl, k);
break;
case PAN_COMPRESS_C1:
/* C1 compression: perfectly symmetrical table with
* penalties increasing the further they are away
* from the diagonal. No additional data stored.
*/
break;
case PAN_COMPRESS_C3:
/* C3 compression: same as C2 compression except the
* first byte is the no-fit penalty.
*/
pDataBuf[k++] = iNoFit;
case PAN_COMPRESS_C2:
/* C2 compression: symmetrical about the diagonal,
* suck in the lower left corner.
*/
for( i = 4; i < iRow; ++i ) {
for( j = 3; j < i; ++j, ++k ) {
pDataBuf[k] = pDataBuf[(i * iCol) + j];
}
}
bAddUniqueTable(pPTbl, k);
break;
case PAN_COMPRESS_C4:
/* C4 compression: similar to C1, except the start
* and increment values are specified.
*/
{
EW_PTBL_C4_MEM *pPC4 =( EW_PTBL_C4_MEM * )&pDataBuf[k];
pPC4->jStart = pDataBuf[(iCol * 4) + 3];
pPC4->jIncrement = pDataBuf[(iCol * 5) + 3] - pPC4->jStart;
k += sizeof(EW_PTBL_C4_MEM);
}
bAddUniqueTable(pPTbl, k);
break;
}
return( TRUE );
}
/***************************************************************************
* FUNCTION: iGetCompressKind
*
* PURPOSE: Examine the data table and determine what kind, if any, of
* data compression can be used.
*
* Notice the tables have an extra row and column for the
* headings. The minimum table size should be 5 x 5, which
* is really a 4 x 4 table (the parse loop catches anything
* smaller and aborts).
*
* RETURNS: The function returns the compression id.
***************************************************************************/
static int iGetCompressKind(
EW_BYTE *pDataBuf,
int iRow,
int iCol,
int iNoFit)
{
int i;
int j;
/* All compression mechanisms require a square table.
*/
if( (iRow != iCol ) ||( iCol < 5 )) {
return( PAN_COMPRESS_C0 );
}
/* Test for symmetry around the diagonal.
*/
for( i = 3; i < iCol; ++i ) {
/* The diagonal( exact match value ) must be zero.
*/
if( pDataBuf[(iCol * i ) + i] != 0) {
return( PAN_COMPRESS_C0 );
}
/* Test for value at( i,j ) ==( j,i ).
*/
for( j = i + 1; (j < iCol ); ++j) {
if( pDataBuf[(iCol * i ) + j] != pDataBuf[(iCol * j) + i]) {
return( PAN_COMPRESS_C0 );
}
}
}
/* The table is symmetrical, now walk it looking for a special
* pattern: it starts at a given value and increments by a given
* value. If we find this, then we just store the start and
* increment values.
*
* The table must be atleast 4 x 4 to try this test. Note if
* it is exactly 4 x 4 and the one value in the table is a 1,
* then C1 is the most compact way to store it (the 'else'
* statement below checks for that). Otherwise C2 or C3 is
* the best.
*/
if( (iCol > 5 ) &&( iNoFit == 10 )) {
EW_BOOL bFits = TRUE;
EW_BYTE jStart = pDataBuf[(iCol * 4) + 3];
EW_BYTE jInc = pDataBuf[(iCol * 5) + 3] - jStart;
for( i = 5; (i < iCol ) && bFits; ++i) {
for( j = 3; (j < i ) && bFits; ++j) {
bFits =( pDataBuf[(iCol * i ) + j] ==
( EW_BYTE )(((EW_BYTE)(i - j - 1) * jInc) + jStart));
}
}
/* C1 compression implies( start, inc ) ==( 1, 1 ),
* C4 stores the start and inc values.
*/
if( bFits ) {
return( ((jStart == 1 ) &&( jInc == 1 )) ?
PAN_COMPRESS_C1 : PAN_COMPRESS_C4);
}
} else if( (pDataBuf[(iCol * 4 ) + 3] == 1) &&( iNoFit == 10 )) {
return( PAN_COMPRESS_C1 );
}
/* The table is symmetrical about the diagonal, but there
* is no recognized pattern within it, so return C2 or C3
* compression (C3 is C2 compression with a specifier for
* the 'no-fit' value).
*/
return( (iNoFit == 10 ) ? PAN_COMPRESS_C2 : PAN_COMPRESS_C3);
}
/***************************************************************************
* FUNCTION: bAddUniqueTable
*
* PURPOSE: Add a unique table to the accumulated penalty database, if
* a table matching this table's data already exists, then re-use
* that data.
*
* Upon entry to this routine, s_unOffs should point to the
* data that is about to be added. This func walks all the
* tables that have already been added looking for duplicate
* data.
*
* This function should be called when we're building the
* database( second pass ).
*
* RETURNS: The function returns TRUE if a new table was added, or FALSE
* if an existing table was re-used.
***************************************************************************/
static EW_BOOL bAddUniqueTable(
EW_PTBL_MEM *pPTbl,
int iSize)
{
int i;
int j;
int iNumTbl;
EW_PDICT_MEM *pHead =( EW_PDICT_MEM * )s_buf;
EW_PIND_MEM *pInd = pHead->pind;
EW_PTBL_MEM *pPTblTst;
/* Shortcut for C1 compression: it has no data.
*/
if( !iSize ) {
return( FALSE );
}
/* This walk is kind of tricky: we are walking a penalty
* database that is in the process of being created. Some
* fields are valid, some are not.
*
* For each dictionary.
*/
for( i = 0; i < (int )pHead->unNumDicts; ++i, ++pInd) {
/* If the ptbl offset is NULL, then we've reached the
* end of the filled-in dictionaries.
*/
if( !pInd->unOffsPTbl ) {
break;
}
/* Get the count of tables.
*/
if( pInd->unOffsAtoB ) {
iNumTbl =( int )((EW_ATOB_MEM *)&s_buf[pInd->unOffsAtoB])->unNumAtoB;
} else {
iNumTbl = NUM_PAN_DIGITS - 1;
}
/* For each penalty table.
*/
for( j = 0, pPTblTst = (EW_PTBL_MEM * )&s_buf[pInd->unOffsPTbl];
j < iNumTbl;
++j, ++pPTblTst) {
/* The last filled-in table should be the one that
* was passed in.
*/
if( (pPTblTst >= pPTbl ) || !pPTblTst->jRangeLast) {
break;
}
/* Look for matching data, and return if it is found.
*/
if( (pPTblTst->unOffsTbl > 0 ) &&
( pPTbl->jCompress == pPTblTst->jCompress ) &&
( iSize == (int )pPTblTst->unTblSize) &&
(memcmp(&s_buf[s_unOffs],
&s_buf[pPTblTst->unOffsTbl], iSize) == 0)) {
pPTbl->unTblSize = iSize;
pPTbl->unOffsTbl = pPTblTst->unOffsTbl;
return( FALSE );
}
}
}
/* No duplicate was found, keep the structure that is currently
* in the buffer.
*/
pPTbl->unOffsTbl = s_unOffs;
s_unOffs += pPTbl->unTblSize = iSize;
return( TRUE );
}
/***************************************************************************
* FUNCTION: iReadData
*
* PURPOSE: Read an array of numbers from file.
*
* RETURNS: The function returns the count of numbers it read from the
* line.
***************************************************************************/
static int iReadData(
FILE *fpin,
char *pLnBuf,
int iBufSize,
EW_BYTE *pDataBuf)
{
int i;
int j = 0;
/* Get the test line.
*/
if( !bGetLine(pLnBuf, iBufSize, fpin )) {
return( 0 );
}
/* For each number.
*/
while( TRUE ) {
/* Walk white space.
*/
for( ; *pLnBuf && ((*pLnBuf == ' ' ) ||( *pLnBuf == '\t' )); ++pLnBuf)
;
/* Stop if not at a number.
*/
if( !*pLnBuf || (*pLnBuf < '0' ) ||( *pLnBuf > '9' )) {
break;
}
/* Read the number.
*/
for( i = 0; *pLnBuf && (*pLnBuf >= '0' ) &&( *pLnBuf <= '9' );
++pLnBuf) {
i =( i * 10 ) +( *pLnBuf - '0' );
}
*pDataBuf++ = i;
++j;
}
/* Sanity check. At this point the buffer should be empty,
* the end of the line, or the start of a comment.
*/
if( *pLnBuf && (*pLnBuf >= ' ' ) &&( *pLnBuf != ';' )) {
return( 0 );
}
return( j );
}
/***************************************************************************
* FUNCTION: bGetLine
*
* PURPOSE: Read a line from file. Skip blank and comment lines.
*
* RETURNS: The function returns TRUE if it finds a line, FALSE if it
* does not.
***************************************************************************/
static EW_BOOL bGetLine(
char *pBuf,
int iLen,
FILE *fpin)
{
int i;
char ch;
char *p;
#define M_EOL(ch)( ((ch ) == '\r') ||( (ch ) == '\n'))
do {
/* First read through end of line characters.
*/
while( ((ch = fgetc(fpin )) != EOF) && M_EOL(ch)) {
if( ch == '\n' ) {
++s_iLnPos;
}
}
if( ch == EOF ) {
return( FALSE );
}
/* Read the line.
*/
for (i = 1, p = pBuf, *p++ = ch;
( i < iLen ) &&( (*p = fgetc(fpin )) != EOF) && !M_EOL(*p);
++i, ++p)
;
*p = '\0';
/* Bump the line counter.
*/
++s_iLnPos;
/* Skip this line if it begins with a comment character.
*/
} while( pBuf[0] == ';' );
return( TRUE );
}
/***************************************************************************
* FUNCTION: vShowDB
*
* PURPOSE: Dump the database to stdout.
*
* RETURNS: Nothing.
***************************************************************************/
static void vShowDB()
{
int i;
int j;
int k;
int m;
int n;
int iNumPTbl;
EW_PDICT_MEM *pHead =( EW_PDICT_MEM * )s_buf;
EW_PIND_MEM *pInd = pHead->pind;
EW_BYTE *pWt;
EW_ATOB_MEM *pAtoB;
EW_ATOB_ITEM_MEM *pAtoBItem;
EW_PTBL_MEM *pPTbl;
EW_BYTE *pData;
printf("\n\nDATABASE DUMP\n");
printf("~~~~~~~~~~~~~\n");
printf("vers = 0x%04x\n", pHead->unVersion);
printf("num dicts = %u\n", pHead->unNumDicts);
printf("size db = %u\n", pHead->unSizeDB);
for( i = 0; i < (int )pHead->unNumDicts; ++i, ++pInd) {
printf("\n=======================================================\n");
printf("0x%04x:Index entry:\n",
( (unsigned )(char *)pInd -( unsigned )(char *)pHead));
printf("family row = %u\n",( EW_USHORT )pInd->jFamilyA);
printf("family col = %u\n",( EW_USHORT )pInd->jFamilyB);
printf("any = %u\n",( EW_USHORT )pInd->jDefAnyPenalty);
printf("no-fit = %u\n",( EW_USHORT )pInd->jDefNoFitPenalty);
printf("match = %u\n",( EW_USHORT )pInd->jDefMatchPenalty);
printf("reserved = %u\n",( EW_USHORT )pInd->jReserved);
printf("offs wt = 0x%04x\n", pInd->unOffsWts);
printf("offs atob = 0x%04x\n", pInd->unOffsAtoB);
printf("offs ptbl = 0x%04x\n", pInd->unOffsPTbl);
if( pInd->unOffsWts ) {
pWt =( EW_BYTE * )&s_buf[pInd->unOffsWts];
printf("\n0x%04x:weights:", pInd->unOffsWts);
for( j = 0; j < NUM_PAN_DIGITS; ++j, ++pWt ) {
printf(" %u",( EW_USHORT )*pWt);
}
printf("\n");
} else {
printf("\nERROR: NO WEIGHTS\n");
}
if( pInd->unOffsAtoB ) {
pAtoB =( EW_ATOB_MEM * )&s_buf[pInd->unOffsAtoB];
pAtoBItem = pAtoB->AtoBItem;
printf("\n0x%04x:AtoB:\n", pInd->unOffsAtoB);
printf("count = %u\n", pAtoB->unNumAtoB);
for( j = 0; j < (int )pAtoB->unNumAtoB; ++j, ++pAtoBItem) {
printf("pair = %u, %u\n",( EW_USHORT )pAtoBItem->jAttrA,
( EW_USHORT )pAtoBItem->jAttrB);
}
iNumPTbl = pAtoB->unNumAtoB;
} else {
iNumPTbl = NUM_PAN_DIGITS - 1;
}
if( pInd->unOffsPTbl && (iNumPTbl > 0 )) {
pPTbl =( EW_PTBL_MEM * )&s_buf[pInd->unOffsPTbl];
for( j = 0; j < iNumPTbl; ++j, ++pPTbl ) {
printf("\n0x%04x:penalty table:\n",
( (unsigned )(char *)pPTbl -( unsigned )(char *)pHead));
printf("rng last = %u\n",( EW_USHORT )pPTbl->jRangeLast);
printf("compress = %u\n",( EW_USHORT )pPTbl->jCompress);
printf("offs tbl = 0x%04x\n", pPTbl->unOffsTbl);
printf("tbl size = %u\n", pPTbl->unTblSize);
if( pPTbl->unOffsTbl && !bShowDupTbl(pPTbl )) {
k = 0;
pData =( EW_BYTE * )&s_buf[pPTbl->unOffsTbl];
switch( pPTbl->jCompress ) {
case PAN_COMPRESS_C0:
{
EW_PTBL_C0_MEM *pPC0 =( EW_PTBL_C0_MEM * )&pData[k];
pData += k =( sizeof(EW_PTBL_C0_MEM ) - sizeof(EW_BYTE));
printf("Non-symmetrical table, row = %u, col = %u, reserved = %u\n",
( EW_USHORT )pPC0->jARangeLast,
( EW_USHORT )pPC0->jBRangeLast,
( EW_USHORT )pPC0->jReserved);
printf(" ");
for( m = 0; m <= (int )pPC0->jBRangeLast; ++m) {
printf(" %2u", m);
}
printf("\n");
for( m = 0; m <= (int )pPC0->jARangeLast; ++m) {
printf("%2u", m);
if( m > 1 ) {
printf(" ");
for( n = 2; (n <= (int )pPC0->jBRangeLast) &&
( k < (int )pPTbl->unTblSize);
++n, ++k, ++pData) {
printf(" %2u",( EW_USHORT )*pData);
}
}
printf("\n");
}
}
break;
case PAN_COMPRESS_C1:
printf("ERROR: TABLE SHOULD BE EMPTY\n");
break;
case PAN_COMPRESS_C3:
printf("no-fit value = %u\n",( EW_USHORT )*pData);
++pData, ++k;
case PAN_COMPRESS_C2:
printf(" ");
for( m = 0; m <= (int )pPTbl->jRangeLast; ++m) {
printf(" %2u", m);
}
printf("\n");
for( m = 0; m <= (int )pPTbl->jRangeLast; ++m) {
printf("%2u", m);
if( m > 2 ) {
printf(" ");
for( n = 2; (n < m ) &&( k < (int )pPTbl->unTblSize);
++n, ++k, ++pData) {
printf(" %2u",( EW_USHORT )*pData);
}
}
printf("\n");
}
break;
case PAN_COMPRESS_C4:
{
EW_PTBL_C4_MEM *pPC4 =( EW_PTBL_C4_MEM * )&pData[k];
pData += k = sizeof(EW_PTBL_C4_MEM);
printf("start = %u, increment = %u\n",
( EW_USHORT )pPC4->jStart,
( EW_USHORT )pPC4->jIncrement);
}
break;
default:
printf("ERROR: INVALID COMPRESSION TYPE\n");
break;
}
} else if (!pPTbl->unOffsTbl &&
( pPTbl->jCompress != PAN_COMPRESS_C1 )) {
printf("ERROR: NO DATA\n");
}
}
} else {
printf("\nERROR: NO PENALTIES\n");
}
}
printf("\n=======================================================\n");
printf("Raw data dump:\n");
pData =( EW_BYTE * )s_buf;
printf(" 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f\n");
for( k = 0; k < (int )pHead->unSizeDB; ) {
printf("0x%04x:", k);
for( i = 0; (i < 16 ) &&( k < (int )pHead->unSizeDB);
++i, ++k, ++pData) {
printf(" %02x",( EW_USHORT )*pData);
}
printf("\n");
}
}
/***************************************************************************
* FUNCTION: bShowDupTbl
*
* PURPOSE: Search for a duplicate table and don't show it twice, instead
* indicate it is a duplicate table.
*
* RETURNS: The function returns TRUE if this is, indeed, a duplicate
* table, or FALSE if it is not.
***************************************************************************/
static EW_BOOL bShowDupTbl(
EW_PTBL_MEM *pPTbl)
{
int i;
int j;
int iNumTbl;
EW_PDICT_MEM *pHead =( EW_PDICT_MEM * )s_buf;
EW_PIND_MEM *pInd = pHead->pind;
EW_PTBL_MEM *pPTblTst;
/* Quick test for C1 compression.
*/
if( !pPTbl->unTblSize || !pPTbl->unOffsTbl ) {
return( FALSE );
}
/* For each dictionary.
*/
for( i = 0; i < (int )pHead->unNumDicts; ++i, ++pInd) {
/* Get the count of tables.
*/
if( pInd->unOffsAtoB ) {
iNumTbl =( int )((EW_ATOB_MEM *)&s_buf[pInd->unOffsAtoB])->unNumAtoB;
} else {
iNumTbl = NUM_PAN_DIGITS - 1;
}
/* For each penalty table.
*/
for( j = 0, pPTblTst = (EW_PTBL_MEM * )&s_buf[pInd->unOffsPTbl];
j < iNumTbl;
++j, ++pPTblTst) {
/* Walk up to the current table.
*/
if( pPTblTst >= pPTbl ) {
break;
}
/* Look for matching data, and return if it is found.
*/
if( (pPTblTst->unOffsTbl > 0 ) &&
( pPTbl->jRangeLast == pPTblTst->jRangeLast ) &&
( pPTbl->jCompress == pPTblTst->jCompress ) &&
( pPTbl->unTblSize == pPTblTst->unTblSize ) &&
( pPTbl->unOffsTbl == pPTblTst->unOffsTbl )) {
printf("The data has already dumped( duplicate table ).\n");
return( TRUE );
}
}
}
/* No duplicate found.
*/
return( FALSE );
}
/***************************************************************************
* Revision log:
***************************************************************************/
/*
* $lgb$
* 1.0 31-Jan-93 msd PANOSE 1.0 penalties database, textual version.
* 1.1 31-Jan-93 msd Modified the way a file is written if we know we're checking it in and out of vcs.
* 1.2 1-Feb-93 msd Fixed a bug with the vcs handling stuff.
* 1.3 3-Feb-93 msd Removed ctrl-z at EOF. Ifdef'd in Mac code to get this to build as an MPW tool. Ifdef'd out system calls on the Mac.
* 1.4 3-Feb-93 msd Added generic line-read routine that can handle both mac- and pc-format test files.
* 1.5 6-Feb-93 msd Init reserved bye in C0 penalty header.
* 1.6 18-Feb-93 msd Implemented binary file writing, init penalty table byte-ordering variable, and C4 ptbl compression( new version of ptbl ). Identical tables are not repeated.
* 1.7 26-Feb-93 msd Don't abort on weight values of zero( just warn ). Also repaired line counter.
* 1.8 1-Apr-93 msd Added _cdecl keyword to main().
* 1.9 15-Apr-94 jasons Removed cdecl on main for Mac.
* $lge$
*/