#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#ifndef FONTMODULE
#include <string.h>
#else
#include "Xdefs.h"
#include "Xmd.h"
#include "xf86_ansic.h"
#endif
#include "t1stdio.h"
#include "util.h"
#include "token.h"
#include "objects.h"
#include "spaces.h"
#include "fontfcn.h"
#include "blues.h"
#include <limits.h>
static int rc;
static boolean InPrivateDict;
static boolean WantFontInfo;
static boolean TwoSubrs;
static psobj inputFile;
static psobj filterFile;
static psobj *inputP;
typedef struct
{
int index;
char *name;
} EncodingTable;
static EncodingTable StdEnc[] = {
{ 040 , "space" },
{ 041 , "exclam" },
{ 042 , "quotedbl" },
{ 043 , "numbersign" },
{ 044 , "dollar" },
{ 045 , "percent" },
{ 046 , "ampersand" },
{ 047 , "quoteright" },
{ 050 , "parenleft" },
{ 051 , "parenright" },
{ 052 , "asterisk" },
{ 053 , "plus" },
{ 054 , "comma" },
{ 055 , "hyphen" },
{ 056 , "period" },
{ 057 , "slash" },
{ 060 , "zero" },
{ 061 , "one" },
{ 062 , "two" },
{ 063 , "three" },
{ 064 , "four" },
{ 065 , "five" },
{ 066 , "six" },
{ 067 , "seven" },
{ 070 , "eight" },
{ 071 , "nine" },
{ 072 , "colon" },
{ 073 , "semicolon" },
{ 074 , "less" },
{ 075 , "equal" },
{ 076 , "greater" },
{ 077 , "question" },
{ 0100 , "at" },
{ 0101 , "A" },
{ 0102 , "B" },
{ 0103 , "C" },
{ 0104 , "D" },
{ 0105 , "E" },
{ 0106 , "F" },
{ 0107 , "G" },
{ 0110 , "H" },
{ 0111 , "I" },
{ 0112 , "J" },
{ 0113 , "K" },
{ 0114 , "L" },
{ 0115 , "M" },
{ 0116 , "N" },
{ 0117 , "O" },
{ 0120 , "P" },
{ 0121 , "Q" },
{ 0122 , "R" },
{ 0123 , "S" },
{ 0124 , "T" },
{ 0125 , "U" },
{ 0126 , "V" },
{ 0127 , "W" },
{ 0130 , "X" },
{ 0131 , "Y" },
{ 0132 , "Z" },
{ 0133 , "bracketleft" },
{ 0134 , "backslash" },
{ 0135 , "bracketright" },
{ 0136 , "asciicircum" },
{ 0137 , "underscore" },
{ 0140 , "quoteleft" },
{ 0141 , "a" },
{ 0142 , "b" },
{ 0143 , "c" },
{ 0144 , "d" },
{ 0145 , "e" },
{ 0146 , "f" },
{ 0147 , "g" },
{ 0150 , "h" },
{ 0151 , "i" },
{ 0152 , "j" },
{ 0153 , "k" },
{ 0154 , "l" },
{ 0155 , "m" },
{ 0156 , "n" },
{ 0157 , "o" },
{ 0160 , "p" },
{ 0161 , "q" },
{ 0162 , "r" },
{ 0163 , "s" },
{ 0164 , "t" },
{ 0165 , "u" },
{ 0166 , "v" },
{ 0167 , "w" },
{ 0170 , "x" },
{ 0171 , "y" },
{ 0172 , "z" },
{ 0173 , "braceleft" },
{ 0174 , "bar" },
{ 0175 , "braceright" },
{ 0176 , "asciitilde" },
{ 0241 , "exclamdown" },
{ 0242 , "cent" },
{ 0243 , "sterling" },
{ 0244 , "fraction" },
{ 0245 , "yen" },
{ 0246 , "florin" },
{ 0247 , "section" },
{ 0250 , "currency" },
{ 0251 , "quotesingle" },
{ 0252 , "quotedblleft" },
{ 0253 , "guillemotleft" },
{ 0254 , "guilsinglleft" },
{ 0255 , "guilsinglright" },
{ 0256 , "fi" },
{ 0257 , "fl" },
{ 0261 , "endash" },
{ 0262 , "dagger" },
{ 0263 , "daggerdbl" },
{ 0264 , "periodcentered" },
{ 0266 , "paragraph" },
{ 0267 , "bullet" },
{ 0270 , "quotesinglbase" },
{ 0271 , "quotedblbase" },
{ 0272 , "quotedblright" },
{ 0273 , "guillemotright" },
{ 0274 , "ellipsis" },
{ 0275 , "perthousand" },
{ 0277 , "questiondown" },
{ 0301 , "grave" },
{ 0302 , "acute" },
{ 0303 , "circumflex" },
{ 0304 , "tilde" },
{ 0305 , "macron" },
{ 0306 , "breve" },
{ 0307 , "dotaccent" },
{ 0310 , "dieresis" },
{ 0312 , "ring" },
{ 0313 , "cedilla" },
{ 0315 , "hungarumlaut" },
{ 0316 , "ogonek" },
{ 0317 , "caron" },
{ 0320 , "emdash" },
{ 0341 , "AE" },
{ 0343 , "ordfeminine" },
{ 0350 , "Lslash" },
{ 0351 , "Oslash" },
{ 0352 , "OE" },
{ 0353 , "ordmasculine" },
{ 0361 , "ae" },
{ 0365 , "dotlessi" },
{ 0370 , "lslash" },
{ 0371 , "oslash" },
{ 0372 , "oe" },
{ 0373 , "germandbls" },
{ 0, 0 }
};
static EncodingTable ISO8859Enc[] = {
{ 32, "space" },
{ 33, "exclam" },
{ 34, "quotedbl" },
{ 35, "numbersign" },
{ 36, "dollar" },
{ 37, "percent" },
{ 38, "ampersand" },
{ 39, "quoteright" },
{ 40, "parenleft" },
{ 41, "parenright" },
{ 42, "asterisk" },
{ 43, "plus" },
{ 44, "comma" },
{ 45, "minus" },
{ 46, "period" },
{ 47, "slash" },
{ 48, "zero" },
{ 49, "one" },
{ 50, "two" },
{ 51, "three" },
{ 52, "four" },
{ 53, "five" },
{ 54, "six" },
{ 55, "seven" },
{ 56, "eight" },
{ 57, "nine" },
{ 58, "colon" },
{ 59, "semicolon" },
{ 60, "less" },
{ 61, "equal" },
{ 62, "greater" },
{ 63, "question" },
{ 64, "at" },
{ 65, "A" },
{ 66, "B" },
{ 67, "C" },
{ 68, "D" },
{ 69, "E" },
{ 70, "F" },
{ 71, "G" },
{ 72, "H" },
{ 73, "I" },
{ 74, "J" },
{ 75, "K" },
{ 76, "L" },
{ 77, "M" },
{ 78, "N" },
{ 79, "O" },
{ 80, "P" },
{ 81, "Q" },
{ 82, "R" },
{ 83, "S" },
{ 84, "T" },
{ 85, "U" },
{ 86, "V" },
{ 87, "W" },
{ 88, "X" },
{ 89, "Y" },
{ 90, "Z" },
{ 91, "bracketleft" },
{ 92, "backslash" },
{ 93, "bracketright" },
{ 94, "asciicircum" },
{ 95, "underscore" },
{ 96, "quoteleft" },
{ 97, "a" },
{ 98, "b" },
{ 99, "c" },
{ 100, "d" },
{ 101, "e" },
{ 102, "f" },
{ 103, "g" },
{ 104, "h" },
{ 105, "i" },
{ 106, "j" },
{ 107, "k" },
{ 108, "l" },
{ 109, "m" },
{ 110, "n" },
{ 111, "o" },
{ 112, "p" },
{ 113, "q" },
{ 114, "r" },
{ 115, "s" },
{ 116, "t" },
{ 117, "u" },
{ 118, "v" },
{ 119, "w" },
{ 120, "x" },
{ 121, "y" },
{ 122, "z" },
{ 123, "braceleft" },
{ 124, "bar" },
{ 125, "braceright" },
{ 126, "asciitilde" },
{ 160, "space" },
{ 161, "exclamdown" },
{ 162, "cent" },
{ 163, "sterling" },
{ 164, "currency" },
{ 165, "yen" },
{ 166, "brokenbar" },
{ 167, "section" },
{ 168, "dieresis" },
{ 169, "copyright" },
{ 170, "ordfeminine" },
{ 171, "guillemotleft" },
{ 172, "logicalnot" },
{ 173, "hyphen" },
{ 174, "registered" },
{ 175, "macron" },
{ 176, "degree" },
{ 177, "plusminus" },
{ 178, "twosuperior" },
{ 179, "threesuperior" },
{ 180, "acute" },
{ 181, "mu" },
{ 182, "paragraph" },
{ 183, "periodcentered" },
{ 184, "cedilla" },
{ 185, "onesuperior" },
{ 186, "ordmasculine" },
{ 187, "guillemotright" },
{ 188, "onequarter" },
{ 189, "onehalf" },
{ 190, "threequarters" },
{ 191, "questiondown" },
{ 192, "Agrave" },
{ 193, "Aacute" },
{ 194, "Acircumflex" },
{ 195, "Atilde" },
{ 196, "Adieresis" },
{ 197, "Aring" },
{ 198, "AE" },
{ 199, "Ccedilla" },
{ 200, "Egrave" },
{ 201, "Eacute" },
{ 202, "Ecircumflex" },
{ 203, "Edieresis" },
{ 204, "Igrave" },
{ 205, "Iacute" },
{ 206, "Icircumflex" },
{ 207, "Idieresis" },
{ 208, "Eth" },
{ 209, "Ntilde" },
{ 210, "Ograve" },
{ 211, "Oacute" },
{ 212, "Ocircumflex" },
{ 213, "Otilde" },
{ 214, "Odieresis" },
{ 215, "multiply" },
{ 216, "Oslash" },
{ 217, "Ugrave" },
{ 218, "Uacute" },
{ 219, "Ucircumflex" },
{ 220, "Udieresis" },
{ 221, "Yacute" },
{ 222, "Thorn" },
{ 223, "germandbls" },
{ 224, "agrave" },
{ 225, "aacute" },
{ 226, "acircumflex" },
{ 227, "atilde" },
{ 228, "adieresis" },
{ 229, "aring" },
{ 230, "ae" },
{ 231, "ccedilla" },
{ 232, "egrave" },
{ 233, "eacute" },
{ 234, "ecircumflex" },
{ 235, "edieresis" },
{ 236, "igrave" },
{ 237, "iacute" },
{ 238, "icircumflex" },
{ 239, "idieresis" },
{ 240, "eth" },
{ 241, "ntilde" },
{ 242, "ograve" },
{ 243, "oacute" },
{ 244, "ocircumflex" },
{ 245, "otilde" },
{ 246, "odieresis" },
{ 247, "divide" },
{ 248, "oslash" },
{ 249, "ugrave" },
{ 250, "uacute" },
{ 251, "ucircumflex" },
{ 252, "udieresis" },
{ 253, "yacute" },
{ 254, "thorn" },
{ 255, "ydieresis" },
{ 0, 0 }
};
static psobj *StdEncArrayP = NULL;
static psobj *ISOLatin1EncArrayP = NULL;
static psobj *
MakeEncodingArrayP(EncodingTable *encodingTable)
{
int i;
psobj *encodingArrayP;
encodingArrayP = (psobj *)vm_alloc(256*(sizeof(psobj)));
if (!encodingArrayP)
return NULL;
for (i=0; i<256;i++)
objFormatName(&(encodingArrayP[i]),7, ".notdef");
for (i=0; encodingTable[i].name; i++)
{
objFormatName(&(encodingArrayP[encodingTable[i].index]),
strlen(encodingTable[i].name),
encodingTable[i].name);
}
return(encodingArrayP);
}
boolean
Init_BuiltInEncoding(void)
{
StdEncArrayP = MakeEncodingArrayP(StdEnc);
ISOLatin1EncArrayP = MakeEncodingArrayP(ISO8859Enc);
return (StdEncArrayP && ISOLatin1EncArrayP);
}
static int
getNextValue(int valueType)
{
scan_token(inputP);
if (tokenType != valueType) {
return(SCAN_ERROR);
}
return(SCAN_OK);
}
static int
getInt(void)
{
scan_token(inputP);
if (tokenType != TOKEN_INTEGER) {
rc = SCAN_ERROR;
return(0);
}
else {
return( tokenValue.integer);
}
}
static int
getEncoding(psobj *arrayP)
{
scan_token(inputP);
if ((tokenType == TOKEN_NAME && (tokenLength==16 || tokenLength==17)))
{
if((tokenLength==16) && (!strncmp(tokenStartP,"StandardEncoding",16)))
arrayP->data.valueP = (char *) StdEncArrayP;
else
arrayP->data.valueP = (char *) ISOLatin1EncArrayP;
arrayP->len = 256;
return(SCAN_OK);
}
else if ( (tokenType == TOKEN_LEFT_BRACE) ||
(tokenType == TOKEN_LEFT_BRACKET) )
{
psobj *objP;
int i;
objP = (psobj *)vm_alloc(256*(sizeof(psobj)));
if (!(objP)) return(SCAN_OUT_OF_MEMORY);
arrayP->data.valueP = (char *) objP;
arrayP->len = 256;
for (i=0; i<256; i++, objP++)
{
scan_token(inputP);
if (tokenType != TOKEN_LITERAL_NAME)
return(SCAN_ERROR);
if (!(vm_alloc(tokenLength)) ) return(SCAN_OUT_OF_MEMORY);
objFormatName(objP,tokenLength,tokenStartP);
}
scan_token(inputP);
if ( (tokenType == TOKEN_RIGHT_BRACE) ||
(tokenType == TOKEN_RIGHT_BRACKET) )
return(SCAN_OK);
}
else
{
psobj *objP;
int i;
objP = (psobj *)vm_alloc(256*(sizeof(psobj)));
if (!(objP)) return(SCAN_OUT_OF_MEMORY);
arrayP->data.valueP = (char *) objP;
arrayP->len = 256;
for (i=0; i<256; i++)
objFormatName(objP + i, 7, ".notdef");
while (TRUE)
{
scan_token(inputP);
switch (tokenType)
{
case TOKEN_NAME:
if (tokenLength == 3)
{
if (strncmp(tokenStartP,"dup",3) == 0)
{
scan_token(inputP);
if (tokenType != TOKEN_INTEGER ||
tokenValue.integer < 0 ||
tokenValue.integer > 255)
return (SCAN_ERROR);
i = tokenValue.integer;
scan_token(inputP);
if (tokenType != TOKEN_LITERAL_NAME)
return(SCAN_ERROR);
if (!(vm_alloc(tokenLength)) )
return(SCAN_OUT_OF_MEMORY);
objFormatName(objP + i,tokenLength,tokenStartP);
scan_token(inputP);
if (tokenType != TOKEN_NAME)
return(SCAN_ERROR);
}
else if (strncmp(tokenStartP,"def",3) == 0)
return (SCAN_OK);
}
break;
case TOKEN_EOF:
case TOKEN_NONE:
case TOKEN_INVALID:
return (SCAN_ERROR);
}
}
}
return (SCAN_ERROR);
}
static int
getArray(psobj *arrayP)
{
int N;
psobj *objP;
char tmp [1024];
strncpy (tmp, tokenStartP, sizeof (tmp));
tmp [sizeof (tmp) - 1] = '\0';
restart:
scan_token(inputP);
switch (tokenType)
{
case TOKEN_LEFT_BRACE:
case TOKEN_LEFT_BRACKET:
break;
case TOKEN_LITERAL_NAME:
tokenStartP[tokenLength] = '\0';
if (strcmp (tokenStartP, tmp) == 0)
{
goto restart;
}
default:
return(SCAN_ERROR);
}
arrayP->data.valueP = tokenStartP;
N = 0;
do {
scan_token(inputP);
if ( (tokenType == TOKEN_RIGHT_BRACE) ||
(tokenType == TOKEN_RIGHT_BRACKET) ) {
arrayP->len = N;
return(SCAN_OK);
}
objP = (psobj *)vm_alloc(sizeof(psobj));
if (!(objP)) return(SCAN_OUT_OF_MEMORY);
if (tokenType == TOKEN_REAL) {
objFormatReal(objP, tokenValue.real);
}
else
if (tokenType == TOKEN_INTEGER) {
objFormatInteger(objP, tokenValue.integer);
}
else return(SCAN_ERROR);
N++;
} while ( 1>0 );
}
static int
getName(char *nameP)
{
do {
scan_token(inputP);
if (tokenType <= TOKEN_NONE) {
if (tokenTooLong) return(SCAN_OUT_OF_MEMORY);
return(SCAN_ERROR);
}
} while ((tokenType != TOKEN_NAME) ||
(0 != strncmp(tokenStartP,nameP,strlen(nameP))) );
return(SCAN_OK);
}
static int
getNbytes(int N)
{
int I;
tokenStartP = vm_next_byte();
tokenMaxP = tokenStartP + MIN(vm_free_bytes(), MAX_STRING_LEN);
if (N > vm_free_bytes()) {
return(SCAN_OUT_OF_MEMORY);
}
I = T1Read(tokenStartP,1,N,inputP->data.fileP);
if ( I != N ) return(SCAN_FILE_EOF);
return(SCAN_OK);
}
static int
getLiteralName(psobj *nameObjP)
{
do {
scan_token(inputP);
if (tokenType <= TOKEN_NONE) {
if (tokenTooLong) return(SCAN_OUT_OF_MEMORY);
return(SCAN_ERROR);
}
if (tokenType == TOKEN_NAME) {
if (0 == strncmp(tokenStartP,"end",3) ) {
return(SCAN_END);
}
}
} while (tokenType != TOKEN_LITERAL_NAME) ;
nameObjP->len = tokenLength;
if (!(vm_alloc(tokenLength)) ) return(SCAN_OUT_OF_MEMORY);
nameObjP->data.valueP = tokenStartP;
return(SCAN_OK);
}
static int
BuildSubrs(psfont *FontP)
{
int N;
int I;
int i;
int J;
psobj *arrayP;
N = getInt();
if (rc) return(rc);
if (N < 0 ) return(SCAN_ERROR);
if (FontP->Subrs.data.arrayP != NULL) {
TwoSubrs = TRUE;
for (i=0;i<N;i++) {
rc = getName("dup");
if (rc) return(rc);
I = getInt();
if (rc) return(rc);
J = getInt();
if (rc) return(rc);
if ( (I < 0) || (J < 0 ) ) return (SCAN_ERROR);
rc = getNextValue(TOKEN_NAME);
if ( rc != SCAN_OK ) return(rc);
rc = getNbytes(J);
if (rc) return(rc);
}
return(SCAN_OK);
}
if (N > INT_MAX / sizeof(psobj))
return (SCAN_ERROR);
arrayP = (psobj *)vm_alloc(N*sizeof(psobj));
if (!(arrayP) ) return(SCAN_OUT_OF_MEMORY);
FontP->Subrs.len = N;
FontP->Subrs.data.arrayP = arrayP;
for (i=0;i<N;i++) {
rc = getName("dup");
if (rc) return(rc);
I = getInt();
if (rc) return(rc);
J = getInt();
if (rc) return(rc);
if ( (I < 0) || (J < 0 ) ) return (SCAN_ERROR);
arrayP[I].len = J;
rc = getNextValue(TOKEN_NAME);
if ( rc != SCAN_OK ) return(rc);
rc = getNbytes(J);
if (rc == SCAN_OK) {
arrayP[I].data.valueP = tokenStartP;
if ( !(vm_alloc(J)) ) return(SCAN_OUT_OF_MEMORY);
}
else return(rc);
}
return(SCAN_OK);
}
static int
BuildCharStrings(psfont *FontP)
{
int N;
int i;
int J;
psdict *dictP;
N = getInt();
if (rc) {
if (TwoSubrs) {
do {
scan_token(inputP);
if (tokenType <= TOKEN_NONE) {
if (tokenTooLong) return(SCAN_OUT_OF_MEMORY);
return(SCAN_ERROR);
}
} while (tokenType != TOKEN_INTEGER);
N = tokenValue.integer;
}
else return(rc);
}
if (N<=0 || N > INT_MAX / sizeof(psdict)) return(SCAN_ERROR);
dictP = (psdict *)vm_alloc((N+1)*sizeof(psdict));
if (!(dictP)) return(SCAN_OUT_OF_MEMORY);
FontP->CharStringsP = dictP;
dictP[0].key.len = N;
for (i=1;i<=N;i++) {
rc = getLiteralName(&(dictP[i].key));
if (rc) return(rc);
J = getInt();
if (rc) return(rc);
if (J<0) return (SCAN_ERROR);
dictP[i].value.len = J;
rc = getNextValue(TOKEN_NAME);
if ( rc != SCAN_OK ) return(rc);
rc = getNbytes(J);
if (rc == SCAN_OK) {
dictP[i].value.data.valueP = tokenStartP;
if ( !(vm_alloc(J)) ) return(SCAN_OUT_OF_MEMORY);
}
else return(rc);
}
return(SCAN_OK);
}
static int
BuildFontInfo(psfont *fontP)
{
psdict *dictP;
dictP = (psdict *)vm_alloc(20*sizeof(psdict));
if (!(dictP)) return(SCAN_OUT_OF_MEMORY);
fontP->fontInfoP = dictP;
fontP->fontInfoP[0].key.len = 17;
objFormatName(&(dictP[FONTNAME].key),8,"FontName");
objFormatName(&(dictP[FONTNAME].value),0,NULL);
objFormatName(&(dictP[PAINTTYPE].key),9,"PaintType");
objFormatInteger(&(dictP[PAINTTYPE].value),0);
objFormatName(&(dictP[FONTTYPENUM].key),8,"FontType");
objFormatInteger(&(dictP[FONTTYPENUM].value),0);
objFormatName(&(dictP[FONTMATRIX].key),10,"FontMatrix");
objFormatArray(&(dictP[FONTMATRIX].value),0,NULL);
objFormatName(&(dictP[FONTBBOX].key),8,"FontBBox");
objFormatArray(&(dictP[FONTBBOX].value),0,NULL);
objFormatName(&(dictP[ENCODING].key),8,"Encoding");
objFormatEncoding(&(dictP[ENCODING].value),0,NULL);
objFormatName(&(dictP[UNIQUEID].key),8,"UniqueID");
objFormatInteger(&(dictP[UNIQUEID].value),0);
objFormatName(&(dictP[STROKEWIDTH].key),11,"StrokeWidth");
objFormatReal(&(dictP[STROKEWIDTH].value),0.0);
objFormatName(&(dictP[VERSION].key),7,"version");
objFormatString(&(dictP[VERSION].value),0,NULL);
objFormatName(&(dictP[NOTICE].key),6,"Notice");
objFormatString(&(dictP[NOTICE].value),0,NULL);
objFormatName(&(dictP[FULLNAME].key),8,"FullName");
objFormatString(&(dictP[FULLNAME].value),0,NULL);
objFormatName(&(dictP[FAMILYNAME].key),10,"FamilyName");
objFormatString(&(dictP[FAMILYNAME].value),0,NULL);
objFormatName(&(dictP[WEIGHT].key),6,"Weight");
objFormatString(&(dictP[WEIGHT].value),0,NULL);
objFormatName(&(dictP[ITALICANGLE].key),11,"ItalicAngle");
objFormatReal(&(dictP[ITALICANGLE].value),0.0);
objFormatName(&(dictP[ISFIXEDPITCH].key),12,"isFixedPitch");
objFormatBoolean(&(dictP[ISFIXEDPITCH].value),FALSE);
objFormatName(&(dictP[UNDERLINEPOSITION].key),17,"UnderlinePosition");
objFormatReal(&(dictP[UNDERLINEPOSITION].value),0.0);
objFormatName(&(dictP[UNDERLINETHICKNESS].key),18,"UnderlineThickness");
objFormatReal(&(dictP[UNDERLINETHICKNESS].value),0.0);
return(SCAN_OK);
}
static int
BuildPrivate(psfont *fontP)
{
psdict *Private;
Private = (psdict *)vm_alloc(20*sizeof(psdict));
if (!(Private)) return(SCAN_OUT_OF_MEMORY);
fontP->Private = Private;
fontP->Private[0].key.len = 16;
objFormatName(&(Private[BLUEVALUES].key),10,"BlueValues");
objFormatArray(&(Private[BLUEVALUES].value),0,NULL);
objFormatName(&(Private[OTHERBLUES].key),10,"OtherBlues");
objFormatArray(&(Private[OTHERBLUES].value),0,NULL);
objFormatName(&(Private[FAMILYBLUES].key),11,"FamilyBlues");
objFormatArray(&(Private[FAMILYBLUES].value),0,NULL);
objFormatName(&(Private[FAMILYOTHERBLUES].key),16,"FamilyOtherBlues");
objFormatArray(&(Private[FAMILYOTHERBLUES].value),0,NULL);
objFormatName(&(Private[BLUESCALE].key),9,"BlueScale");
objFormatReal(&(Private[BLUESCALE].value),DEFAULTBLUESCALE);
objFormatName(&(Private[BLUESHIFT].key),9,"BlueShift");
objFormatInteger(&(Private[BLUESHIFT].value),DEFAULTBLUESHIFT);
objFormatName(&(Private[BLUEFUZZ].key),8,"BlueFuzz");
objFormatInteger(&(Private[BLUEFUZZ].value),DEFAULTBLUEFUZZ);
objFormatName(&(Private[STDHW].key),5,"StdHW");
objFormatArray(&(Private[STDHW].value),0,NULL);
objFormatName(&(Private[STDVW].key),5,"StdVW");
objFormatArray(&(Private[STDVW].value),0,NULL);
objFormatName(&(Private[STEMSNAPH].key),9,"StemSnapH");
objFormatArray(&(Private[STEMSNAPH].value),0,NULL);
objFormatName(&(Private[STEMSNAPV].key),9,"StemSnapV");
objFormatArray(&(Private[STEMSNAPV].value),0,NULL);
objFormatName(&(Private[FORCEBOLD].key),9,"ForceBold");
objFormatBoolean(&(Private[FORCEBOLD].value),DEFAULTFORCEBOLD);
objFormatName(&(Private[LANGUAGEGROUP].key),13,"LanguageGroup");
objFormatInteger(&(Private[LANGUAGEGROUP].value),DEFAULTLANGUAGEGROUP);
objFormatName(&(Private[LENIV].key),5,"lenIV");
objFormatInteger(&(Private[LENIV].value),DEFAULTLENIV);
objFormatName(&(Private[RNDSTEMUP].key),9,"RndStemUp");
objFormatBoolean(&(Private[RNDSTEMUP].value),DEFAULTRNDSTEMUP);
objFormatName(&(Private[EXPANSIONFACTOR].key),9,"ExpansionFactor");
objFormatReal(&(Private[EXPANSIONFACTOR].value),
DEFAULTEXPANSIONFACTOR);
return(SCAN_OK);
}
static int
GetType1Blues(psfont *fontP)
{
psdict *PrivateDictP;
struct blues_struct *blues;
int i;
psobj *HintEntryP;
PrivateDictP = fontP->Private;
blues = (struct blues_struct *) vm_alloc(sizeof(struct blues_struct));
if (!blues) return(SCAN_OUT_OF_MEMORY);
fontP->BluesP = blues;
HintEntryP = &(PrivateDictP[BLUEVALUES].value);
if ( !objPIsArray(HintEntryP) || (HintEntryP->len == 0 ))
blues->numBlueValues = 0;
else {
if (HintEntryP->len > NUMBLUEVALUES) {
blues->numBlueValues = NUMBLUEVALUES;
} else
blues->numBlueValues = HintEntryP->len;
for (i = 0; i<= blues->numBlueValues-1; ++i) {
if (objPIsInteger(&HintEntryP->data.arrayP[i]))
blues->BlueValues[i] =
HintEntryP->data.arrayP[i].data.integer;
else if (objPIsReal(&HintEntryP->data.arrayP[i]))
blues->BlueValues[i] =
HintEntryP->data.arrayP[i].data.real;
else
blues->BlueValues[i] = 0;
}
}
HintEntryP = &(PrivateDictP[OTHERBLUES].value);
if ( !objPIsArray(HintEntryP) || (HintEntryP->len == 0 ))
blues->numOtherBlues = 0;
else {
if (HintEntryP->len > NUMOTHERBLUES) {
blues->numOtherBlues = NUMOTHERBLUES;
} else
blues->numOtherBlues = HintEntryP->len;
for (i = 0; i<= blues->numOtherBlues-1; ++i) {
if (objPIsInteger(&HintEntryP->data.arrayP[i]))
blues->OtherBlues[i] =
HintEntryP->data.arrayP[i].data.integer;
else if (objPIsReal(&HintEntryP->data.arrayP[i]))
blues->OtherBlues[i] =
HintEntryP->data.arrayP[i].data.real;
else
blues->OtherBlues[i] = 0;
}
}
HintEntryP = &(PrivateDictP[FAMILYBLUES].value);
if ( !objPIsArray(HintEntryP) || (HintEntryP->len == 0 ))
blues->numFamilyBlues = 0;
else {
if (HintEntryP->len > NUMFAMILYBLUES) {
blues->numFamilyBlues = NUMFAMILYBLUES;
} else
blues->numFamilyBlues = HintEntryP->len;
for (i = 0; i<= blues->numFamilyBlues-1; ++i) {
if (objPIsInteger(&HintEntryP->data.arrayP[i]))
blues->FamilyBlues[i] =
HintEntryP->data.arrayP[i].data.integer;
else if (objPIsReal(&HintEntryP->data.arrayP[i]))
blues->FamilyBlues[i] =
HintEntryP->data.arrayP[i].data.real;
else
blues->FamilyBlues[i] = 0;
}
}
HintEntryP = &(PrivateDictP[FAMILYOTHERBLUES].value);
if ( !objPIsArray(HintEntryP) || (HintEntryP->len == 0 ))
blues->numFamilyOtherBlues = 0;
else {
if (HintEntryP->len > NUMFAMILYOTHERBLUES) {
blues->numFamilyOtherBlues = NUMFAMILYOTHERBLUES;
} else
blues->numFamilyOtherBlues = HintEntryP->len;
for (i = 0; i<= blues->numFamilyOtherBlues-1; ++i) {
if (objPIsInteger(&HintEntryP->data.arrayP[i]))
blues->FamilyOtherBlues[i] =
HintEntryP->data.arrayP[i].data.integer;
else if (objPIsReal(&HintEntryP->data.arrayP[i]))
blues->FamilyOtherBlues[i] =
HintEntryP->data.arrayP[i].data.real;
else
blues->FamilyOtherBlues[i] = 0;
}
}
HintEntryP = &(PrivateDictP[STEMSNAPH].value);
if ( !objPIsArray(HintEntryP) || (HintEntryP->len == 0 ))
blues->numStemSnapH = 0;
else {
if (HintEntryP->len > NUMSTEMSNAPH) {
blues->numStemSnapH = NUMSTEMSNAPH;
} else
blues->numStemSnapH = HintEntryP->len;
for (i = 0; i<= blues->numStemSnapH-1; ++i) {
if (objPIsInteger(&HintEntryP->data.arrayP[i]))
blues->StemSnapH[i] =
HintEntryP->data.arrayP[i].data.integer;
else if (objPIsReal(&HintEntryP->data.arrayP[i]))
blues->StemSnapH[i] =
HintEntryP->data.arrayP[i].data.real;
else
blues->StemSnapH[i] = 0;
}
}
HintEntryP = &(PrivateDictP[STEMSNAPV].value);
if ( !objPIsArray(HintEntryP) || (HintEntryP->len == 0 ))
blues->numStemSnapV = 0;
else {
if (HintEntryP->len > NUMSTEMSNAPV) {
blues->numStemSnapV = NUMSTEMSNAPV;
} else
blues->numStemSnapV = HintEntryP->len;
for (i = 0; i<= blues->numStemSnapV-1; ++i) {
if (objPIsInteger(&HintEntryP->data.arrayP[i]))
blues->StemSnapV[i] =
HintEntryP->data.arrayP[i].data.integer;
else if (objPIsReal(&HintEntryP->data.arrayP[i]))
blues->StemSnapV[i] =
HintEntryP->data.arrayP[i].data.real;
else
blues->StemSnapV[i] = 0;
}
}
HintEntryP = &(PrivateDictP[STDVW].value);
if ( !objPIsArray(HintEntryP) || (HintEntryP->len == 0 ))
blues->StdVW = 0;
else {
if (HintEntryP->len > NUMSTDVW) {
}
if (objPIsInteger(&HintEntryP->data.arrayP[0]))
blues->StdVW = HintEntryP->data.arrayP[0].data.integer;
else if (objPIsReal(&HintEntryP->data.arrayP[0]))
blues->StdVW = HintEntryP->data.arrayP[0].data.real;
else
blues->StdVW = 0;
}
HintEntryP = &(PrivateDictP[STDHW].value);
if ( !objPIsArray(HintEntryP) || (HintEntryP->len == 0 ))
blues->StdHW = 0;
else {
if (HintEntryP->len > NUMSTDHW) {
}
if (objPIsInteger(&HintEntryP->data.arrayP[0]))
blues->StdHW = HintEntryP->data.arrayP[0].data.integer;
else if (objPIsReal(&HintEntryP->data.arrayP[0]))
blues->StdHW = HintEntryP->data.arrayP[0].data.real;
else
blues->StdHW = 0;
}
HintEntryP = &(PrivateDictP[BLUESCALE].value);
if (objPIsInteger(HintEntryP))
blues->BlueScale = HintEntryP->data.integer;
else if (objPIsReal(HintEntryP))
blues->BlueScale = HintEntryP->data.real;
else
blues->BlueScale = DEFAULTBLUESCALE;
HintEntryP = &(PrivateDictP[BLUESHIFT].value);
if (objPIsInteger(HintEntryP))
blues->BlueShift = HintEntryP->data.integer;
else if (objPIsReal(HintEntryP))
blues->BlueShift = HintEntryP->data.real;
else
blues->BlueShift = DEFAULTBLUESHIFT;
HintEntryP = &(PrivateDictP[BLUEFUZZ].value);
if (objPIsInteger(HintEntryP))
blues->BlueFuzz = HintEntryP->data.integer;
else if (objPIsReal(HintEntryP))
blues->BlueFuzz = HintEntryP->data.real;
else
blues->BlueFuzz = DEFAULTBLUEFUZZ;
HintEntryP = &(PrivateDictP[FORCEBOLD].value);
if (objPIsBoolean(HintEntryP))
blues->ForceBold = HintEntryP->data.boolean;
else
blues->ForceBold = DEFAULTFORCEBOLD;
HintEntryP = &(PrivateDictP[LANGUAGEGROUP].value);
if (objPIsInteger(HintEntryP))
blues->LanguageGroup = HintEntryP->data.integer;
else
blues->LanguageGroup = DEFAULTLANGUAGEGROUP;
HintEntryP = &(PrivateDictP[RNDSTEMUP].value);
if (objPIsBoolean(HintEntryP))
blues->RndStemUp = HintEntryP->data.boolean;
else
blues->RndStemUp = DEFAULTRNDSTEMUP;
HintEntryP = &(PrivateDictP[LENIV].value);
if (objPIsInteger(HintEntryP))
blues->lenIV = HintEntryP->data.integer;
else
blues->lenIV = DEFAULTLENIV;
HintEntryP = &(PrivateDictP[EXPANSIONFACTOR].value);
if (objPIsInteger(HintEntryP))
blues->ExpansionFactor = HintEntryP->data.integer;
else if (objPIsReal(HintEntryP))
blues->ExpansionFactor = HintEntryP->data.real;
else
blues->ExpansionFactor = DEFAULTEXPANSIONFACTOR;
return(SCAN_OK);
}
psobj *
GetType1CharString(psfont *fontP, unsigned char code)
{
int N;
psobj *charnameP;
psdict *CharStringsDictP;
psobj *theStringP;
if (StdEncArrayP == NULL) {
return(NULL);
}
charnameP = &(StdEncArrayP[code]);
if (!(objPIsName(charnameP)) ) {
return(NULL);
}
CharStringsDictP = fontP->CharStringsP;
N = SearchDictName(CharStringsDictP,charnameP);
if (N<=0) {
return(NULL);
}
theStringP = &(CharStringsDictP[N].value);
return(theStringP);
}
static int
FindDictValue(psdict *dictP)
{
psobj LitName;
int N;
int V;
objFormatName(&LitName,tokenLength,tokenStartP);
N = SearchDictName(dictP,&LitName);
if ( N > 0 ) {
switch (dictP[N].value.type) {
case OBJ_ENCODING:
V = getEncoding(&(dictP[N].value));
if ( V != SCAN_OK ) return(V);
break;
case OBJ_ARRAY:
V = getArray(&(dictP[N].value));
if ( V != SCAN_OK ) return(V);
break;
case OBJ_INTEGER:
dictP[N].value.data.integer = getInt();
if (rc) return(rc);
break;
case OBJ_REAL:
scan_token(inputP);
if (tokenType == TOKEN_REAL) {
dictP[N].value.data.real = tokenValue.real;
}
else
if (tokenType == TOKEN_INTEGER) {
dictP[N].value.data.real = tokenValue.integer;
}
else return(SCAN_ERROR);
break;
case OBJ_NAME:
V = getNextValue(TOKEN_LITERAL_NAME);
if ( V != SCAN_OK ) return(V);
if (!(vm_alloc(tokenLength)) ) return(SCAN_OUT_OF_MEMORY);
objFormatName(&(dictP[N].value),tokenLength,tokenStartP);
break;
case OBJ_STRING:
V = getNextValue(TOKEN_STRING);
if ( V != SCAN_OK ) return(V);
if (!(vm_alloc(tokenLength)) ) return(SCAN_OUT_OF_MEMORY);
objFormatString(&(dictP[N].value),tokenLength,tokenStartP);
break;
case OBJ_BOOLEAN:
scan_token(inputP);
if (tokenType != TOKEN_NAME) {
return(SCAN_ERROR);
}
if (0 == strncmp(tokenStartP,"true",4) ) {
dictP[N].value.data.boolean =TRUE;
}
else
if (0 == strncmp(tokenStartP,"false",5) ) {
dictP[N].value.data.boolean =FALSE;
}
else return(SCAN_ERROR);
break;
default:
return(SCAN_ERROR);
}
}
return(SCAN_OK);
}
int
scan_font(psfont *FontP)
{
char filename[128];
char filetype[3];
FILE *fileP;
char *nameP;
int namelen;
int V;
int i;
boolean starthex80;
starthex80 = FALSE;
filetype[0] = 'r';
filetype[1] = 'b';
filetype[2] = '\0';
nameP= FontP->FontFileName.data.nameP;
namelen = FontP->FontFileName.len;
while (nameP[0] == ' ') {
nameP++;
namelen--;
}
while ((namelen>0) && ( nameP[namelen-1] == ' ')) {
namelen--;
}
strncpy(filename,nameP,namelen);
filename[namelen] = '\0';
inputFile.data.fileP = NULL;
filterFile.data.fileP = NULL;
inputP = &inputFile;
if ((fileP = T1Open(filename,filetype))) {
V = _XT1getc(fileP);
if ( V == 0X80 ) {
for (i=0;i<5;i++) V = _XT1getc(fileP);
starthex80 = TRUE;
}
else T1Ungetc(V,fileP);
objFormatFile(inputP,fileP);
}
else {
return(SCAN_FILE_OPEN_ERROR);
};
WantFontInfo = TRUE;
InPrivateDict = FALSE;
TwoSubrs = FALSE;
rc = BuildFontInfo(FontP);
if (rc != 0) return(rc);
rc = 0;
do {
scan_token(inputP);
switch (tokenType) {
case TOKEN_EOF:
case TOKEN_NONE:
case TOKEN_INVALID:
if (tokenTooLong) return(SCAN_OUT_OF_MEMORY);
rc = SCAN_ERROR;
break;
case TOKEN_LITERAL_NAME:
tokenStartP[tokenLength] = '\0';
if (InPrivateDict ) {
if (0== strncmp(tokenStartP,"Subrs",5) ) {
rc = BuildSubrs(FontP);
break;
}
if (0== strncmp(tokenStartP,"CharStrings",11) ) {
rc = BuildCharStrings(FontP);
if ( (rc == SCAN_OK) ||(rc == SCAN_END) ) {
T1Close(inputP->data.fileP);
rc = GetType1Blues(FontP);
return(rc);
}
break;
}
rc = FindDictValue(FontP->Private);
if (rc != SCAN_OUT_OF_MEMORY)
rc = SCAN_OK;
break;
}
else
if (0== strncmp(tokenStartP,"Private",7) ) {
InPrivateDict = TRUE;
rc = BuildPrivate(FontP);
break;
}
else
if (WantFontInfo) {
rc = FindDictValue(FontP->fontInfoP);
if (rc != SCAN_OUT_OF_MEMORY)
rc = SCAN_OK;
break;
}
break;
case TOKEN_NAME:
if (0 == strncmp(tokenStartP,"eexec",5) ) {
if (starthex80) {
V = _XT1getc(fileP);
if ( V == 0X80 ) {
for (i=0;i<5;i++) V = _XT1getc(fileP);
}
else T1Ungetc(V,fileP);
}
filterFile.data.fileP = T1eexec(inputP->data.fileP);
if (filterFile.data.fileP == NULL) {
T1Close(inputFile.data.fileP);
return(SCAN_FILE_OPEN_ERROR);
}
inputP = &filterFile;
WantFontInfo = FALSE;
}
break;
}
}
while (rc ==0);
T1Close(inputP->data.fileP);
if (tokenTooLong) return(SCAN_OUT_OF_MEMORY);
return(rc);
}