source: trunk/pin/src/conv_afm.c@ 49

Last change on this file since 49 was 1, checked in by bart, 18 years ago

Initial checkin of PIN.EXE source code
this contains memory fixes for larger PPD files
File size: 70.2 KB
Line 
1/*DDK*************************************************************************/
2/* */
3/* COPYRIGHT Copyright (C) 1991, 2003 IBM Corporation */
4/* */
5/* The following IBM OS/2 source code is provided to you solely for */
6/* the purpose of assisting you in your development of OS/2 device */
7/* drivers. You may use this code in accordance with the IBM License */
8/* Agreement provided in the IBM Developer Connection Device Driver */
9/* Source Kit for OS/2. This Copyright statement may not be removed. */
10/* */
11/*****************************************************************************/
12
13// need full audit!
14// must eliminate RepWarning and RepError
15// declare all internal functions and variables static
16// remove outdated comments and code
17
18#pragma chars( signed )
19#pragma pack(1)
20/**************************************************************************
21 *
22 * SOURCE FILE NAME = AFM2BIN.C
23 *
24 * DESCRIPTIVE NAME = Metric File Compiler
25 *
26 *
27 * VERSION = V2.0
28 *
29 * DATE 02/25/88
30 *
31 * DESCRIPTION Converts an AFM fileand puts the output in an output file.
32 *
33 *
34 * FUNCTIONS
35 * report_warning
36 * report_error
37 * szIsEqual
38 * szMove
39 * GetBuffin
40 * UnGetLine
41 * EatWhite
42 * GetWord
43 * MapToken
44 * GetNumber
45 * GetFloat
46 * GetToken
47 * GetCharCode
48 * GetNextCharCode
49 * PrintLine
50 * CompareKPs
51 * ParseKernPairs
52 * ParseKernData
53 * ParseString
54 * ParseWeight
55 * ParseCharMetrics
56 * ParseCharBox
57 * ParseCharName
58 * ParseCharWidth
59 * ParseCharCode
60 * ParsePitchType
61 * OpenAfm
62 * FixCharWidths
63 * SetAfm
64 * ResetBuffout
65 * IncBuffout
66 * PutByte
67 * PutRgb
68 * PutWord
69 * PutDword
70 * PutString
71 * FillString
72 * WriteOutput
73 * AddExtension
74 * RemoveExtension
75 * GetArgs
76 * GetNextWord
77 * StrCopy
78 * ParseItalic
79 * ParseFamilyClass
80 *
81 * NOTES
82 *
83 * Format of the ".pfm" file generated:
84 * ====================================
85 *
86 * 1. Header (offsets to other sections)
87 * 2. Global font information
88 * 3. Character metrics
89 * 4. Pair Kerning data
90 * 5. Comment, Notice, etc. strings
91 * 6. Font metrics structure
92 *
93 *
94 * 1. Header
95 * ---------
96 * Offset Type
97 * 0000 word Version from StartFontMetrics
98 * (whole portion in high byte, fractional in low)
99 * 0002 word Offset to Global font information
100 * 0004 word Offset to Character metrics
101 * 0006 word Offset to Pair Kerning data
102 * 0008 word Offset to Strings section
103 * 000A word Offset to font metrics structure
104 * 000C word Size of the 5 above sections (global, metrics, etc.)
105 *
106 * Note: All sections (char metrics, kerning, etc) start on
107 * word-alinged boundaries.
108 *
109 *
110 *
111 * 2. Global font information
112 * --------------------------
113 * Offset Type
114 * 0000 word VariablePitch (ie, 1 for true, 0 for false)
115 * 0002 word*4 FontBBox
116 * 000A word CapHeight
117 *
118 *
119 *
120 * 3. Character metrics
121 * --------------------
122 * Offset Type
123 * 0000 byte Char code to output in a PostScript show command
124 * in order to display this character. 0=the font
125 * must be remapped in order to display this char,
126 * in which case just output the char directly.
127 * 0001 word Character width ("WX" argument)
128 * ......
129 *
130 *
131 *
132 * 4. Pair Kerning Data
133 * --------------------
134 * Offset Type
135 * 0000 word Char code 1
136 * 0002 word Char code 2
137 * 0004 word*2 Kerning vector ("KP/KPX" arguments)
138 * .....
139 * NOTE: If this font is codepage 850 (winthorn multi-codepage support)
140 * then the character codes above are actually the codes as
141 * remapped by the codepage vector -- presently in the range
142 * of 1-316.
143 *
144 *
145 *
146 * 5. Comment, Notice, Version, Fontname, EncodingString, and Weight strings
147 * -------------------------------------------------------------------------
148 * Offset Type
149 * 0000 asciiz FontName string (eg, "Times-RomanBold")
150 * asciiz Comment string
151 * asciiz Version string
152 * asciiz Notice string
153 * asciiz EncodingScheme (eg, "AdobeStandardEncoding")
154 * asciiz Weight (eg, "Bold")
155 *
156 *
157 *
158 * 6. Font metrics structure
159 * -------------------------
160 * CHAR szFamilyname[FACESIZE];
161 * CHAR szFacename[FACESIZE];
162 * SHORT idRegistry; / We always write as 0 /
163 * SHORT usCodePage; / 850 = Adobe standard encoding
164 * scheme; this font will
165 * offer winthorn multi-
166 * codepage support
167 * 0 = Adobe font-specific
168 * encoding; no multi-
169 * codepage support /
170 * LONG lEmHeight; / Height of emSquare (1000) /
171 * LONG lXHeight; / Height of lowercase x /
172 * LONG lMaxAscender; / Top of font bounding box /
173 * LONG lMaxDescender; / Bottom of font bounding box /
174 * LONG lLowerCaseAscent; / Top of tallest lowercase char /
175 * LONG lLowerCaseDescent; / Bottom of lowest lowercase descender /
176 * LONG lInternalLeading; / lMaxBaselineExt minus lEmHeight /
177 * LONG lExternalLeading; / Always zero /
178 * LONG lAveCharWidth; / Weighted average of char widths /
179 * LONG lMaxCharInc; / Widest character /
180 * LONG lEmInc; / Width of emSquare (1000) /
181 * LONG lMaxBaselineExt; / lMaxAscender + lMaxDescender /
182 * SHORT sCharSlope; / ItalicAngle field from afm file /
183 * SHORT sInlineDir; / 0 Degrees = left to right /
184 * SHORT sCharRot; / We always write as 0 /
185 * USHORT usWeightClass; / Font weight 1-9 /
186 * USHORT usWidthClass; / We always write as 5 (normal) /
187 * SHORT sXDeviceRes; / We always write as 1000 / !!CR
188 * SHORT sYDeviceRes; / We always write as 1000 / !!CR
189 * SHORT sFirstChar; / We always write as 1 /
190 * SHORT sLastChar; / For codepage 850, this is 316
191 * / For codepage 0, this is 255 /
192 * SHORT sDefaultChar; / We always write as 31 /
193 * SHORT sBreakChar; / We always write as 31 /
194 * SHORT sNominalPointSize; / We always write as 120 (12 pt.) /
195 * SHORT sMinimumPointSize; / We always write as 10 /
196 * SHORT sMaximumPointSize; / We always write as 7200 /
197 * USHORT fsType; / 0 = proportional, 1 = fixed /
198 * USHORT fsDefn; / 1 = outline /
199 * USHORT fsSelection; / We always write as 0 / !!CR
200 * USHORT fsCapabilities; / 0 = Can mix text and graphics /
201 * LONG lSubscriptXSize; / We always write as 0 /
202 * LONG lSubscriptYSize; / We always write as 0 /
203 * LONG lSubscriptXOffset; / We always write as 0 /
204 * LONG lSubscriptYOffset; / We always write as 0 /
205 * LONG lSuperscriptXSize; / We always write as 0 /
206 * LONG lSuperscriptYSize; / We always write as 0 /
207 * LONG lSuperscriptXOffset; / We always write as 0 /
208 * LONG lSuperscriptYOffset; / We always write as 0 /
209 * LONG lUnderscoreSize; / From afm file /
210 * LONG lUnderscorePosition; / From afm file /
211 * LONG lStrikeoutSize; / Based on hyphen character /
212 * LONG lStrikeoutPosition; / Based on hyphen character /
213 * SHORT sKerningPairs; / From afm file
214 * SHORT sFamilyClass; / Based on DCR 24415 /
215 * LONG lMatch; / We always write as 0 /
216 *
217 *
218 * STRUCTURES
219 *
220 * EXTERNAL REFERENCES
221 *
222 * EXTERNAL FUNCTIONS
223 *
224*/
225#include <os2.h>
226#include <stdio.h>
227#include <stdlib.h>
228#include <string.h>
229
230#include <ctype.h>
231//#include <search.h>
232/* #include <sys\types.h> */
233/* #include <sys\stat.h> */
234
235#include "afm.h"
236#include "mapping.h"
237
238BOOL fEcho = FALSE;
239BOOL fListStats = FALSE;
240BOOL fListMetrics = FALSE;
241BOOL fEOF = FALSE;
242BOOL fUnGetLine = FALSE;
243
244// Boolean flag to display all warnings, if TRUE (normally FALSE).
245BOOL FReportWarning = TRUE;
246
247FONTMETRICS fmFont;
248
249CharData *charmap; /* the conversion table from Adobe
250 character names into application
251 code points */
252AfmData afm;
253
254FILE *fhIn,*fhOut; /* file handles */
255char rgchIn[MAX_FNAMESIZE]; /* file names */
256char rgchOut[MAX_FNAMESIZE];
257
258SHORT cInline = 0;
259char rgbLine[MAX_LINESIZE]; /* current line of text being
260 processed */
261char *pszLine; /* ptr to the current location in the
262 line */
263SHORT cbBuffin; /* number of bytes in input buffer */
264char *pbBuffin; /* ptr to current location in input
265 buffer */
266char rgbBuffin[MAX_IBUFFSIZE];
267SHORT cbBuffout; /* number of bytes in output buffer */
268char *pbBuffout; /* ptr to current location in output
269 buffer */
270char rgbBuffout[MAX_OBUFFSIZE];
271#define ARBITRARY_CODEPAGE 65400 /* IBM CODEPAGE number for arbitrary
272 (/ /* glyphs */
273#define VOID void
274
275/*
276** Since this is used by the C runtime function qsort, this MUST be
277** defined as so to prevent the compiler from returning an error.
278*/
279int CompareKPs( const void *, const void * );
280VOID EatWhite( VOID );
281VOID FixCharWidths( VOID );
282BOOL GetBuffin( VOID );
283BOOL GetLine( VOID );
284SHORT GetNumber( VOID );
285SHORT GetToken( VOID );
286VOID OpenAfm( VOID );
287VOID ParseBaseFont( VOID );
288VOID ParseBoundingBox( VOID );
289VOID ParseCharBox( Rect * );
290SHORT ParseCharCode( VOID );
291VOID ParseCharMetrics( VOID );
292SHORT ParseCharWidth( VOID );
293VOID ParseFamilyClass( VOID );
294VOID ParseItalic( VOID );
295VOID ParseKernData( VOID );
296VOID ParseKernPairs( VOID );
297VOID ParsePitchType( VOID );
298VOID ParseWeight( VOID );
299VOID PrintLine( VOID );
300VOID ResetBuffout( VOID );
301VOID SetAfm( VOID );
302VOID UnGetLine( VOID );
303VOID WriteOutput( SHORT pass );
304VOID report_error( ErrType, char * );
305VOID report_warning( ErrType, char * );
306
307/***************************************************************************
308 *
309 * FUNCTION NAME = report_warning
310 *
311 * DESCRIPTION = prints the given message (err) with the given
312 * line fragment (pszLine), including the current
313 * input line number. If line fragment is NULL, then
314 * only the message is displayed.
315 *
316 * Display the warning message, only if '-w' is specified
317 * on the command line. This will cause FReportWarning to be
318 * set to TRUE.
319 *
320 * INPUT = err - index to error number
321 * pszLine - optional error text
322 *
323 * OUTPUT = NONE.
324 *
325 * RETURN-NORMAL = NONE.
326 * RETURN-ERROR = NONE.
327 *
328 ************************************************************************* */
329
330VOID report_warning(ErrType err,char *pszLineW)
331{
332
333 /*
334 ** Report warnings, only if '-w' was specified on the command line.
335 ** If FReportWarning == TRUE.
336 */
337 if (FReportWarning == TRUE)
338 {
339 if (cInline)
340 {
341 fprintf(stderr, "AFM2BIN: %s(%u): %s", rgchIn, cInline, errmsgs[err]);
342
343 if (pszLineW)
344 fprintf(stderr, " \"%s\"", pszLineW);
345 }
346
347 else
348 {
349 fprintf(stderr, "%s", errmsgs[err]);
350
351 if (pszLineW)
352 fprintf(stderr, " %s", pszLineW);
353 }
354 fprintf(stderr, "\n");
355
356 if (err == err_option || err == err_arg)
357 report_error(err_usage, NULL);
358 }
359}
360
361/***************************************************************************
362 *
363 * FUNCTION NAME = report_error
364 *
365 * DESCRIPTION = Same as report_warning, but terminates as well.
366 *
367 * INPUT = err - error number
368 * pszLine - optional text
369 *
370 * OUTPUT = NONE.
371 *
372 * RETURN-NORMAL = NONE.
373 * RETURN-ERROR = NONE
374 *
375 ************************************************************************* */
376
377VOID report_error( ErrType err, char *pszLineE )
378{
379 report_warning(err, pszLineE);
380 exit(1);
381}
382
383/***************************************************************************
384 *
385 * FUNCTION NAME = szIsEqual
386 *
387 * DESCRIPTION = Compares two NULL terminated strings.
388 *
389 * INPUT = sz1 - character string 1
390 * sz2 - character string 2
391 *
392 * OUTPUT = NONE.
393 *
394 * RETURN-NORMAL = Returns TRUE if they are equal,
395 * RETURN-ERROR = FALSE if they are different.
396 *
397 ************************************************************************* */
398
399BOOL szIsEqual(char *sz1,char *sz2)
400{
401
402 while (*sz1 && *sz2)
403 {
404
405 if (*sz1++ != *sz2++)
406 return (FALSE);
407 }
408 return (*sz1 == *sz2);
409}
410
411/***************************************************************************
412 *
413 * FUNCTION NAME = szMove
414 *
415 * DESCRIPTION = Copies a string. This function will copy at most
416 * the number of bytes in the destination area - 1.
417 *
418 * INPUT = szDest - destination string
419 * szSrc - source string
420 * cbDst - size of destination string
421 *
422 * OUTPUT = NONE.
423 *
424 * RETURN-NORMAL = NONE.
425 * RETURN-ERROR = NONE.
426 *
427 ************************************************************************* */
428
429VOID szMove(char *szDst,char *szSrc,SHORT cbDst)
430{
431
432 while (*szDst++ = *szSrc++)
433
434 if (--cbDst <= 0)
435 {
436 *(szDst-1) = 0;
437 break;
438 }
439}
440
441/***************************************************************************
442 *
443 * FUNCTION NAME = GetBuffin
444 *
445 * DESCRIPTION = Read a new buffer full of text from the input file.
446 *
447 * Note: If the end of file is encountered in this function
448 * then the program is aborted with an error message.
449 * Normally the program will stop processing the input
450 * when it sees the end of information keyword.
451 *
452 * INPUT = input file.
453 * OUTPUT = NONE.
454 *
455 * RETURN-NORMAL = NONE.
456 * RETURN-ERROR = NONE.
457 *
458 ************************************************************************* */
459
460BOOL GetBuffin( VOID )
461{
462 cbBuffin = 0;
463
464 if (!fEOF)
465 {
466 cbBuffin = fread( rgbBuffin, 1, sizeof(rgbBuffin), fhIn );
467
468 if (cbBuffin <= 0)
469 {
470 cbBuffin = 0;
471 fEOF = TRUE;
472 report_error(err_eof, NULL);
473 }
474 }
475 pbBuffin = rgbBuffin;
476 return (fEOF);
477}
478
479/***************************************************************************
480 *
481 * FUNCTION NAME = UnGetLine
482 *
483 * DESCRIPTION = This routine pushes the most recent line back into
484 * the input buffer.
485 *
486 * INPUT = NONE.
487 * OUTPUT = Line back into the input stream.
488 *
489 * RETURN-NORMAL = NONE.
490 * RETURN-ERROR = NONE.
491 *
492 ************************************************************************* */
493
494VOID UnGetLine( VOID )
495{
496 cInline--;
497 fUnGetLine = TRUE;
498 pszLine = rgbLine;
499}
500
501/***************************************************************************
502 *
503 * FUNCTION NAME = GetLine
504 *
505 * DESCRIPTION = This routine gets the next line of text out of the
506 * input buffer.
507 *
508 * INPUT = NONE.
509 * OUTPUT = NONE.
510 *
511 * RETURN-NORMAL = End of File.
512 * RETURN-ERROR = NONE.
513 *
514 ************************************************************************* */
515
516BOOL GetLine( VOID )
517{
518 SHORT cbLine;
519 char bCh;
520 cInline++;
521
522
523 if (fUnGetLine)
524 {
525 pszLine = rgbLine;
526 fUnGetLine = FALSE;
527 return (FALSE);
528 }
529 cbLine = 0;
530 pszLine = rgbLine;
531 *pszLine = 0;
532
533 if (!fEOF)
534 {
535
536 while (TRUE)
537 {
538
539 if (cbBuffin <= 0)
540 GetBuffin();
541
542 while (--cbBuffin >= 0)
543 {
544 bCh = *pbBuffin++;
545
546 if (bCh == '\n' || ++cbLine > (SHORT)sizeof(rgbLine))
547 {
548 *pszLine = 0;
549 pszLine = rgbLine;
550 EatWhite();
551
552 if (*pszLine != 0)
553 goto DONE;
554
555 pszLine = rgbLine;
556 cbLine = 0;
557 continue;
558 }
559 *pszLine++ = bCh;
560 }
561 }
562 }
563 *pszLine = 0;
564DONE:
565 pszLine = rgbLine;
566 return (fEOF);
567}
568
569/***************************************************************************
570 *
571 * FUNCTION NAME = EatWhite
572 *
573 * DESCRIPTION = This routine moves the input buffer pointer forward
574 * to the next non-white character.
575 *
576 * INPUT = NONE.
577 * OUTPUT = NONE.
578 *
579 * RETURN-NORMAL = NONE.
580 * RETURN-ERROR = NONE.
581 *
582 ************************************************************************* */
583
584VOID EatWhite( VOID )
585{
586
587 while (*pszLine && (*pszLine == ' ' || *pszLine == '\t'))
588 ++pszLine;
589}
590
591/***************************************************************************
592 *
593 * FUNCTION NAME = GetWord
594 *
595 * DESCRIPTION = This routine gets the next word delimited by white
596 * space from the input buffer.
597 *
598 * INPUT = szWord - destination
599 * cbWord - size of destination
600 *
601 * OUTPUT = NONE.
602 *
603 * RETURN-NORMAL = NONE.
604 * RETURN-ERROR = NONE.
605 *
606 ************************************************************************* */
607
608VOID GetWord(char *szWord,SHORT cbWord)
609{
610 char bCh;
611
612 EatWhite();
613
614 while (--cbWord > 0)
615 {
616
617 switch (bCh = *pszLine++)
618 {
619 case 0 :
620 --pszLine;
621 goto DONE;
622
623 case ' ' :
624 case '\t' :
625 --pszLine;
626 goto DONE;
627
628 case ';' :
629 *szWord++ = bCh;
630 goto DONE;
631 default :
632
633 *szWord++ = bCh;
634 break;
635 }
636 }
637DONE:
638 *szWord = 0;
639}
640
641/***************************************************************************
642 *
643 * FUNCTION NAME = MapToken
644 *
645 * DESCRIPTION = This routine maps an ascii key word into an
646 * enumerated token.
647 *
648 * INPUT = szWord - ptr to the ASCII keyword string
649 *
650 * OUTPUT = NONE.
651 *
652 * RETURN-NORMAL = The token value
653 * RETURN-ERROR = Token Unknown
654 *
655 ************************************************************************* */
656
657TokType MapToken(char *szWord)
658{
659 TokType iToken = 0;
660
661
662 while (iToken < tok_max)
663 {
664
665 if (szIsEqual(szWord, tokens[iToken]))
666 return (iToken);
667 ++iToken;
668 }
669 return (tok_unknown);
670}
671
672/***************************************************************************
673 *
674 * FUNCTION NAME = GetNumber
675 *
676 * DESCRIPTION = This routine parses an ASCII decimal number from the
677 * input file stream and returns its value.
678 *
679 * INPUT = NONE.
680 * OUTPUT = NONE.
681 *
682 * RETURN-NORMAL = Number Value.
683 * RETURN-ERROR = NONE.
684 *
685 ************************************************************************* */
686
687SHORT GetNumber( VOID )
688{
689 SHORT iVal;
690 BOOL fNegative;
691
692 fNegative = FALSE;
693 iVal = 0;
694 EatWhite();
695
696 if (*pszLine == '-')
697 {
698 fNegative = TRUE;
699 ++pszLine;
700 }
701
702 if (*pszLine < '0' || *pszLine > '9')
703 report_error(err_badnum, pszLine);
704
705 while (*pszLine >= '0' && *pszLine <= '9')
706 iVal = iVal *10+(*pszLine++-'0');
707
708 if (fNegative)
709 iVal = -iVal;
710
711 if (*pszLine == 0 || *pszLine == ' ' || *pszLine == '\t' || *pszLine == ';')
712 return (iVal);
713
714 return (0);
715}
716
717/***************************************************************************
718 *
719 * FUNCTION NAME = GetFloat
720 *
721 * DESCRIPTION = This routine parses an ASCII floating point decimal
722 * number from the input file stream and returns its
723 * value scaled by a specified amount.
724 *
725 * INPUT = iScale - amount to scale the value by
726 * OUTPUT = NONE.
727 *
728 * RETURN-NORMAL = value
729 * RETURN-ERROR = NONE.
730 *
731 ************************************************************************* */
732
733SHORT GetFloat(SHORT iScale)
734{
735 long lVal;
736 long lDivisor;
737 BOOL fNegative;
738
739 EatWhite();
740 fNegative = FALSE;
741 lVal = 0L;
742
743 if (*pszLine == '-')
744 {
745 fNegative = TRUE;
746 ++pszLine;
747 }
748
749 if (*pszLine < '0' || *pszLine > '9')
750 report_error(err_badreal, pszLine);
751
752 while (*pszLine >= '0' && *pszLine <= '9')
753 lVal = lVal *10+(*pszLine++-'0');
754 lDivisor = 1L;
755
756 if (*pszLine == '.')
757 {
758 ++pszLine;
759
760 while (*pszLine >= '0' && *pszLine <= '9')
761 {
762 lVal = lVal *10+(*pszLine++-'0');
763 lDivisor = lDivisor *10;
764 }
765 }
766 lVal = (lVal *iScale)/lDivisor;
767
768 if (fNegative)
769 lVal = -lVal;
770
771 if (*pszLine == 0 || *pszLine == ' ' || *pszLine == '\t' || *pszLine == ';')
772 return ((short)lVal);
773
774 return(0);
775}
776
777/***************************************************************************
778 *
779 * FUNCTION NAME = GetToken
780 *
781 * DESCRIPTION = Get the next token from the input stream.
782 *
783 * INPUT = NONE.
784 * OUTPUT = NONE.
785 *
786 * RETURN-NORMAL = NONE.
787 * RETURN-ERROR = NONE.
788 *
789 ************************************************************************* */
790
791SHORT GetToken( VOID )
792{
793 char szWord[80];
794
795
796 if (*pszLine == 0)
797
798 if (GetLine())
799 return (tok_max);
800 GetWord(szWord, sizeof(szWord));
801 return (MapToken(szWord));
802}
803
804/***************************************************************************
805 *
806 * FUNCTION NAME = GetCharCode
807 *
808 * DESCRIPTION = Given a name of a Postscript character, this
809 * function determines what its code point shall be
810 * (in the sense of winthorn multi- code page support)
811 * and what character code must be output in a
812 * Postscript "show" command in order to display this
813 * character. If the latter is zero, then a complete
814 * Postscript font remapping is necessary in order to
815 * display this character.
816 *
817 * INPUT = pcd - postscript character definition pointer
818 * OUTPUT = NONE.
819 *
820 * RETURN-NORMAL = NONE.
821 * RETURN-ERROR = NONE.
822 *
823 ************************************************************************* */
824
825void GetCharCode(CharData *pcd)
826{
827 register CharData *p;
828
829 p = charmap;
830
831 while (p->pszName)
832 {
833
834 if (szIsEqual(pcd->pszName, p->pszName))
835 {
836 pcd->iCP850Code = p->iCP850Code;
837 pcd->ipscriptCode = p->ipscriptCode;
838 return ;
839 }
840 ++p;
841 }
842
843// report_warning(err_unkchar, pcd->pszName);
844
845 pcd->iCP850Code = 0;
846 return ;
847}
848
849/***************************************************************************
850 *
851 * FUNCTION NAME = GetNextCharCode
852 *
853 * DESCRIPTION = This is similar to GetCharCode() above. But one
854 * Adobe character name may map to several code page
855 * 850 code points. This function continues scanning
856 * the list and returns matches until the end of the
857 * list is reached, at which time a null pointer is
858 * returned.
859 *
860 * INPUT = pcd - pcd pointer
861 * pcdRemainingList - list of pcds
862 *
863 *
864 * OUTPUT =
865 *
866 * RETURN-NORMAL =
867 * RETURN-ERROR =
868 *
869 ************************************************************************* */
870
871CharData *GetNextCharCode(CharData *pcd,CharData *pcdRemainingList)
872{
873 register CharData *p;
874
875 p = pcdRemainingList;
876
877 while (p != NULL && p->pszName)
878 {
879
880 if (szIsEqual(pcd->pszName, p->pszName))
881 {
882 pcd->iCP850Code = p->iCP850Code;
883 pcd->ipscriptCode = p->ipscriptCode;
884 return (p+1);
885 }
886 ++p;
887 }
888 pcd->iCP850Code = 0;
889 return (0);
890}
891
892/***************************************************************************
893 *
894 * FUNCTION NAME = PrintLine
895 *
896 * DESCRIPTION = Print a line of ASCII text with the white space
897 * stripped out.
898 *
899 * INPUT = NONE.
900 * OUTPUT = NONE.
901 *
902 * RETURN-NORMAL = NONE.
903 * RETURN-ERROR = NONE.
904 *
905 ************************************************************************* */
906
907VOID PrintLine( VOID )
908{
909 char szWord[80];
910
911
912 while (*pszLine)
913 {
914 GetWord(szWord, sizeof(szWord));
915 printf("%s ", szWord);
916 }
917 printf("\n");
918}
919
920/***************************************************************************
921 *
922 * FUNCTION NAME = CompareKPs
923 *
924 * DESCRIPTION = Returns a comparison of two kern pairs.
925 *
926 * INPUT = pKP1 - pointer to Kerning Pair 1
927 * pKP2 - pointer to Kerning Pair 2
928 *
929 * OUTPUT = NONE.
930 *
931 * RETURN-NORMAL = NONE.
932 * RETURN-ERROR = NONE.
933 *
934 ************************************************************************* */
935int CompareKPs( const void *pKP1, const void *pKP2 )
936{
937 return( (int) (((KPair *) pKP1)->iKey1 - ((KPair *) pKP2)->iKey1) );
938}
939
940/***************************************************************************
941 *
942 * FUNCTION NAME = ParseKernPairs
943 *
944 * DESCRIPTION = Parse the pairwise kerning data.
945 *
946 * INPUT = NONE.
947 * OUTPUT = NONE.
948 *
949 * RETURN-NORMAL = NONE.
950 * RETURN-ERROR = NONE.
951 *
952 ************************************************************************* */
953
954VOID ParseKernPairs( VOID )
955{
956 SHORT i;
957 SHORT iCh1;
958 SHORT iCh2;
959 TokType iToken;
960 SHORT cPairs;
961 char szWord[80];
962 CharData cd1,cd2;
963
964 cPairs = GetNumber();
965 i = 0;
966
967 while (i < cPairs)
968 {
969
970 if (GetLine())
971 break;
972
973 if (GetToken() != tok_kpx)
974 {
975 UnGetLine();
976 break;
977 }
978 GetWord(szWord, sizeof(szWord));
979 cd1.pszName = szWord;
980 GetCharCode(&cd1);
981 iCh1 = cd1.ipscriptCode;
982 GetWord(szWord, sizeof(szWord));
983 cd2.pszName = szWord;
984 GetCharCode(&cd2);
985 iCh2 = cd2.ipscriptCode;
986
987 /*
988 ** If either character is not in codepage 850 then throw away this
989 ** kerning pair.
990 */
991
992 if (iCh1 == 0 || iCh2 == 0)
993 {
994 --cPairs;
995 continue;
996 }
997 afm.rgKPairs[i].sAmount = GetNumber();
998 afm.rgKPairs[i].iKey1 = iCh1;
999 afm.rgKPairs[i].iKey2 = iCh2;
1000 ++i;
1001 }
1002 fmFont.sKerningPairs = afm.cKPairs = cPairs;
1003 GetLine();
1004 iToken = GetToken();
1005
1006 if (fEOF)
1007 report_error(err_eofin, tokens[tok_startkernpairs]);
1008
1009 else
1010
1011 if (iToken != tok_endkernpairs)
1012 report_error(err_expected, tokens[tok_endkernpairs]);
1013 qsort( &afm.rgKPairs[0], afm.cKPairs, sizeof( KPair ), CompareKPs );
1014}
1015
1016/***************************************************************************
1017 *
1018 * FUNCTION NAME = ParseKernData
1019 *
1020 * DESCRIPTION = Start processing the pairwise kerning data.
1021 *
1022 *
1023 * INPUT = NONE.
1024 * OUTPUT = NONE.
1025 *
1026 * RETURN-NORMAL = NONE.
1027 * RETURN-ERROR = NONE.
1028 *
1029 ************************************************************************* */
1030
1031VOID ParseKernData( VOID )
1032{
1033
1034 if (!GetLine())
1035 {
1036
1037 if (GetToken() == tok_startkernpairs)
1038 ParseKernPairs();
1039
1040 else
1041 report_warning(err_expected, tokens[tok_startkernpairs]);
1042 }
1043
1044 else
1045 report_warning(err_eof, NULL);
1046}
1047
1048/***************************************************************************
1049 *
1050 * FUNCTION NAME = ParseString
1051 *
1052 * DESCRIPTION = Move the next string from the input buffer into the
1053 * afm structure.
1054 *
1055 * INPUT = psz - destination string
1056 * maxsize - maximum size of destination string
1057 *
1058 * OUTPUT = NONE.
1059 *
1060 * RETURN-NORMAL = NONE.
1061 * RETURN-ERROR = NONE.
1062 *
1063 ************************************************************************* */
1064
1065VOID ParseString(char *psz,SHORT maxsize)
1066{
1067 EatWhite();
1068 szMove(psz, pszLine, maxsize);
1069}
1070
1071/***************************************************************************
1072 *
1073 * FUNCTION NAME = ParseWeight
1074 *
1075 * DESCRIPTION = Parse the fonts weight and set the corresponding entry
1076 * in the afm structure.
1077 *
1078 * INPUT = NONE.
1079 * OUTPUT = NONE.
1080 *
1081 * RETURN-NORMAL = NONE.
1082 * RETURN-ERROR = NONE.
1083 *
1084 ************************************************************************* */
1085
1086VOID ParseWeight( VOID )
1087{
1088 char szWord[80];
1089
1090 GetWord(szWord, sizeof(szWord));
1091
1092 if (szIsEqual(szWord, "Medium") || szIsEqual(szWord, "Roman") || szIsEqual
1093 (szWord, "Regular") || szIsEqual(szWord, "MediumCondensed"))
1094 fmFont.usWeightClass = FW_NORMAL;
1095
1096 else
1097
1098 if (szIsEqual(szWord, "Bold") || szIsEqual(szWord, "BoldCondensed"))
1099 fmFont.usWeightClass = FW_BOLD;
1100
1101 else
1102
1103 if (szIsEqual(szWord, "Demi"))
1104 fmFont.usWeightClass = FW_SEMIBOLD;
1105
1106 else
1107
1108 if (szIsEqual(szWord, "Light"))
1109 fmFont.usWeightClass = FW_LIGHT;
1110
1111 else
1112
1113 if (szIsEqual(szWord, "Book"))
1114 fmFont.usWeightClass = FW_SEMILIGHT;
1115
1116 else
1117
1118 if (szIsEqual(szWord, "Black"))
1119 fmFont.usWeightClass = FW_ULTRABOLD;
1120
1121 else
1122 report_warning(err_unkfontw, szWord);
1123 szMove(afm.szWeight, szWord, sizeof(szWord));
1124}
1125
1126/***************************************************************************
1127 *
1128 * FUNCTION NAME = ParseCharMetrics
1129 *
1130 * DESCRIPTION = Parse the character metrics entry in the input file
1131 * and set the width and bounding box in the afm structure.
1132 *
1133 * INPUT = NONE.
1134 * OUTPUT = NONE.
1135 *
1136 * RETURN-NORMAL = NONE.
1137 * RETURN-ERROR = NONE.
1138 *
1139 ************************************************************************* */
1140
1141VOID ParseCharMetrics( VOID )
1142{
1143 SHORT cChars;
1144 SHORT i;
1145 SHORT iWdth;
1146 SHORT iChar;
1147 long MWidth;
1148 long MHeight;
1149 long MRatio;
1150 Rect rcChar;
1151 CharData cd;
1152 char szName[20];
1153 CharData *pcdNext;
1154
1155 cChars = GetNumber();
1156
1157 for (i = 0; i < cChars; ++i)
1158 {
1159
1160 if (GetLine())
1161 report_error(err_eofin, tokens[tok_startcharmetrics]);
1162 iChar = ParseCharCode();
1163 iWdth = ParseCharWidth();
1164
1165 if (iWdth > (int)fmFont.lMaxCharInc)
1166 fmFont.lMaxCharInc = (LONG)iWdth;
1167 cd.pszName = szName;
1168 pcdNext = ParseCharName(&cd);
1169 ParseCharBox(&rcChar);
1170
1171 /*
1172 ** get the size of M square for the font. from this we will
1173 ** get the relative width of the font and fill in the
1174 ** font metrics usWidthClass field.
1175 */
1176
1177 if (!strcmp(cd.pszName, "M"))
1178 {
1179 MWidth = (long)(rcChar.right-rcChar.left);
1180 MHeight = (long)(rcChar.top-rcChar.bottom);
1181
1182 /*
1183 ** now get the width/height ratio.
1184 */
1185
1186 MRatio = (MWidth *100L)/MHeight;
1187
1188 if (MRatio <= 50L)
1189 fmFont.usWidthClass = ULTRACONDENSED;
1190
1191 else
1192
1193 if (MRatio <= 63L)
1194 fmFont.usWidthClass = EXTRACONDENSED;
1195
1196 else
1197
1198 if (MRatio <= 75L)
1199 fmFont.usWidthClass = CONDENSED;
1200
1201 else
1202
1203 if (MRatio <= 88L)
1204 fmFont.usWidthClass = SEMICONDENSED;
1205
1206 else
1207
1208 if (MRatio <= 112l)
1209 fmFont.usWidthClass = MEDIUM;
1210
1211 else
1212
1213 if (MRatio <= 124L)
1214 fmFont.usWidthClass = SEMIEXPANDED;
1215
1216 else
1217
1218 if (MRatio <= 149L)
1219 fmFont.usWidthClass = EXPANDED;
1220
1221 else
1222
1223 if (MRatio <= 199L)
1224 fmFont.usWidthClass = EXTRAEXPANDED;
1225
1226 else
1227 fmFont.usWidthClass = ULTRAEXPANDED;
1228 }
1229
1230 /*
1231 ** If this character is the hyphen, extract some
1232 ** info for the font metrics "strikeout" fields.
1233 */
1234
1235 if (!strcmp(cd.pszName, "hyphen"))
1236 {
1237 fmFont.lStrikeoutSize = rcChar.top-rcChar.bottom;
1238 fmFont.lStrikeoutPosition = (rcChar.top+rcChar.bottom)/2;
1239 }
1240
1241 do
1242 {
1243
1244 if (fListStats)
1245 printf("\042%s\042 maps to code point %d\n", cd.pszName, cd.iCP850Code)
1246 ;
1247 afm.rgcm[cd.iCP850Code].ipscriptCode = cd.ipscriptCode;
1248 afm.rgcm[cd.iCP850Code].cvec.x = iWdth;
1249 afm.rgcm[cd.iCP850Code].cvec.y = 0;
1250 afm.rgcm[cd.iCP850Code].rc.top = rcChar.top;
1251 afm.rgcm[cd.iCP850Code].rc.left = rcChar.left;
1252 afm.rgcm[cd.iCP850Code].rc.right = rcChar.right;
1253 afm.rgcm[cd.iCP850Code].rc.bottom = rcChar.bottom;
1254 pcdNext = GetNextCharCode(&cd, pcdNext);
1255 }
1256
1257 while (pcdNext);
1258 }
1259 GetLine();
1260
1261 if (GetToken() != tok_endcharmetrics)
1262 report_error(err_expected, tokens[tok_endcharmetrics]);
1263}
1264
1265/***************************************************************************
1266 *
1267 * FUNCTION NAME = ParseCharBox
1268 *
1269 * DESCRIPTION = Parse the character's bounding box and return its
1270 * dimensions in the destination rectangle.
1271 *
1272 * INPUT = prc - pointer to the destination rectangle
1273 *
1274 * OUTPUT = NONE.
1275 *
1276 * RETURN-NORMAL = NONE.
1277 * RETURN-ERROR = NONE.
1278 *
1279 ************************************************************************* */
1280
1281VOID ParseCharBox( Rect *prc )
1282{
1283 char szWord[16];
1284
1285 GetWord(szWord, sizeof(szWord));
1286
1287 if (szIsEqual("B", szWord))
1288 {
1289 prc->left = GetNumber();
1290 prc->bottom = GetNumber();
1291 prc->right = GetNumber();
1292 prc->top = GetNumber();
1293 }
1294
1295 else
1296 report_error(err_missingbbox, NULL);
1297 EatWhite();
1298
1299 if (*pszLine++ != ';')
1300 report_error(err_missingsemi, NULL);
1301}
1302
1303/***************************************************************************
1304 *
1305 * FUNCTION NAME = ParseCharName
1306 *
1307 * DESCRIPTION = Parse a character's name and return its name and
1308 * numeric values. Also return a pointer into the
1309 * character list to show how much of the list has
1310 * already been scanned.
1311 *
1312 * INPUT = pcd
1313 * OUTPUT = NONE.
1314 *
1315 * RETURN-NORMAL = NONE.
1316 * RETURN-ERROR = NONE.
1317 *
1318 ************************************************************************* */
1319
1320CharData *ParseCharName(CharData *pcd)
1321{
1322 register CharData *p;
1323
1324 EatWhite();
1325 GetWord(pcd->pszName, 16);
1326
1327 if (szIsEqual("N", pcd->pszName))
1328 {
1329 GetWord(pcd->pszName, 16);
1330 GetCharCode(pcd);
1331 }
1332
1333 else
1334 report_error(err_expectedname, NULL);
1335 EatWhite();
1336
1337 if (*pszLine++ != ';')
1338 report_error(err_missingsemi, NULL);
1339 p = charmap;
1340
1341 while (p->pszName)
1342 {
1343
1344 if (szIsEqual(pcd->pszName, p->pszName))
1345 {
1346 return (p+1);
1347 }
1348 ++p;
1349 }
1350 return (0);
1351}
1352
1353/***************************************************************************
1354 *
1355 * FUNCTION NAME = ParseCharWidth
1356 *
1357 * DESCRIPTION = Parse a character's width and return its numeric value.
1358 *
1359 * INPUT = NONE.
1360 * OUTPUT = NONE.
1361 *
1362 * RETURN-NORMAL = NONE.
1363 * RETURN-ERROR = NONE.
1364 *
1365 ************************************************************************* */
1366
1367SHORT ParseCharWidth( VOID )
1368{
1369 char szWord[16];
1370 register SHORT iWdth;
1371
1372 GetWord(szWord, sizeof(szWord));
1373
1374 if (szIsEqual(tokens[tok_wx], szWord))
1375 {
1376 iWdth = GetNumber();
1377
1378 if (iWdth == 0)
1379 report_error(err_zerocharw, NULL);
1380 EatWhite();
1381
1382 if (*pszLine++ != ';')
1383 report_error(err_missingsemi, NULL);
1384 }
1385
1386 else
1387 report_error(err_expected, tokens[tok_wx]);
1388 return (iWdth);
1389}
1390
1391/***************************************************************************
1392 *
1393 * FUNCTION NAME = ParseCharCode
1394 *
1395 * DESCRIPTION = Parse the ascii form of a character's code point and
1396 * return its numeric value.
1397 *
1398 * INPUT = NONE.
1399 * OUTPUT = NONE.
1400 *
1401 * RETURN-NORMAL = NONE.
1402 * RETURN-ERROR = NONE.
1403 *
1404 ************************************************************************* */
1405
1406SHORT ParseCharCode( VOID )
1407{
1408 SHORT iChar;
1409 char szWord[16];
1410
1411 iChar = 0;
1412 GetWord(szWord, sizeof(szWord));
1413
1414 if (szIsEqual("C", szWord))
1415 {
1416 iChar = GetNumber();
1417
1418 if (iChar == 0)
1419 report_error(err_badccode, NULL);
1420 EatWhite();
1421
1422 if (*pszLine++ != ';')
1423 report_error(err_missingsemi, NULL);
1424 }
1425 return (iChar);
1426}
1427
1428/***************************************************************************
1429 *
1430 * FUNCTION NAME = ParseBounding Box
1431 *
1432 * DESCRIPTION = Parse a character's bounding box and return its size
1433 * in the afm structure.
1434 *
1435 * INPUT = NONE.
1436 * OUTPUT = NONE.
1437 *
1438 * RETURN-NORMAL = NONE.
1439 * RETURN-ERROR = NONE.
1440 *
1441 ************************************************************************* */
1442
1443VOID ParseBoundingBox( VOID )
1444{
1445 afm.rcBBox.left = GetNumber();
1446 afm.rcBBox.bottom = GetNumber();
1447 afm.rcBBox.right = GetNumber();
1448 afm.rcBBox.top = GetNumber();
1449 fmFont.lMaxAscender = (LONG)afm.rcBBox.top;
1450 fmFont.lMaxDescender = (LONG)abs(afm.rcBBox.bottom);
1451 fmFont.lInternalLeading = (fmFont.lMaxAscender+fmFont.lMaxDescender)-1000;
1452}
1453
1454/***************************************************************************
1455 *
1456 * FUNCTION NAME = ParsePitchType
1457 *
1458 * DESCRIPTION = Parse the pitch type and set the variable pitch
1459 * flag in the afm structure.
1460 *
1461 * INPUT = NONE.
1462 * OUTPUT = NONE.
1463 *
1464 * RETURN-NORMAL = NONE.
1465 * RETURN-ERROR = NONE.
1466 *
1467 ************************************************************************* */
1468
1469VOID ParsePitchType( VOID )
1470{
1471 char szWord[16];
1472
1473 EatWhite();
1474 GetWord(szWord, sizeof(szWord));
1475
1476 if (szIsEqual("true", szWord))
1477 {
1478 afm.fVariablePitch = FALSE;
1479// fmFont.fsType = 1; //@DBCS
1480 fmFont.fsType |= FM_TYPE_FIXED; //@DBCS
1481 }
1482
1483 else
1484 {
1485 afm.fVariablePitch = TRUE;
1486// fmFont.fsType = 0; //@DBCS
1487 fmFont.fsType &=~ FM_TYPE_FIXED; //@DBCS
1488 }
1489}
1490
1491/***************************************************************************
1492 *
1493 * FUNCTION NAME = OpenAfm
1494 *
1495 * DESCRIPTION = Initialize the afm structure, and open the files.
1496 *
1497 * INPUT = NONE.
1498 * OUTPUT = NONE.
1499 *
1500 * RETURN-NORMAL = NONE.
1501 * RETURN-ERROR = NONE.
1502 *
1503 ************************************************************************* */
1504
1505VOID OpenAfm( VOID )
1506{
1507 SHORT i;
1508
1509 /*
1510 ** global stuff
1511 */
1512
1513 afm.iMaxWidth = 0;
1514 afm.version = 0;
1515 afm.szFontName[0] = 0;
1516 afm.szComment[0] = 0;
1517 afm.fVariablePitch = FALSE;
1518 fmFont.idRegistry = 0;
1519 fmFont.usCodePage = CODE_PAGE;
1520 fmFont.lEmHeight = 1000L;
1521 fmFont.lXHeight = 0L;
1522 fmFont.lMaxAscender = 0L;
1523 fmFont.lMaxDescender = 0L;
1524 fmFont.lLowerCaseAscent = 0L;
1525 fmFont.lLowerCaseDescent = 0L;
1526 fmFont.lInternalLeading = 0L;
1527 fmFont.lExternalLeading = 0L;
1528 fmFont.lAveCharWidth = 0L;
1529 fmFont.lMaxCharInc = 0L;
1530 fmFont.lEmInc = 1000L;
1531 fmFont.lMaxBaselineExt = 0L;
1532 fmFont.sCharSlope = 0;
1533 fmFont.sInlineDir = 0;
1534 fmFont.sCharRot = 0;
1535 fmFont.usWeightClass = FW_NORMAL;
1536 fmFont.usWidthClass = 5;
1537 fmFont.sXDeviceRes = 1000;
1538 fmFont.sYDeviceRes = 1000;
1539 fmFont.sFirstChar = FIRST_CHAR;
1540 fmFont.sLastChar = LAST_CHAR;
1541 fmFont.sDefaultChar = 31;
1542 fmFont.sBreakChar = 31;
1543 fmFont.sNominalPointSize = 120;
1544 fmFont.sMinimumPointSize = 10;
1545 fmFont.sMaximumPointSize = 7200;
1546 fmFont.fsType = 0;
1547 fmFont.fsDefn = 1;
1548 fmFont.fsSelection = 0;
1549 fmFont.fsCapabilities = 0;
1550 fmFont.lSubscriptXSize = 0L;
1551 fmFont.lSubscriptYSize = 0L;
1552 fmFont.lSubscriptXOffset = 0L;
1553 fmFont.lSubscriptYOffset = 0L;
1554 fmFont.lSuperscriptXSize = 0L;
1555 fmFont.lSuperscriptYSize = 0L;
1556 fmFont.lSuperscriptXOffset = 0L;
1557 fmFont.lSuperscriptYOffset = 0L;
1558 fmFont.lUnderscoreSize = 0L;
1559 fmFont.lUnderscorePosition = 0L;
1560 fmFont.lStrikeoutSize = 0L;
1561 fmFont.lStrikeoutPosition = 0L;
1562 fmFont.sKerningPairs = afm.cKPairs = 0;
1563 fmFont.sFamilyClass = 0;
1564 fmFont.lMatch = 0L;
1565
1566 /*
1567 ** Character metrics stuff
1568 */
1569
1570 for (i = 0; i < MAX_CHARS; afm.rgcm[i++].ipscriptCode = -1)
1571 ;
1572 fhIn = fopen( rgchIn, "r" );
1573
1574 if (fhIn == NULL )
1575 report_error(err_cantopen, rgchIn);
1576// fhOut = fopen( rgchOut, "wb" );
1577
1578// if (fhOut == NULL )
1579// report_error(err_cantcreate, rgchOut);
1580
1581 // printf("Converting %s to %s\n", rgchIn, rgchOut);
1582}
1583
1584/***************************************************************************
1585 *
1586 * FUNCTION NAME = FixCharWidths
1587 *
1588 * DESCRIPTION = Any necessary character that this font does not
1589 * support will currently have ipscriptCode == -1.
1590 * Force all of these characters to map to (and have
1591 * character metrics of) the default character,
1592 * typically a blank.
1593 *
1594 * INPUT = NONE.
1595 * OUTPUT = NONE.
1596 *
1597 * RETURN-NORMAL = NONE.
1598 * RETURN-ERROR = NONE.
1599 *
1600 ************************************************************************* */
1601
1602VOID FixCharWidths( VOID )
1603{
1604 CMData cmSpace;
1605 SHORT i;
1606
1607 cmSpace = afm.rgcm[32];
1608
1609 for (i = 0; i < MAX_CHARS; ++i)
1610
1611 if (afm.rgcm[i].ipscriptCode == -1)
1612 afm.rgcm[i] = cmSpace;
1613}
1614
1615/***************************************************************************
1616 *
1617 * FUNCTION NAME = SetAfm
1618 *
1619 * DESCRIPTION = Finish setting the character and font metrics in the
1620 * afm to their proper values.
1621 *
1622 * INPUT = NONE.
1623 * OUTPUT = NONE.
1624 *
1625 * RETURN-NORMAL = NONE.
1626 * RETURN-ERROR = NONE.
1627 *
1628 ************************************************************************* */
1629
1630VOID SetAfm( VOID )
1631{
1632 long lSumx = 0L;
1633 register SHORT i;
1634 register SHORT x;
1635
1636
1637 if (!afm.fVariablePitch)
1638 {
1639 x = afm.rgcm[fmFont.sFirstChar].cvec.x;
1640
1641 for (i = fmFont.sFirstChar; i <= (fmFont.sFirstChar+fmFont.sLastChar); ++i)
1642 afm.rgcm[i].cvec.x = x;
1643 }
1644
1645 /*
1646 ** set average width, lowercase ascent, and lowercase descent
1647 */
1648
1649 for (i = 'a'; i <= 'z'; i++)
1650 {
1651 lSumx += (long)afm.rgcm[i].cvec.x *iWeightFactor[i-'a'];
1652
1653 if (afm.rgcm[i].rc.top > fmFont.lLowerCaseAscent)
1654 fmFont.lLowerCaseAscent = afm.rgcm[i].rc.top;
1655
1656 if (abs(afm.rgcm[i].rc.bottom) > fmFont.lLowerCaseDescent)
1657 fmFont.lLowerCaseDescent = abs(afm.rgcm[i].rc.bottom);
1658 }
1659 lSumx += (long)afm.rgcm[' '].cvec.x *iWeightFactor[i-'a'];
1660 fmFont.lAveCharWidth = lSumx/1000L;
1661
1662 /*
1663 ** set maximum width
1664 */
1665
1666 for (i = fmFont.sFirstChar; i <= fmFont.sLastChar; ++i)
1667
1668 if (afm.rgcm[i].cvec.x > afm.iMaxWidth)
1669 afm.iMaxWidth = afm.rgcm[i].cvec.x;
1670
1671 /*
1672 ** If this font cannot provide winthorn multi-codepage support,
1673 ** we better change some of the fields in the font metrics.
1674 */
1675
1676 if (szIsEqual(afm.szEncodingScheme, "FontSpecific"))
1677 {
1678 fmFont.sFirstChar = 1;
1679 fmFont.sLastChar = 255;
1680 fmFont.usCodePage = ARBITRARY_CODEPAGE;
1681 }
1682
1683 /*
1684 ** Make sure the strikeout size and position are set reasonably
1685 */
1686
1687 if ((!fmFont.lStrikeoutSize) || (!fmFont.lStrikeoutPosition))
1688 {
1689 fmFont.lStrikeoutPosition = 300L;
1690
1691 if (fmFont.lUnderscoreSize)
1692 fmFont.lStrikeoutSize = fmFont.lUnderscoreSize;
1693
1694 else
1695 fmFont.lStrikeoutSize = 66L;
1696 }
1697
1698 /*
1699 ** Set the internal leading field
1700 */
1701
1702 if (fmFont.lEmHeight)
1703 fmFont.lInternalLeading = (fmFont.lMaxAscender+fmFont.lMaxDescender)-1000L;
1704}
1705
1706/***************************************************************************
1707 *
1708 * FUNCTION NAME = ResetBuffout
1709 *
1710 * DESCRIPTION = This function resets output buffer.
1711 *
1712 * INPUT = NONE.
1713 * OUTPUT = NONE.
1714 *
1715 * RETURN-NORMAL = NONE.
1716 * RETURN-ERROR = NONE.
1717 *
1718 ************************************************************************* */
1719
1720VOID ResetBuffout( VOID )
1721{
1722 pbBuffout = rgbBuffout;
1723 cbBuffout = 0;
1724}
1725
1726/***************************************************************************
1727 *
1728 * FUNCTION NAME = IncBuffout
1729 *
1730 * DESCRIPTION = These functions adjust cbBuffout by the amount indicated.
1731 * If the amount is zero, the offset is adjusted to be
1732 * word-aligned.
1733 *
1734 * INPUT = i - amount to increment
1735 *
1736 * OUTPUT = NONE.
1737 *
1738 * RETURN-NORMAL = NONE.
1739 * RETURN-ERROR = NONE.
1740 *
1741 ************************************************************************* */
1742
1743IncBuffout(SHORT i)
1744{
1745
1746 if ((!i) && (cbBuffout&1))
1747 {
1748 cbBuffout++;
1749 pbBuffout++;
1750 }
1751
1752 else
1753 {
1754 cbBuffout += i;
1755
1756 if (cbBuffout >= (SHORT)sizeof(rgbBuffout))
1757 report_error(err_overflow, NULL);
1758 }
1759 return (cbBuffout);
1760}
1761
1762/***************************************************************************
1763 *
1764 * FUNCTION NAME = PutByte
1765 *
1766 * DESCRIPTION = This function writes a byte to the output buffer.
1767 *
1768 * INPUT = iByte - byte to write
1769 *
1770 * OUTPUT = NONE.
1771 *
1772 * RETURN-NORMAL = NONE.
1773 * RETURN-ERROR = NONE.
1774 *
1775 ************************************************************************* */
1776
1777VOID PutByte( SHORT iByte)
1778{
1779 *pbBuffout++ = iByte&0x0ff;
1780 IncBuffout(1);
1781}
1782
1783/***************************************************************************
1784 *
1785 * FUNCTION NAME = PutRgb
1786 *
1787 * DESCRIPTION = This function writes an array of bytes to the output
1788 * buffer.
1789 *
1790 * INPUT = pb - array of bytes
1791 * cb - count of bytes
1792 *
1793 * OUTPUT = NONE.
1794 *
1795 * RETURN-NORMAL = NONE.
1796 * RETURN-ERROR = NONE.
1797 *
1798 ************************************************************************* */
1799
1800VOID PutRgb(char *pb,SHORT cb)
1801{
1802
1803 while (--cb >= 0)
1804 PutByte(*pb++);
1805}
1806
1807/***************************************************************************
1808 *
1809 * FUNCTION NAME = PutWord
1810 *
1811 * DESCRIPTION = These functions write a word to the output buffer.
1812 *
1813 * INPUT = iWord - word to write
1814 *
1815 * OUTPUT = NONE.
1816 *
1817 * RETURN-NORMAL = NONE.
1818 * RETURN-ERROR = NONE.
1819 *
1820 ************************************************************************* */
1821
1822VOID PutWord( SHORT iWord)
1823{
1824 *pbBuffout++ = iWord&0x0ff;
1825 *pbBuffout++ = (iWord >> 8)&0x0ff;
1826 IncBuffout(2);
1827}
1828
1829/***************************************************************************
1830 *
1831 * FUNCTION NAME = PutDword
1832 *
1833 * DESCRIPTION = These functions writes a long word to the output buffer.
1834 *
1835 * INPUT = lWord - double word to output
1836 *
1837 * OUTPUT = NONE.
1838 *
1839 * RETURN-NORMAL = NONE.
1840 * RETURN-ERROR = NONE.
1841 *
1842 ************************************************************************* */
1843
1844VOID PutDword(long lWord)
1845{
1846 PutWord((int)(lWord&0x0ffffL));
1847 lWord >>= 16;
1848 PutWord((int)(lWord&0x0ffffL));
1849}
1850
1851/***************************************************************************
1852 *
1853 * FUNCTION NAME = PutString
1854 *
1855 * DESCRIPTION = This function writes a null terminated string to the
1856 * output file.
1857 *
1858 * INPUT = psz - string to output
1859 *
1860 * OUTPUT = NONE.
1861 *
1862 * RETURN-NORMAL = NONE.
1863 * RETURN-ERROR = NONE.
1864 *
1865 ************************************************************************* */
1866
1867VOID PutString(char *psz)
1868{
1869 SHORT bCh;
1870
1871 do
1872 {
1873 bCh = *pbBuffout++ = *psz++;
1874 IncBuffout(1);
1875 }
1876
1877 while (bCh);
1878}
1879
1880/***************************************************************************
1881 *
1882 * FUNCTION NAME = FillString
1883 *
1884 * DESCRIPTION = This function writes a null terminated string to
1885 * the output file, filling the rest of the indicated
1886 * buffer with zeroes.
1887 *
1888 * INPUT = psz - string to write
1889 * iSize - total number of bytes
1890 *
1891 * OUTPUT = NONE.
1892 *
1893 * RETURN-NORMAL = NONE.
1894 * RETURN-ERROR = NONE.
1895 *
1896 ************************************************************************* */
1897
1898VOID FillString(char *psz,SHORT iSize)
1899{
1900 SHORT bCh;
1901 char *p1sz;
1902
1903 p1sz = psz; /* mark beginning */
1904
1905 while (*psz)
1906 { /* fill in the string... */
1907 *pbBuffout++ = *psz++;
1908 IncBuffout(1);
1909 }
1910 bCh = iSize-(psz-p1sz); /* ...calculate # nulls */
1911
1912 do
1913 { /* & zero the rest of the buffer */
1914 *pbBuffout++ = 0;
1915 IncBuffout(1);
1916 }
1917
1918 while (--bCh);
1919}
1920
1921/***************************************************************************
1922 *
1923 * FUNCTION NAME = WriteOutput
1924 *
1925 * DESCRIPTION = This function writes the device font info structure
1926 * to the output file.
1927 *
1928 * INPUT = pass
1929 *
1930 * OUTPUT = NONE.
1931 *
1932 * RETURN-NORMAL = NONE.
1933 * RETURN-ERROR = NONE.
1934 *
1935 ************************************************************************* */
1936
1937VOID WriteOutput( SHORT pass )
1938{
1939 char c;
1940 register SHORT i, j, count;
1941 static unsigned offGlobal;
1942 static unsigned offCharMetrics;
1943 static unsigned offPairKerning;
1944 static unsigned offStrings;
1945 static unsigned offMetrics;
1946 static unsigned sizeAll;
1947 static char outstr[] = " %-20.20s %.50s\n";
1948 static char outint[] = " %-20.20s %d\n";
1949 static char *boolstr[] =
1950 {
1951 "false","true"
1952 }
1953 ;
1954 static char outrect[] = " %-20.20s %d,%d,%d,%d\n";
1955 static char outmetric[] = " '%c' %4d,%-4d [%4d,%4d,%4d,%4d]\n";
1956
1957
1958 if (pass == 1 && fListStats)
1959 {
1960 printf("\nResults:\n");
1961 printf(outstr, tokens[tok_fontname], afm.szFontName);
1962 printf(outstr, tokens[tok_comment], afm.szComment);
1963 printf(outstr, tokens[tok_weight], afm.szWeight);
1964 printf(outint, tokens[tok_weight], fmFont.usWeightClass);
1965 printf(outint, tokens[tok_italicangle], fmFont.sCharSlope);
1966 printf(outstr, tokens[tok_isfixedpitch], boolstr[!afm.fVariablePitch]);
1967 printf(outrect, tokens[tok_fontbox], afm.rcBBox.left, afm.rcBBox.bottom,
1968 afm.rcBBox.right, afm.rcBBox.top);
1969 printf(outint, tokens[tok_underlineposition], fmFont.lUnderscorePosition);
1970 printf(outint, tokens[tok_underlinethickness], fmFont.lUnderscoreSize);
1971 printf(outint, tokens[tok_ascender], (WORD)fmFont.lMaxAscender);
1972 printf(outint, tokens[tok_descender], (WORD)fmFont.lMaxDescender);
1973 printf(outstr, tokens[tok_version], afm.szVersion);
1974 printf(outstr, tokens[tok_notice], afm.szNotice);
1975 }
1976 ResetBuffout();
1977 PutWord(afm.version);
1978 PutWord(offGlobal);
1979 PutWord(offCharMetrics);
1980 PutWord(offPairKerning);
1981 PutWord(offStrings);
1982 PutWord(offMetrics);
1983 PutWord(sizeAll);
1984
1985 /*
1986 ** write the global font info
1987 */
1988
1989 offGlobal = IncBuffout(0);
1990 PutWord(afm.fVariablePitch);
1991 PutWord(afm.rcBBox.left);
1992 PutWord(afm.rcBBox.bottom);
1993 PutWord(afm.rcBBox.right);
1994 PutWord(afm.rcBBox.top);
1995 PutWord(afm.iCapHeight);
1996
1997 /*
1998 ** character metrics
1999 */
2000
2001 offCharMetrics = IncBuffout(0);
2002
2003 for (i = fmFont.sFirstChar; i <= (fmFont.sFirstChar+fmFont.sLastChar); i++)
2004 {
2005 PutByte((BYTE)afm.rgcm[i].ipscriptCode);
2006 PutWord(afm.rgcm[i].cvec.x);
2007
2008 if (pass == 1 && fListMetrics)
2009 {
2010
2011 if (i == fmFont.sFirstChar)
2012 printf("\nMetrics:\n");
2013 c = i;
2014
2015 if (!isprint(c))
2016 c = ' ';
2017 printf(outmetric, c, afm.rgcm[i].cvec.x, afm.rgcm[i].cvec.y, afm.rgcm[i].
2018 rc.left, afm.rgcm[i].rc.bottom, afm.rgcm[i].rc.right, afm.rgcm[i].
2019 rc.top);
2020 }
2021 }
2022
2023 /*
2024 ** pair kerning data
2025 */
2026
2027 offPairKerning = IncBuffout(0);
2028
2029 i = 0;
2030 while ( i < afm.cKPairs )
2031 {
2032 /* Count num pairs with same key1 */
2033 count = 0;
2034 for (j = i; afm.rgKPairs[i].iKey1 == afm.rgKPairs[j].iKey1; j++ )
2035 {
2036 count++;
2037 }
2038
2039 PutByte((BYTE)(afm.rgKPairs[i].iKey1));
2040 PutByte( (BYTE)count );
2041
2042 for ( j = 0; j < count; j++, i++ )
2043 {
2044 PutByte((BYTE)(afm.rgKPairs[i].iKey2));
2045 PutWord(afm.rgKPairs[i].sAmount);
2046 }
2047 }
2048
2049 /*
2050 ** strings
2051 */
2052
2053 offStrings = IncBuffout(0);
2054 PutString(afm.szFontName);
2055/*PutString(afm.szComment); LMT */
2056/*PutString(afm.szVersion); LMT */
2057/*PutString(afm.szNotice); LMT */
2058/*PutString(afm.szEncodingScheme); LMT */
2059/*PutString(afm.szWeight); LMT */
2060
2061 /*
2062 ** font metrics
2063 */
2064
2065 offMetrics = IncBuffout(0);
2066 FillString(fmFont.szFamilyname, FACESIZE);
2067 FillString(fmFont.szFacename, FACESIZE);
2068 PutWord(fmFont.idRegistry);
2069 PutWord(fmFont.usCodePage);
2070 PutDword(fmFont.lEmHeight);
2071 PutDword(fmFont.lXHeight);
2072 PutDword(fmFont.lMaxAscender);
2073 PutDword(fmFont.lMaxDescender);
2074 PutDword(fmFont.lLowerCaseAscent);
2075 PutDword(fmFont.lLowerCaseDescent);
2076 PutDword(fmFont.lInternalLeading);
2077 PutDword(fmFont.lExternalLeading);
2078 PutDword(fmFont.lAveCharWidth);
2079 PutDword(fmFont.lMaxCharInc);
2080 PutDword(fmFont.lEmInc);
2081 PutDword(fmFont.lMaxAscender+fmFont.lMaxDescender);
2082 PutWord(fmFont.sCharSlope);
2083 PutWord(fmFont.sInlineDir);
2084 PutWord(fmFont.sCharRot);
2085 PutWord(fmFont.usWeightClass);
2086 PutWord(fmFont.usWidthClass);
2087 PutWord(fmFont.sXDeviceRes);
2088 PutWord(fmFont.sYDeviceRes);
2089 PutWord(fmFont.sFirstChar);
2090 PutWord(fmFont.sLastChar);
2091 PutWord(fmFont.sDefaultChar);
2092 PutWord(fmFont.sBreakChar);
2093 PutWord(fmFont.sNominalPointSize);
2094 PutWord(fmFont.sMinimumPointSize);
2095 PutWord(fmFont.sMaximumPointSize);
2096 PutWord(fmFont.fsType);
2097 PutWord(fmFont.fsDefn);
2098 PutWord(fmFont.fsSelection);
2099 PutWord(fmFont.fsCapabilities);
2100 PutDword(fmFont.lSubscriptXSize);
2101 PutDword(fmFont.lSubscriptYSize);
2102 PutDword(fmFont.lSubscriptXOffset);
2103 PutDword(fmFont.lSubscriptYOffset);
2104 PutDword(fmFont.lSuperscriptXSize);
2105 PutDword(fmFont.lSuperscriptYSize);
2106 PutDword(fmFont.lSuperscriptXOffset);
2107 PutDword(fmFont.lSuperscriptYOffset);
2108 PutDword(fmFont.lUnderscoreSize);
2109 PutDword(fmFont.lUnderscorePosition);
2110 PutDword(fmFont.lStrikeoutSize);
2111 PutDword(fmFont.lStrikeoutPosition);
2112 PutWord(fmFont.sKerningPairs);
2113 PutWord(fmFont.sFamilyClass);
2114 PutDword(fmFont.lMatch);
2115
2116 /*
2117 ** total size
2118 */
2119
2120 sizeAll = IncBuffout(0)-offGlobal;
2121
2122 if (pass == 1)
2123 WriteOutput(2);
2124
2125 else
2126 {
2127
2128 if (cbBuffout && fhOut)
2129 fwrite(rgbBuffout, 1, cbBuffout, fhOut);
2130 }
2131}
2132
2133/***************************************************************************
2134 *
2135 * FUNCTION NAME = AddExtension
2136 *
2137 * DESCRIPTION = If given filename has no extension, add the given default.
2138 *
2139 * INPUT = pszName - filename
2140 * pszDefext - default filename extension
2141 *
2142 * OUTPUT = NONE.
2143 *
2144 * RETURN-NORMAL = NONE.
2145 * RETURN-ERROR = NONE.
2146 *
2147 ************************************************************************* */
2148
2149VOID AddExtension(char *pszName,char *pszDefext)
2150{
2151 char c;
2152 SHORT l;
2153 register char *p;
2154
2155 l = strlen(pszName);
2156 p = pszName+l;
2157 c = '.';
2158
2159 while (l-- > 0)
2160 {
2161 c = *--p;
2162
2163 if (c == '.' || c == '\\' || c == ':')
2164 break;
2165 }
2166
2167 if (c != '.')
2168 strcat(p, pszDefext);
2169}
2170
2171/***************************************************************************
2172 *
2173 * FUNCTION NAME = RemoveExtension
2174 *
2175 * DESCRIPTION = Removes any extension from the given filename.
2176 *
2177 * INPUT = pszName - filename
2178 *
2179 * OUTPUT = NONE.
2180 *
2181 * RETURN-NORMAL = NONE.
2182 * RETURN-ERROR = NONE.
2183 *
2184 ************************************************************************* */
2185
2186VOID RemoveExtension(char *pszName)
2187{
2188 char c;
2189 SHORT l;
2190 register char *p;
2191
2192 l = strlen(pszName);
2193 p = pszName+l;
2194 c = '.';
2195
2196 while (l-- > 0)
2197 {
2198 c = *--p;
2199
2200 if (c == '.' || c == '\\' || c == ':')
2201 break;
2202 }
2203
2204 if (c == '.')
2205 *p = 0;
2206}
2207
2208
2209#if 0
2210/***************************************************************************
2211 *
2212 * FUNCTION NAME = GetArgs
2213 *
2214 * DESCRIPTION = Parses all args passed to the program.
2215 *
2216 * INPUT = argc - argument count
2217 * argv - array of pointers to arguments
2218 *
2219 * OUTPUT = NONE.
2220 *
2221 * RETURN-NORMAL = NONE.
2222 * RETURN-ERROR = NONE.
2223 *
2224 ************************************************************************* */
2225
2226VOID GetArgs(SHORT argc,char **argv)
2227{
2228 BOOL argerror = FALSE;
2229 register char c,*p;
2230
2231 report_warning(err_ver, NULL);
2232
2233 if (argc <= 1)
2234 argerror = TRUE;
2235
2236 while (--argc)
2237 {
2238 p = *++argv;
2239
2240 if (*p == '-' || *p == '/')
2241 {
2242
2243 while (c = tolower( *++p ))
2244 {
2245
2246 switch (c)
2247 {
2248 case 'e' :
2249 fEcho = TRUE;
2250 break;
2251 case 's' :
2252 fListStats = TRUE;
2253 break;
2254 case 'm' :
2255 fListMetrics = TRUE;
2256 break;
2257 case 'v' :
2258 fListStats = TRUE;
2259 fListMetrics = TRUE;
2260 break;
2261
2262
2263 // Add conditional for displaying warnings.
2264 case 'w':
2265 FReportWarning = TRUE;
2266 break;
2267
2268 default :
2269 argerror = TRUE;
2270 report_warning(err_option, p);
2271 break;
2272 }
2273 }
2274 }
2275
2276 else
2277 {
2278
2279 if (!rgchIn[0])
2280 {
2281 szMove(rgchIn, p, sizeof(rgchIn));
2282 AddExtension(rgchIn, DEF_IEXT);
2283 }
2284
2285 else
2286
2287 if (!rgchOut[0])
2288 {
2289 szMove(rgchOut, p, sizeof(rgchOut));
2290 AddExtension(rgchOut, DEF_OEXT);
2291 }
2292
2293 else
2294 {
2295 argerror = TRUE;
2296 report_warning(err_arg, p);
2297 }
2298 }
2299 }
2300
2301 if (rgchIn[0] && !rgchOut[0])
2302 {
2303 szMove(rgchOut, rgchIn, sizeof(rgchIn));
2304 RemoveExtension(rgchOut);
2305 AddExtension(rgchOut, DEF_OEXT);
2306 }
2307 strlwr(rgchIn);
2308 strlwr(rgchOut);
2309
2310 if (rgchIn[0])
2311
2312 if (szIsEqual(rgchIn, rgchOut))
2313 {
2314 argerror = TRUE;
2315 report_warning(err_badoutput, NULL);
2316 }
2317
2318 if (argerror)
2319 report_error(err_usage, NULL);
2320}
2321#endif
2322
2323
2324/***************************************************************************
2325 *
2326 * FUNCTION NAME = GetNextWord
2327 *
2328 * DESCRIPTION = This routine copies the next word delimited by
2329 * white space from the source buffer to the
2330 * destination buffer and NULL terminates it. It
2331 * returns a pointer to the end position of the word
2332 * in the source buffer.
2333 *
2334 * INPUT = pszSrcStr - pointer to source area
2335 * pszDestStr - pointer to desitnation area
2336 *
2337 * OUTPUT = NONE.
2338 *
2339 * RETURN-NORMAL = NONE.
2340 * RETURN-ERROR = NONE.
2341 *
2342 ************************************************************************* */
2343
2344char *GetNextWord(char *pszSrcStr,char *pszDestStr)
2345{
2346
2347 while (*pszSrcStr && (*pszSrcStr == ' ' || *pszSrcStr == '\t'))
2348 ++pszSrcStr; /* chew any leading white space */
2349
2350 while (*pszSrcStr && (*pszSrcStr != ' ' && *pszSrcStr != '\t'))
2351 *pszDestStr++ = *pszSrcStr++;
2352 *pszDestStr = 0; /* drop NULL at end of destination */
2353 return (pszSrcStr);
2354}
2355
2356/***************************************************************************
2357 *
2358 * FUNCTION NAME = StrCopy
2359 *
2360 * DESCRIPTION = Copy finite or NULL terminated string to
2361 * destination buffer and lower case it during copy.
2362 *
2363 * INPUT = psStr - pointer to source string
2364 * pdStr - pointer to destination string
2365 * iCount - source string length
2366 *
2367 * OUTPUT = NONE.
2368 *
2369 * RETURN-NORMAL = NONE.
2370 * RETURN-ERROR = NONE.
2371 *
2372 ************************************************************************* */
2373
2374VOID StrCopy(char *psStr,char *pdStr,SHORT iCount)
2375{
2376 char c;
2377 SHORT i;
2378
2379
2380 for (i = 0; i < iCount; i++)
2381 { /* stay within finite bounds */
2382
2383 if (!(c = *psStr))
2384 break; /* pick up copy and abort if NULL */
2385
2386 if (c >= 'A' && c <= 'Z')
2387 {
2388 c += 'a'-'A';
2389 }
2390 *pdStr = c;
2391 psStr++;
2392 pdStr++;
2393 }
2394 *pdStr = 0; /* drop NULL at end of destination */
2395}
2396
2397/***************************************************************************
2398 *
2399 * FUNCTION NAME = ParseItalic
2400 *
2401 * DESCRIPTION = Parse the input string for the 'italic' key-word to
2402 * be able to set the Italic bit in the font metrics
2403 *
2404 * INPUT = NONE.
2405 * OUTPUT = NONE.
2406 *
2407 * RETURN-NORMAL = NONE.
2408 * RETURN-ERROR = NONE.
2409 *
2410 ************************************************************************* */
2411
2412VOID ParseItalic( VOID )
2413{
2414 char szStrBuff[MAX_STR];
2415 char szWrdBuff[MAX_STR];
2416 char *pszSrcStr;
2417
2418 /*
2419 ** pick up private copy of name
2420 */
2421
2422 StrCopy(afm.szFontName, szStrBuff, sizeof(afm.szFontName));
2423 pszSrcStr = szStrBuff;
2424
2425 /*
2426 ** while not at end of name string, grab the
2427 ** next word and see if it is 'italic'
2428 */
2429
2430 while (*pszSrcStr)
2431 {
2432 pszSrcStr = GetNextWord(pszSrcStr, szWrdBuff);
2433
2434 if (szIsEqual(szWrdBuff, "italic"))
2435 {
2436 fmFont.fsSelection |= FATTR_SEL_ITALIC;
2437 break;
2438 }
2439 }
2440}
2441
2442/***************************************************************************
2443 *
2444 * FUNCTION NAME = ParseFamilyClass
2445 *
2446 * DESCRIPTION = Parse the input string for the various family names
2447 * to be able to set the Family Name ID in the font
2448 * metrics
2449 *
2450 * INPUT = NONE.
2451 * OUTPUT = NONE.
2452 *
2453 * RETURN-NORMAL = NONE.
2454 * RETURN-ERROR = NONE.
2455 *
2456 ************************************************************************* */
2457
2458VOID ParseFamilyClass( VOID )
2459{
2460 char szStrBuff[MAX_STR];
2461 char szWrdBuff[MAX_STR];
2462 char *pszSrcStr;
2463
2464 /*
2465 ** pick up private copy of name
2466 */
2467
2468 StrCopy(fmFont.szFamilyname, szStrBuff, sizeof(fmFont.szFamilyname));
2469 pszSrcStr = szStrBuff;
2470
2471 /*
2472 ** while not at end of name string, grab the
2473 ** next word and run thro the various
2474 ** possibiliteis
2475 */
2476
2477 while (*pszSrcStr)
2478 {
2479 pszSrcStr = GetNextWord(pszSrcStr, szWrdBuff);
2480
2481 if ((szIsEqual(szWrdBuff, "avant")) || (szIsEqual(szWrdBuff, "helvetica")))
2482 {
2483 fmFont.sFamilyClass |= FATTR_FAM_SANS_SERIF;
2484 break;
2485 }
2486
2487 if ((szIsEqual(szWrdBuff, "bookman")) || (szIsEqual(szWrdBuff, "times")))
2488 {
2489 fmFont.sFamilyClass |= FATTR_FAM_TRANSITIONAL_SERIF;
2490 break;
2491 }
2492
2493 if ((szIsEqual(szWrdBuff, "courier")) || (szIsEqual(szWrdBuff, "lubalin")))
2494 {
2495 fmFont.sFamilyClass |= FATTR_FAM_SLAB_SERIF;
2496 break;
2497 }
2498
2499 if ((szIsEqual(szWrdBuff, "garamond")) || (szIsEqual(szWrdBuff, "palatino")
2500 ))
2501 {
2502 fmFont.sFamilyClass |= FATTR_FAM_OLD_STYLE_SERIF;
2503 break;
2504 }
2505
2506 if ((szIsEqual(szWrdBuff, "century")) || (szIsEqual(szWrdBuff, "korinna")))
2507 {
2508 fmFont.sFamilyClass |= FATTR_FAM_CLARENDON_SERIF;
2509 break;
2510 }
2511
2512 if ((szIsEqual(szWrdBuff, "souvenir")))
2513 {
2514 fmFont.sFamilyClass |= FATTR_FAM_FREEFORM_SERIF;
2515 break;
2516 }
2517
2518 if ((szIsEqual(szWrdBuff, "chancery")))
2519 {
2520 fmFont.sFamilyClass |= FATTR_FAM_SCRIPT;
2521 break;
2522 }
2523
2524 if ((szIsEqual(szWrdBuff, "symbol")) || (szIsEqual(szWrdBuff, "dingbats")))
2525 {
2526 fmFont.sFamilyClass |= FATTR_FAM_SYMBOLIC;
2527 break;
2528 }
2529 }
2530}
2531
2532
2533/* DBCS enabling start */ //@DBCS
2534/***************************************************************************
2535 *
2536 * FUNCTION NAME = ParseBaseFont
2537 *
2538 * DESCRIPTION = Parse the Base font and set the base font flag
2539 * in the fontmetrics structure.
2540 *
2541 * INPUT = NONE.
2542 * OUTPUT = NONE.
2543 *
2544 * RETURN-NORMAL = NONE.
2545 * RETURN-ERROR = NONE.
2546 *
2547 ************************************************************************* */
2548
2549VOID ParseBaseFont( VOID )
2550{
2551 char szWord[16];
2552
2553 EatWhite();
2554 GetWord(szWord, sizeof(szWord));
2555
2556 if (szIsEqual("true", szWord))
2557 {
2558 /*
2559 ** If the IsBaseFont is true, the font is for mixed
2560 ** single/double-byte code page
2561 */
2562 fmFont.fsType |= FM_TYPE_MBCS;
2563 }
2564
2565 else
2566 {
2567 fmFont.fsType &= ~FM_TYPE_MBCS;
2568 }
2569}
2570/* DBCS enabling end */ //@DBCS
2571
2572
2573
2574int Conv_AFM_Init()
2575{
2576 return 1;
2577}
2578
2579
2580int Conv_AFM_WritePFM(PSZ pszInFile, FILE *fhOutArg, PSZ pszFontName, PSZ pszFontFullName)
2581{
2582 SHORT iToken;
2583 BOOL fEndOfInput = FALSE;
2584
2585 printf(".");
2586 // clear out our previous memory (here the bugs lie... will need to track
2587 // all of those globals that need cleaning)
2588 cInline = 0;
2589 memset( &afm,0,sizeof(afm) );
2590 memset( &fmFont,0,sizeof(fmFont) );
2591 charmap = charmapAdobeStandard;
2592
2593
2594// GetArgs(argc, argv);
2595 // check parameters
2596 if(pszInFile == NULL ||
2597 fhOutArg == NULL ||
2598 pszFontName == NULL)
2599 {
2600 return FALSE; // fail if not good
2601 }
2602
2603 szMove(rgchIn,(char*)pszInFile,MAX_FNAMESIZE);
2604
2605 printf(".");
2606
2607 OpenAfm();
2608
2609 fhOut = fhOutArg;
2610
2611 printf(".");
2612
2613 while (!fEndOfInput)
2614 {
2615 GetLine();
2616 iToken = GetToken();
2617
2618 switch (iToken)
2619 {
2620 case tok_fontname :
2621 ParseString((char*)pszFontName, 40);
2622 break;
2623
2624 case tok_fullname :
2625 ParseString(afm.szFontName, sizeof(afm.szFontName));
2626 szMove(fmFont.szFacename, afm.szFontName, sizeof(fmFont.szFacename));
2627 szMove((char*)pszFontFullName,afm.szFontName,40);
2628 ParseItalic();
2629 break;
2630 case tok_familyname :
2631 ParseString(fmFont.szFamilyname, sizeof(fmFont.szFamilyname));
2632 ParseFamilyClass();
2633 break;
2634 case tok_encodingscheme :
2635 ParseString(afm.szEncodingScheme, sizeof(afm.szEncodingScheme));
2636
2637 if (szIsEqual(afm.szEncodingScheme, "FontSpecific"))
2638 charmap = charmapFontSpecific;
2639
2640 else
2641 charmap = charmapAdobeStandard;
2642 break;
2643 case tok_comment :
2644
2645 if (!afm.szComment[0])
2646 ParseString(afm.szComment, sizeof(afm.szComment));
2647 break;
2648 case tok_weight :
2649 ParseWeight();
2650 break;
2651 case tok_italicangle :
2652 fmFont.sCharSlope = GetFloat(10);
2653 break;
2654 case tok_isfixedpitch :
2655 ParsePitchType();
2656 break;
2657 case tok_fontbox :
2658 ParseBoundingBox();
2659 break;
2660 case tok_underlineposition :
2661 fmFont.lUnderscorePosition = (LONG)abs(GetNumber());
2662 break;
2663 case tok_underlinethickness :
2664 fmFont.lUnderscoreSize = (LONG)GetNumber();
2665 break;
2666/* case tok_version :
2667 ParseString(afm.szVersion, sizeof(afm.szVersion));
2668 break; */
2669/***case tok_notice :
2670 ParseString(afm.szNotice, sizeof(afm.szNotice));
2671 break; **/
2672 case tok_capheight :
2673 afm.iCapHeight = GetNumber();
2674 break;
2675 case tok_xheight :
2676 fmFont.lXHeight = (LONG)abs(GetNumber());
2677 break;
2678 case tok_ascender :
2679 (void)GetNumber();
2680 break;
2681 case tok_descender :
2682 (void)GetNumber();
2683 break;
2684 case tok_startcharmetrics :
2685 ParseCharMetrics();
2686 break;
2687 case tok_startkerndata :
2688 ParseKernData();
2689 break;
2690 case tok_startfontmetrics :
2691 afm.version = GetFloat(10);
2692 afm.version = (afm.version%10)+((afm.version/10) << 8);
2693 break;
2694 case tok_endfontmetrics :
2695 fEndOfInput = TRUE;
2696 break;
2697 case tok_isbasefont : //@DBCS
2698 ParseBaseFont(); //@DBCS
2699 break; //@DBCS
2700 }
2701 pszLine = rgbLine;
2702
2703 if (fEcho)
2704 PrintLine();
2705 }
2706
2707 printf(".");
2708
2709 fclose(fhIn);
2710 FixCharWidths();
2711 SetAfm();
2712
2713 printf(".");
2714
2715 WriteOutput(1);
2716
2717// fclose(fhOut);
2718
2719 return TRUE;
2720}
2721
2722void Conv_AFM_Done()
2723{
2724 // imagine a clean up
2725 return;
2726}
Note: See TracBrowser for help on using the repository browser.