ReceiveTempSMS
/
Al-Qurtas-Islamic-bank-The-Best-Bank-in-Iraq
forked from minhngoc25a/freetype2
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Renamed z1* files back to t1*; the same transition for Z1_* structures 

Removed obsolete raster1/* files.
This commit is contained in:
Werner Lemberg 2000-10-28 17:10:06 +00:00
parent 1ea9378ad3
commit b5084e11f7
25 changed files with 400 additions and 4106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
CHANGES
View File

@ -1,5 +1,8 @@
LATEST CHANGES LATEST CHANGES
- "type1z" renamed back to "type1"; the old "type1" module has been
removed
- revamped the build system to make it a lot more generic. This will - revamped the build system to make it a lot more generic. This will
allow us to re-use nearly un-modified in lots of other projects allow us to re-use nearly un-modified in lots of other projects
(including FreeType Layout) (including FreeType Layout)
@ -13,10 +16,10 @@ LATEST CHANGES
- updated "docs/docmaker.py", a draft API reference is available at - updated "docs/docmaker.py", a draft API reference is available at
http://www.freetype.org/ft2api.html http://www.freetype.org/ft2api.html
- changed "type1z" to use "psaux" - changed "type1" to use "psaux"
- created a new module named "psaux" to hold the Type 1 & Type 2 parsing - created a new module named "psaux" to hold the Type 1 & Type 2 parsing
routines. It should be used by "type1z", "cid" and "cff" in the future routines. It should be used by "type1", "cid" and "cff" in the future
- fixed an important bug in "FT_Glyph_Get_CBox" - fixed an important bug in "FT_Glyph_Get_CBox"
@ -354,7 +357,7 @@ OLD CHANGES FOR BETA 7
- changed the default number of gray levels of the smooth renderer to - changed the default number of gray levels of the smooth renderer to
256 (instead of the previous 128). Of course, the human eye can't 256 (instead of the previous 128). Of course, the human eye can't
see any difference ;-) see any difference ;-)
- removed TT_MAX_SUBGLYPHS, there is no static limit on the number of - removed TT_MAX_SUBGLYPHS, there is no static limit on the number of
subglyphs in a TrueType font now.. subglyphs in a TrueType font now..

2
docs/BUILD
View File

@ -198,7 +198,7 @@ III. DETAILED COMPILATION PROCEDURE
src/sfnt/sfnt.c - the `sfnt' module src/sfnt/sfnt.c - the `sfnt' module
src/smooth/smooth.c - the anti-aliasing raster module src/smooth/smooth.c - the anti-aliasing raster module
src/truetype/truetype.c - the TrueType font driver src/truetype/truetype.c - the TrueType font driver
src/type1z/type1z.c - the Type 1 font driver src/type1/type1.c - the Type 1 font driver
The last module of FreeType 2, winfonts (implementing support for The last module of FreeType 2, winfonts (implementing support for
Windows FNT format), is a single file. Windows FNT format), is a single file.

9
include/freetype/internal/ftdebug.h
View File

@ -86,19 +86,12 @@
trace_t1hint, trace_t1hint,
trace_t1load, trace_t1load,
trace_t1objs, trace_t1objs,
trace_t1parse,
/* PostScript helper module `psaux' */ /* PostScript helper module `psaux' */
trace_t1decode, trace_t1decode,
trace_psobjs, trace_psobjs,
/* experimental Type 1 driver components */
trace_z1driver,
trace_z1gload,
trace_z1hint,
trace_z1load,
trace_z1objs,
trace_z1parse,
/* Type 2 driver components */ /* Type 2 driver components */
trace_t2driver, trace_t2driver,
trace_t2gload, trace_t2gload,

2
src/base/ftmac.c
View File

@ -59,7 +59,7 @@
#include <freetype/freetype.h> #include <freetype/freetype.h>
#include <freetype/internal/ftstream.h> #include <freetype/internal/ftstream.h>
#include <truetype/ttobjs.h> #include <truetype/ttobjs.h>
#include <type1z/z1objs.h> #include <type1/t1objs.h>
#include <Resources.h> #include <Resources.h>
#include <Fonts.h> #include <Fonts.h>

3293
src/raster1/ftraster.c
View File

File diff suppressed because it is too large Load Diff

50
src/raster1/ftraster.h
View File

@ -1,50 +0,0 @@
/***************************************************************************/
/* */
/* ftraster.h */
/* */
/* The FreeType glyph rasterizer (specification). */
/* */
/* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used */
/* modified and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#ifndef FTRASTER_H
#define FTRASTER_H
#ifdef __cplusplus
extern "C" {
#endif
#include <freetype/ftimage.h>
/*************************************************************************/
/* */
/* Uncomment the following line if you are using ftraster.c as a */
/* standalone module, fully independent of FreeType. */
/* */
/* #define _STANDALONE_ */
#ifndef FT_EXPORT_VAR
#define FT_EXPORT_VAR( x ) extern x
#endif
FT_EXPORT_VAR( const FT_Raster_Funcs ) ft_standard_raster;
#ifdef __cplusplus
}
#endif
#endif /* FTRASTER_H */
/* END */

276
src/raster1/ftrend1.c
View File

@ -1,276 +0,0 @@
/***************************************************************************/
/* */
/* ftrend1.c */
/* */
/* The FreeType glyph rasterizer interface (body). */
/* */
/* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#include <freetype/internal/ftobjs.h>
#include <freetype/ftoutln.h>
#ifdef FT_FLAT_COMPILE
#include "ftrend1.h"
#include "ftraster.h"
#else
#include <raster1/ftrend1.h>
#include <raster1/ftraster.h>
#endif
/* initialize renderer -- init its raster */
static
FT_Error ft_raster1_init( FT_Renderer render )
{
FT_Library library = FT_MODULE_LIBRARY( render );
render->clazz->raster_class->raster_reset( render->raster,
library->raster_pool,
library->raster_pool_size );
return FT_Err_Ok;
}
/* set render-specific mode */
static
FT_Error ft_raster1_set_mode( FT_Renderer render,
FT_ULong mode_tag,
FT_Pointer data )
{
/* we simply pass it to the raster */
return render->clazz->raster_class->raster_set_mode( render->raster,
mode_tag,
data );
}
/* transform a given glyph image */
static
FT_Error ft_raster1_transform( FT_Renderer render,
FT_GlyphSlot slot,
FT_Matrix* matrix,
FT_Vector* delta )
{
FT_Error error = FT_Err_Ok;
if ( slot->format != render->glyph_format )
{
error = FT_Err_Invalid_Argument;
goto Exit;
}
if ( matrix )
FT_Outline_Transform( &slot->outline, matrix );
if ( delta )
FT_Outline_Translate( &slot->outline, delta->x, delta->y );
Exit:
return error;
}
/* return the glyph's control box */
static
void ft_raster1_get_cbox( FT_Renderer render,
FT_GlyphSlot slot,
FT_BBox* cbox )
{
MEM_Set( cbox, 0, sizeof ( *cbox ) );
if ( slot->format == render->glyph_format )
FT_Outline_Get_CBox( &slot->outline, cbox );
}
/* convert a slot's glyph image into a bitmap */
static
FT_Error ft_raster1_render( FT_Renderer render,
FT_GlyphSlot slot,
FT_UInt mode,
FT_Vector* origin )
{
FT_Error error;
FT_Outline* outline;
FT_BBox cbox;
FT_UInt width, height, pitch;
FT_Bitmap* bitmap;
FT_Memory memory;
FT_Raster_Params params;
/* check glyph image format */
if ( slot->format != render->glyph_format )
{
error = FT_Err_Invalid_Argument;
goto Exit;
}
/* check rendering mode */
if ( mode != ft_render_mode_mono )
{
/* raster1 is only capable of producing monochrome bitmaps */
if ( render->clazz == &ft_raster1_renderer_class )
return FT_Err_Cannot_Render_Glyph;
}
else
{
/* raster5 is only capable of producing 5-gray-levels bitmaps */
if ( render->clazz == &ft_raster5_renderer_class )
return FT_Err_Cannot_Render_Glyph;
}
outline = &slot->outline;
/* translate the outline to the new origin if needed */
if ( origin )
FT_Outline_Translate( outline, origin->x, origin->y );
/* compute the control box, and grid fit it */
FT_Outline_Get_CBox( outline, &cbox );
cbox.xMin &= -64;
cbox.yMin &= -64;
cbox.xMax = ( cbox.xMax + 63 ) & -64;
cbox.yMax = ( cbox.yMax + 63 ) & -64;
width = ( cbox.xMax - cbox.xMin ) >> 6;
height = ( cbox.yMax - cbox.yMin ) >> 6;
bitmap = &slot->bitmap;
memory = render->root.memory;
/* release old bitmap buffer */
if ( slot->flags & ft_glyph_own_bitmap )
{
FREE( bitmap->buffer );
slot->flags &= ~ft_glyph_own_bitmap;
}
/* allocate new one, depends on pixel format */
if ( !( mode & ft_render_mode_mono ) )
{
/* we pad to 32 bits, only for backwards compatibility with FT 1.x */
pitch = ( width + 3 ) & -4;
bitmap->pixel_mode = ft_pixel_mode_grays;
bitmap->num_grays = 256;
}
else
{
pitch = ( width + 7 ) >> 3;
bitmap->pixel_mode = ft_pixel_mode_mono;
}
bitmap->width = width;
bitmap->rows = height;
bitmap->pitch = pitch;
if ( ALLOC( bitmap->buffer, (FT_ULong)pitch * height ) )
goto Exit;
slot->flags |= ft_glyph_own_bitmap;
/* translate outline to render it into the bitmap */
FT_Outline_Translate( outline, -cbox.xMin, -cbox.yMin );
/* set up parameters */
params.target = bitmap;
params.source = outline;
params.flags = 0;
if ( bitmap->pixel_mode == ft_pixel_mode_grays )
params.flags |= ft_raster_flag_aa;
/* render outline into the bitmap */
error = render->raster_render( render->raster, &params );
if ( error )
goto Exit;
slot->format = ft_glyph_format_bitmap;
slot->bitmap_left = cbox.xMin >> 6;
slot->bitmap_top = cbox.yMax >> 6;
Exit:
return error;
}
FT_CPLUSPLUS( const FT_Renderer_Class ) ft_raster1_renderer_class =
{
{
ft_module_renderer,
sizeof( FT_RendererRec ),
"raster1",
0x10000L,
0x20000L,
0, /* module specific interface */
(FT_Module_Constructor)ft_raster1_init,
(FT_Module_Destructor) 0,
(FT_Module_Requester) 0
},
ft_glyph_format_outline,
(FTRenderer_render) ft_raster1_render,
(FTRenderer_transform)ft_raster1_transform,
(FTRenderer_getCBox) ft_raster1_get_cbox,
(FTRenderer_setMode) ft_raster1_set_mode,
(FT_Raster_Funcs*) &ft_standard_raster
};
/* This renderer is _NOT_ part of the default modules; you will need */
/* to register it by hand in your application. It should only be */
/* used for backwards-compatibility with FT 1.x anyway. */
/* */
FT_CPLUSPLUS( const FT_Renderer_Class ) ft_raster5_renderer_class =
{
{
ft_module_renderer,
sizeof( FT_RendererRec ),
"raster5",
0x10000L,
0x20000L,
0, /* module specific interface */
(FT_Module_Constructor)ft_raster1_init,
(FT_Module_Destructor) 0,
(FT_Module_Requester) 0
},
ft_glyph_format_outline,
(FTRenderer_render) ft_raster1_render,
(FTRenderer_transform)ft_raster1_transform,
(FTRenderer_getCBox) ft_raster1_get_cbox,
(FTRenderer_setMode) ft_raster1_set_mode,
(FT_Raster_Funcs*) &ft_standard_raster
};
/* END */

48
src/raster1/ftrend1.h
View File

@ -1,48 +0,0 @@
/***************************************************************************/
/* */
/* ftrend1.h */
/* */
/* The FreeType glyph rasterizer interface (specification). */
/* */
/* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#ifndef FTREND1_H
#define FTREND1_H
#include <freetype/ftrender.h>
#ifdef __cplusplus
extern "C" {
#endif
FT_EXPORT_VAR( const FT_Renderer_Class ) ft_raster1_renderer_class;
/* this renderer is _NOT_ part of the default modules, you'll need */
/* to register it by hand in your application. It should only be */
/* used for backwards-compatibility with FT 1.x anyway. */
/* */
FT_EXPORT_VAR( const FT_Renderer_Class ) ft_raster5_renderer_class;
#ifdef __cplusplus
}
#endif
#endif /* FTREND1_H */
/* END */

35
src/raster1/raster1.c
View File

@ -1,35 +0,0 @@
/***************************************************************************/
/* */
/* raster1.c */
/* */
/* FreeType monochrome rasterer module component (body only). */
/* */
/* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#define FT_MAKE_OPTION_SINGLE_OBJECT
#ifdef FT_FLAT_COMPILE
#include "ftraster.c"
#include "ftrend1.c"
#else
#include <raster1/ftraster.c>
#include <raster1/ftrend1.c>
#endif
/* END */

2
src/type1/module.mk
View File

@ -1,5 +1,5 @@
# #
# FreeType 2 Type1z module definition # FreeType 2 Type1 module definition
# #

24
src/type1/rules.mk
View File

@ -1,5 +1,5 @@
# #
# FreeType 2 Type1z driver configuration rules # FreeType 2 Type1 driver configuration rules
# #
@ -26,20 +26,20 @@ T1_COMPILE := $(FT_COMPILE)
# Type1 driver sources (i.e., C files) # Type1 driver sources (i.e., C files)
# #
T1_DRV_SRC := $(T1_DIR_)z1parse.c \ T1_DRV_SRC := $(T1_DIR_)t1parse.c \
$(T1_DIR_)z1load.c \ $(T1_DIR_)t1load.c \
$(T1_DIR_)z1driver.c \ $(T1_DIR_)t1driver.c \
$(T1_DIR_)z1afm.c \ $(T1_DIR_)t1afm.c \
$(T1_DIR_)z1gload.c \ $(T1_DIR_)t1gload.c \
$(T1_DIR_)z1objs.c $(T1_DIR_)t1objs.c
# Type1 driver headers # Type1 driver headers
# #
T1_DRV_H := $(T1_DRV_SRC:%.c=%.h) \ T1_DRV_H := $(T1_DRV_SRC:%.c=%.h) \
$(T1_DIR_)z1tokens.h $(T1_DIR_)t1tokens.h
# Type1z driver object(s) # Type1 driver object(s)
# #
# T1_DRV_OBJ_M is used during `multi' builds # T1_DRV_OBJ_M is used during `multi' builds
# T1_DRV_OBJ_S is used during `single' builds # T1_DRV_OBJ_S is used during `single' builds
@ -47,18 +47,18 @@ T1_DRV_H := $(T1_DRV_SRC:%.c=%.h) \
T1_DRV_OBJ_M := $(T1_DRV_SRC:$(T1_DIR_)%.c=$(OBJ_)%.$O) T1_DRV_OBJ_M := $(T1_DRV_SRC:$(T1_DIR_)%.c=$(OBJ_)%.$O)
T1_DRV_OBJ_S := $(OBJ_)type1.$O T1_DRV_OBJ_S := $(OBJ_)type1.$O
# Type1z driver source file for single build # Type1 driver source file for single build
# #
T1_DRV_SRC_S := $(T1_DIR_)type1.c T1_DRV_SRC_S := $(T1_DIR_)type1.c
# Type1z driver - single object # Type1 driver - single object
# #
$(T1_DRV_OBJ_S): $(T1_DRV_SRC_S) $(T1_DRV_SRC) $(FREETYPE_H) $(T1_DRV_H) $(T1_DRV_OBJ_S): $(T1_DRV_SRC_S) $(T1_DRV_SRC) $(FREETYPE_H) $(T1_DRV_H)
$(T1_COMPILE) $T$@ $(T1_DRV_SRC_S) $(T1_COMPILE) $T$@ $(T1_DRV_SRC_S)
# Type1z driver - multiple objects # Type1 driver - multiple objects
# #
$(OBJ_)%.$O: $(T1_DIR_)%.c $(FREETYPE_H) $(T1_DRV_H) $(OBJ_)%.$O: $(T1_DIR_)%.c $(FREETYPE_H) $(T1_DRV_H)
$(T1_COMPILE) $T$@ $< $(T1_COMPILE) $T$@ $<

30
src/type1/z1afm.c → src/type1/t1afm.c
View File

@ -1,6 +1,6 @@
/***************************************************************************/ /***************************************************************************/
/* */ /* */
/* z1afm.c */ /* t1afm.c */
/* */ /* */
/* AFM support for Type 1 fonts (body). */ /* AFM support for Type 1 fonts (body). */
/* */ /* */
@ -18,11 +18,11 @@
#ifdef FT_FLAT_COMPILE #ifdef FT_FLAT_COMPILE
#include "z1afm.h" #include "t1afm.h"
#else #else
#include <type1/z1afm.h> #include <type1/t1afm.h>
#endif #endif
@ -42,12 +42,12 @@
/* messages during execution. */ /* messages during execution. */
/* */ /* */
#undef FT_COMPONENT #undef FT_COMPONENT
#define FT_COMPONENT trace_z1afm #define FT_COMPONENT trace_t1afm
LOCAL_FUNC LOCAL_FUNC
void Z1_Done_AFM( FT_Memory memory, void T1_Done_AFM( FT_Memory memory,
Z1_AFM* afm ) T1_AFM* afm )
{ {
FREE( afm->kern_pairs ); FREE( afm->kern_pairs );
afm->num_pairs = 0; afm->num_pairs = 0;
@ -153,8 +153,8 @@
int compare_kern_pairs( const void* a, int compare_kern_pairs( const void* a,
const void* b ) const void* b )
{ {
Z1_Kern_Pair* pair1 = (Z1_Kern_Pair*)a; T1_Kern_Pair* pair1 = (T1_Kern_Pair*)a;
Z1_Kern_Pair* pair2 = (Z1_Kern_Pair*)b; T1_Kern_Pair* pair2 = (T1_Kern_Pair*)b;
FT_ULong index1 = KERN_INDEX( pair1->glyph1, pair1->glyph2 ); FT_ULong index1 = KERN_INDEX( pair1->glyph1, pair1->glyph2 );
FT_ULong index2 = KERN_INDEX( pair2->glyph1, pair2->glyph2 ); FT_ULong index2 = KERN_INDEX( pair2->glyph1, pair2->glyph2 );
@ -166,7 +166,7 @@
/* parse an AFM file -- for now, only read the kerning pairs */ /* parse an AFM file -- for now, only read the kerning pairs */
LOCAL_FUNC LOCAL_FUNC
FT_Error Z1_Read_AFM( FT_Face t1_face, FT_Error T1_Read_AFM( FT_Face t1_face,
FT_Stream stream ) FT_Stream stream )
{ {
FT_Error error; FT_Error error;
@ -175,9 +175,9 @@
FT_Byte* limit; FT_Byte* limit;
FT_Byte* p; FT_Byte* p;
FT_Int count = 0; FT_Int count = 0;
Z1_Kern_Pair* pair; T1_Kern_Pair* pair;
T1_Font* type1 = &((T1_Face)t1_face)->type1; T1_Font* type1 = &((T1_Face)t1_face)->type1;
Z1_AFM* afm = 0; T1_AFM* afm = 0;
if ( ACCESS_Frame( stream->size ) ) if ( ACCESS_Frame( stream->size ) )
@ -202,7 +202,7 @@
/* allocate the pairs */ /* allocate the pairs */
if ( ALLOC( afm, sizeof ( *afm ) ) || if ( ALLOC( afm, sizeof ( *afm ) ) ||
ALLOC_ARRAY( afm->kern_pairs, count, Z1_Kern_Pair ) ) ALLOC_ARRAY( afm->kern_pairs, count, T1_Kern_Pair ) )
goto Exit; goto Exit;
/* now, read each kern pair */ /* now, read each kern pair */
@ -237,7 +237,7 @@
} }
/* now, sort the kern pairs according to their glyph indices */ /* now, sort the kern pairs according to their glyph indices */
qsort( afm->kern_pairs, count, sizeof ( Z1_Kern_Pair ), qsort( afm->kern_pairs, count, sizeof ( T1_Kern_Pair ),
compare_kern_pairs ); compare_kern_pairs );
Exit: Exit:
@ -252,12 +252,12 @@
/* find the kerning for a given glyph pair */ /* find the kerning for a given glyph pair */
LOCAL_FUNC LOCAL_FUNC
void Z1_Get_Kerning( Z1_AFM* afm, void T1_Get_Kerning( T1_AFM* afm,
FT_UInt glyph1, FT_UInt glyph1,
FT_UInt glyph2, FT_UInt glyph2,
FT_Vector* kerning ) FT_Vector* kerning )
{ {
Z1_Kern_Pair *min, *mid, *max; T1_Kern_Pair *min, *mid, *max;
FT_ULong index = KERN_INDEX( glyph1, glyph2 ); FT_ULong index = KERN_INDEX( glyph1, glyph2 );

30
src/type1/z1afm.h → src/type1/t1afm.h
View File

@ -1,6 +1,6 @@
/***************************************************************************/ /***************************************************************************/
/* */ /* */
/* z1afm.h */ /* t1afm.h */
/* */ /* */
/* AFM support for Type 1 fonts (specification). */ /* AFM support for Type 1 fonts (specification). */
/* */ /* */
@ -16,17 +16,17 @@
/***************************************************************************/ /***************************************************************************/
#ifndef Z1AFM_H #ifndef T1AFM_H
#define Z1AFM_H #define T1AFM_H
#ifdef FT_FLAT_COMPILE #ifdef FT_FLAT_COMPILE
#include "z1objs.h" #include "t1objs.h"
#else #else
#include <type1/z1objs.h> #include <type1/t1objs.h>
#endif #endif
@ -36,33 +36,33 @@
#endif #endif
typedef struct Z1_Kern_Pair_ typedef struct T1_Kern_Pair_
{ {
FT_UInt glyph1; FT_UInt glyph1;
FT_UInt glyph2; FT_UInt glyph2;
FT_Vector kerning; FT_Vector kerning;
} Z1_Kern_Pair; } T1_Kern_Pair;
typedef struct Z1_AFM_ typedef struct T1_AFM_
{ {
FT_Int num_pairs; FT_Int num_pairs;
Z1_Kern_Pair* kern_pairs; T1_Kern_Pair* kern_pairs;
} Z1_AFM; } T1_AFM;
LOCAL_DEF LOCAL_DEF
FT_Error Z1_Read_AFM( FT_Face face, FT_Error T1_Read_AFM( FT_Face face,
FT_Stream stream ); FT_Stream stream );
LOCAL_DEF LOCAL_DEF
void Z1_Done_AFM( FT_Memory memory, void T1_Done_AFM( FT_Memory memory,
Z1_AFM* afm ); T1_AFM* afm );
LOCAL_DEF LOCAL_DEF
void Z1_Get_Kerning( Z1_AFM* afm, void T1_Get_Kerning( T1_AFM* afm,
FT_UInt glyph1, FT_UInt glyph1,
FT_UInt glyph2, FT_UInt glyph2,
FT_Vector* kerning ); FT_Vector* kerning );
@ -73,7 +73,7 @@
#endif #endif
#endif /* Z1AFM_H */ #endif /* T1AFM_H */
/* END */ /* END */

62
src/type1/z1driver.c → src/type1/t1driver.c
View File

@ -1,8 +1,8 @@
/***************************************************************************/ /***************************************************************************/
/* */ /* */
/* z1driver.c */ /* t1driver.c */
/* */ /* */
/* Experimental Type 1 driver interface (body). */ /* Type 1 driver interface (body). */
/* */ /* */
/* Copyright 1996-2000 by */ /* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -18,17 +18,17 @@
#ifdef FT_FLAT_COMPILE #ifdef FT_FLAT_COMPILE
#include "z1driver.h" #include "t1driver.h"
#include "z1gload.h" #include "t1gload.h"
#include "z1load.h" #include "t1load.h"
#include "z1afm.h" #include "t1afm.h"
#else #else
#include <type1/z1driver.h> #include <type1/t1driver.h>
#include <type1/z1gload.h> #include <type1/t1gload.h>
#include <type1/z1load.h> #include <type1/t1load.h>
#include <type1/z1afm.h> #include <type1/t1afm.h>
#endif #endif
@ -47,11 +47,11 @@
/* messages during execution. */ /* messages during execution. */
/* */ /* */
#undef FT_COMPONENT #undef FT_COMPONENT
#define FT_COMPONENT trace_z1driver #define FT_COMPONENT trace_t1driver
static static
FT_Error get_z1_glyph_name( T1_Face face, FT_Error get_t1_glyph_name( T1_Face face,
FT_UInt glyph_index, FT_UInt glyph_index,
FT_Pointer buffer, FT_Pointer buffer,
FT_UInt buffer_max ) FT_UInt buffer_max )
@ -112,23 +112,23 @@
FT_UNUSED( interface ); FT_UNUSED( interface );
if ( strcmp( (const char*)interface, "glyph_name" ) == 0 ) if ( strcmp( (const char*)interface, "glyph_name" ) == 0 )
return (FT_Module_Interface)get_z1_glyph_name; return (FT_Module_Interface)get_t1_glyph_name;
#ifndef Z1_CONFIG_OPTION_NO_MM_SUPPORT #ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT
if ( strcmp( (const char*)interface, "get_mm" ) == 0 ) if ( strcmp( (const char*)interface, "get_mm" ) == 0 )
return (FT_Module_Interface)Z1_Get_Multi_Master; return (FT_Module_Interface)T1_Get_Multi_Master;
if ( strcmp( (const char*)interface, "set_mm_design") == 0 ) if ( strcmp( (const char*)interface, "set_mm_design") == 0 )
return (FT_Module_Interface)Z1_Set_MM_Design; return (FT_Module_Interface)T1_Set_MM_Design;
if ( strcmp( (const char*)interface, "set_mm_blend") == 0 ) if ( strcmp( (const char*)interface, "set_mm_blend") == 0 )
return (FT_Module_Interface)Z1_Set_MM_Blend; return (FT_Module_Interface)T1_Set_MM_Blend;
#endif #endif
return 0; return 0;
} }
#ifndef Z1_CONFIG_OPTION_NO_AFM #ifndef T1_CONFIG_OPTION_NO_AFM
/*************************************************************************/ /*************************************************************************/
/* */ /* */
@ -168,15 +168,15 @@
FT_UInt right_glyph, FT_UInt right_glyph,
FT_Vector* kerning ) FT_Vector* kerning )
{ {
Z1_AFM* afm; T1_AFM* afm;
kerning->x = 0; kerning->x = 0;
kerning->y = 0; kerning->y = 0;
afm = (Z1_AFM*)face->afm_data; afm = (T1_AFM*)face->afm_data;
if ( afm ) if ( afm )
Z1_Get_Kerning( afm, left_glyph, right_glyph, kerning ); T1_Get_Kerning( afm, left_glyph, right_glyph, kerning );
return T1_Err_Ok; return T1_Err_Ok;
} }
@ -295,17 +295,17 @@
0, /* format interface */ 0, /* format interface */
(FT_Module_Constructor)Z1_Init_Driver, (FT_Module_Constructor)T1_Init_Driver,
(FT_Module_Destructor) Z1_Done_Driver, (FT_Module_Destructor) T1_Done_Driver,
(FT_Module_Requester) Get_Interface, (FT_Module_Requester) Get_Interface,
}, },
sizeof( T1_FaceRec ), sizeof( T1_FaceRec ),
sizeof( Z1_SizeRec ), sizeof( T1_SizeRec ),
sizeof( Z1_GlyphSlotRec ), sizeof( T1_GlyphSlotRec ),
(FTDriver_initFace) Z1_Init_Face, (FTDriver_initFace) T1_Init_Face,
(FTDriver_doneFace) Z1_Done_Face, (FTDriver_doneFace) T1_Done_Face,
(FTDriver_initSize) 0, (FTDriver_initSize) 0,
(FTDriver_doneSize) 0, (FTDriver_doneSize) 0,
(FTDriver_initGlyphSlot)0, (FTDriver_initGlyphSlot)0,
@ -313,15 +313,15 @@
(FTDriver_setCharSizes) 0, (FTDriver_setCharSizes) 0,
(FTDriver_setPixelSizes)0, (FTDriver_setPixelSizes)0,
(FTDriver_loadGlyph) Z1_Load_Glyph, (FTDriver_loadGlyph) T1_Load_Glyph,
(FTDriver_getCharIndex) Get_Char_Index, (FTDriver_getCharIndex) Get_Char_Index,
#ifdef Z1_CONFIG_OPTION_NO_AFM #ifdef T1_CONFIG_OPTION_NO_AFM
(FTDriver_getKerning) 0, (FTDriver_getKerning) 0,
(FTDriver_attachFile) 0, (FTDriver_attachFile) 0,
#else #else
(FTDriver_getKerning) Get_Kerning, (FTDriver_getKerning) Get_Kerning,
(FTDriver_attachFile) Z1_Read_AFM, (FTDriver_attachFile) T1_Read_AFM,
#endif #endif
(FTDriver_getAdvances) 0 (FTDriver_getAdvances) 0
}; };
@ -331,7 +331,7 @@
EXPORT_FUNC( const FT_Driver_Class* ) getDriverClass( void ) EXPORT_FUNC( const FT_Driver_Class* ) getDriverClass( void )
{ {
return &t1z_driver_class; return &t1_driver_class;
} }
#endif /* FT_CONFIG_OPTION_DYNAMIC_DRIVERS */ #endif /* FT_CONFIG_OPTION_DYNAMIC_DRIVERS */

10
src/type1/z1driver.h → src/type1/t1driver.h
View File

@ -1,8 +1,8 @@
/***************************************************************************/ /***************************************************************************/
/* */ /* */
/* z1driver.h */ /* t1driver.h */
/* */ /* */
/* High-level experimental Type 1 driver interface (specification). */ /* High-level Type 1 driver interface (specification). */
/* */ /* */
/* Copyright 1996-2000 by */ /* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -16,8 +16,8 @@
/***************************************************************************/ /***************************************************************************/
#ifndef Z1DRIVER_H #ifndef T1DRIVER_H
#define Z1DRIVER_H #define T1DRIVER_H
#include <freetype/internal/ftdriver.h> #include <freetype/internal/ftdriver.h>
@ -33,7 +33,7 @@
#endif #endif
#endif /* Z1DRIVER_H */ #endif /* T1DRIVER_H */
/* END */ /* END */

26
src/type1/z1gload.c → src/type1/t1gload.c
View File

@ -1,8 +1,8 @@
/***************************************************************************/ /***************************************************************************/
/* */ /* */
/* z1gload.c */ /* t1gload.c */
/* */ /* */
/* Experimental Type 1 Glyph Loader (body). */ /* Type 1 Glyph Loader (body). */
/* */ /* */
/* Copyright 1996-2000 by */ /* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -18,11 +18,11 @@
#ifdef FT_FLAT_COMPILE #ifdef FT_FLAT_COMPILE
#include "z1gload.h" #include "t1gload.h"
#else #else
#include <type1/z1gload.h> #include <type1/t1gload.h>
#endif #endif
@ -43,7 +43,7 @@
/* messages during execution. */ /* messages during execution. */
/* */ /* */
#undef FT_COMPONENT #undef FT_COMPONENT
#define FT_COMPONENT trace_z1gload #define FT_COMPONENT trace_t1gload
/*************************************************************************/ /*************************************************************************/
@ -64,7 +64,7 @@
LOCAL_FUNC_X LOCAL_FUNC_X
FT_Error Z1_Parse_Glyph( T1_Decoder* decoder, FT_Error T1_Parse_Glyph( T1_Decoder* decoder,
FT_UInt glyph_index ) FT_UInt glyph_index )
{ {
T1_Face face = (T1_Face)decoder->builder.face; T1_Face face = (T1_Face)decoder->builder.face;
@ -82,7 +82,7 @@
LOCAL_FUNC LOCAL_FUNC
FT_Error Z1_Compute_Max_Advance( T1_Face face, FT_Error T1_Compute_Max_Advance( T1_Face face,
FT_Int* max_advance ) FT_Int* max_advance )
{ {
FT_Error error; FT_Error error;
@ -101,7 +101,7 @@
0, /* glyph slot */ 0, /* glyph slot */
(FT_Byte**)type1->glyph_names, (FT_Byte**)type1->glyph_names,
face->blend, face->blend,
Z1_Parse_Glyph ); T1_Parse_Glyph );
if ( error ) if ( error )
return error; return error;
@ -117,7 +117,7 @@
for ( glyph_index = 0; glyph_index < type1->num_glyphs; glyph_index++ ) for ( glyph_index = 0; glyph_index < type1->num_glyphs; glyph_index++ )
{ {
/* now get load the unscaled outline */ /* now get load the unscaled outline */
error = Z1_Parse_Glyph( &decoder, glyph_index ); error = T1_Parse_Glyph( &decoder, glyph_index );
/* ignore the error if one occured - skip to next glyph */ /* ignore the error if one occured - skip to next glyph */
} }
@ -144,8 +144,8 @@
LOCAL_FUNC LOCAL_FUNC
FT_Error Z1_Load_Glyph( Z1_GlyphSlot glyph, FT_Error T1_Load_Glyph( T1_GlyphSlot glyph,
Z1_Size size, T1_Size size,
FT_Int glyph_index, FT_Int glyph_index,
FT_Int load_flags ) FT_Int load_flags )
{ {
@ -180,7 +180,7 @@
(FT_GlyphSlot)glyph, (FT_GlyphSlot)glyph,
(FT_Byte**)type1->glyph_names, (FT_Byte**)type1->glyph_names,
face->blend, face->blend,
Z1_Parse_Glyph ); T1_Parse_Glyph );
if ( error ) if ( error )
goto Exit; goto Exit;
@ -192,7 +192,7 @@
/* now load the unscaled outline */ /* now load the unscaled outline */
error = Z1_Parse_Glyph( &decoder, glyph_index ); error = T1_Parse_Glyph( &decoder, glyph_index );
if ( error ) if ( error )
goto Exit; goto Exit;

20
src/type1/z1gload.h → src/type1/t1gload.h
View File

@ -1,8 +1,8 @@
/***************************************************************************/ /***************************************************************************/
/* */ /* */
/* z1gload.h */ /* t1gload.h */
/* */ /* */
/* Experimental Type 1 Glyph Loader (specification). */ /* Type 1 Glyph Loader (specification). */
/* */ /* */
/* Copyright 1996-2000 by */ /* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -16,17 +16,17 @@
/***************************************************************************/ /***************************************************************************/
#ifndef Z1GLOAD_H #ifndef T1GLOAD_H
#define Z1GLOAD_H #define T1GLOAD_H
#ifdef FT_FLAT_COMPILE #ifdef FT_FLAT_COMPILE
#include "z1objs.h" #include "t1objs.h"
#else #else
#include <type1/z1objs.h> #include <type1/t1objs.h>
#endif #endif
@ -37,12 +37,12 @@
LOCAL_DEF LOCAL_DEF
FT_Error Z1_Compute_Max_Advance( T1_Face face, FT_Error T1_Compute_Max_Advance( T1_Face face,
FT_Int* max_advance ); FT_Int* max_advance );
LOCAL_DEF LOCAL_DEF
FT_Error Z1_Load_Glyph( Z1_GlyphSlot glyph, FT_Error T1_Load_Glyph( T1_GlyphSlot glyph,
Z1_Size size, T1_Size size,
FT_Int glyph_index, FT_Int glyph_index,
FT_Int load_flags ); FT_Int load_flags );
@ -52,7 +52,7 @@
#endif #endif
#endif /* Z1GLOAD_H */ #endif /* T1GLOAD_H */
/* END */ /* END */

302
src/type1/z1load.c → src/type1/t1load.c
View File

@ -1,8 +1,8 @@
/***************************************************************************/ /***************************************************************************/
/* */ /* */
/* z1load.c */ /* t1load.c */
/* */ /* */
/* Experimental Type 1 font loader (body). */ /* Type 1 font loader (body). */
/* */ /* */
/* Copyright 1996-2000 by */ /* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -71,11 +71,11 @@
#ifdef FT_FLAT_COMPILE #ifdef FT_FLAT_COMPILE
#include "z1load.h" #include "t1load.h"
#else #else
#include <type1/z1load.h> #include <type1/t1load.h>
#endif #endif
@ -91,10 +91,10 @@
/* messages during execution. */ /* messages during execution. */
/* */ /* */
#undef FT_COMPONENT #undef FT_COMPONENT
#define FT_COMPONENT trace_z1load #define FT_COMPONENT trace_t1load
#ifndef Z1_CONFIG_OPTION_NO_MM_SUPPORT #ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT
/*************************************************************************/ /*************************************************************************/
@ -190,7 +190,7 @@
LOCAL_FUNC LOCAL_FUNC
FT_Error Z1_Get_Multi_Master( T1_Face face, FT_Error T1_Get_Multi_Master( T1_Face face,
FT_Multi_Master* master ) FT_Multi_Master* master )
{ {
T1_Blend* blend = face->blend; T1_Blend* blend = face->blend;
@ -222,7 +222,7 @@
LOCAL_FUNC LOCAL_FUNC
FT_Error Z1_Set_MM_Blend( T1_Face face, FT_Error T1_Set_MM_Blend( T1_Face face,
FT_UInt num_coords, FT_UInt num_coords,
FT_Fixed* coords ) FT_Fixed* coords )
{ {
@ -268,7 +268,7 @@
LOCAL_FUNC LOCAL_FUNC
FT_Error Z1_Set_MM_Design( T1_Face face, FT_Error T1_Set_MM_Design( T1_Face face,
FT_UInt num_coords, FT_UInt num_coords,
FT_Long* coords ) FT_Long* coords )
{ {
@ -330,7 +330,7 @@
final_blends[n] = the_blend; final_blends[n] = the_blend;
} }
error = Z1_Set_MM_Blend( face, num_coords, final_blends ); error = T1_Set_MM_Blend( face, num_coords, final_blends );
} }
return error; return error;
@ -338,7 +338,7 @@
LOCAL_FUNC LOCAL_FUNC
void Z1_Done_Blend( T1_Face face ) void T1_Done_Blend( T1_Face face )
{ {
FT_Memory memory = face->root.memory; FT_Memory memory = face->root.memory;
T1_Blend* blend = face->blend; T1_Blend* blend = face->blend;
@ -391,7 +391,7 @@
static static
void parse_blend_axis_types( T1_Face face, void parse_blend_axis_types( T1_Face face,
Z1_Loader* loader ) T1_Loader* loader )
{ {
T1_Token axis_tokens[ T1_MAX_MM_AXIS ]; T1_Token axis_tokens[ T1_MAX_MM_AXIS ];
FT_Int n, num_axis; FT_Int n, num_axis;
@ -401,7 +401,7 @@
/* take an array of objects */ /* take an array of objects */
Z1_ToTokenArray( &loader->parser, axis_tokens, T1_ToTokenArray( &loader->parser, axis_tokens,
T1_MAX_MM_AXIS, &num_axis ); T1_MAX_MM_AXIS, &num_axis );
if ( num_axis <= 0 || num_axis > T1_MAX_MM_AXIS ) if ( num_axis <= 0 || num_axis > T1_MAX_MM_AXIS )
{ {
@ -452,19 +452,19 @@
static static
void parse_blend_design_positions( T1_Face face, void parse_blend_design_positions( T1_Face face,
Z1_Loader* loader ) T1_Loader* loader )
{ {
T1_Token design_tokens[ T1_MAX_MM_DESIGNS ]; T1_Token design_tokens[ T1_MAX_MM_DESIGNS ];
FT_Int num_designs; FT_Int num_designs;
FT_Int num_axis; FT_Int num_axis;
Z1_Parser* parser = &loader->parser; T1_ParserRec* parser = &loader->parser;
FT_Error error = 0; FT_Error error = 0;
T1_Blend* blend; T1_Blend* blend;
/* get the array of design tokens - compute number of designs */ /* get the array of design tokens - compute number of designs */
Z1_ToTokenArray( parser, design_tokens, T1_MAX_MM_DESIGNS, &num_designs ); T1_ToTokenArray( parser, design_tokens, T1_MAX_MM_DESIGNS, &num_designs );
if ( num_designs <= 0 || num_designs > T1_MAX_MM_DESIGNS ) if ( num_designs <= 0 || num_designs > T1_MAX_MM_DESIGNS )
{ {
FT_ERROR(( "parse_blend_design_positions:" )); FT_ERROR(( "parse_blend_design_positions:" ));
@ -494,7 +494,7 @@
token = design_tokens + n; token = design_tokens + n;
parser->root.cursor = token->start - 1; parser->root.cursor = token->start - 1;
parser->root.limit = token->limit + 1; parser->root.limit = token->limit + 1;
Z1_ToTokenArray( parser, axis_tokens, T1_MAX_MM_AXIS, &n_axis ); T1_ToTokenArray( parser, axis_tokens, T1_MAX_MM_AXIS, &n_axis );
if ( n == 0 ) if ( n == 0 )
{ {
@ -519,7 +519,7 @@
parser->root.cursor = token2->start; parser->root.cursor = token2->start;
parser->root.limit = token2->limit; parser->root.limit = token2->limit;
blend->design_pos[n][axis] = Z1_ToFixed( parser, 0 ); blend->design_pos[n][axis] = T1_ToFixed( parser, 0 );
} }
} }
@ -534,19 +534,19 @@
static static
void parse_blend_design_map( T1_Face face, void parse_blend_design_map( T1_Face face,
Z1_Loader* loader ) T1_Loader* loader )
{ {
FT_Error error = 0; FT_Error error = 0;
Z1_Parser* parser = &loader->parser; T1_ParserRec* parser = &loader->parser;
T1_Blend* blend; T1_Blend* blend;
T1_Token axis_tokens[ T1_MAX_MM_AXIS ]; T1_Token axis_tokens[ T1_MAX_MM_AXIS ];
FT_Int n, num_axis; FT_Int n, num_axis;
FT_Byte* old_cursor; FT_Byte* old_cursor;
FT_Byte* old_limit; FT_Byte* old_limit;
FT_Memory memory = face->root.memory; FT_Memory memory = face->root.memory;
Z1_ToTokenArray( parser, axis_tokens, T1_MAX_MM_AXIS, &num_axis ); T1_ToTokenArray( parser, axis_tokens, T1_MAX_MM_AXIS, &num_axis );
if ( num_axis <= 0 || num_axis > T1_MAX_MM_AXIS ) if ( num_axis <= 0 || num_axis > T1_MAX_MM_AXIS )
{ {
FT_ERROR(( "parse_blend_design_map: incorrect number of axes: %d\n", FT_ERROR(( "parse_blend_design_map: incorrect number of axes: %d\n",
@ -600,8 +600,8 @@
for ( p = 0; p < num_points; p++ ) for ( p = 0; p < num_points; p++ )
{ {
map->design_points[p] = Z1_ToInt( parser ); map->design_points[p] = T1_ToInt( parser );
map->blend_points [p] = Z1_ToFixed( parser, 0 ); map->blend_points [p] = T1_ToFixed( parser, 0 );
} }
} }
@ -615,15 +615,15 @@
static static
void parse_weight_vector( T1_Face face, void parse_weight_vector( T1_Face face,
Z1_Loader* loader ) T1_Loader* loader )
{ {
FT_Error error = 0; FT_Error error = 0;
Z1_Parser* parser = &loader->parser; T1_ParserRec* parser = &loader->parser;
T1_Blend* blend = face->blend; T1_Blend* blend = face->blend;
T1_Token master; T1_Token master;
FT_UInt n; FT_UInt n;
FT_Byte* old_cursor; FT_Byte* old_cursor;
FT_Byte* old_limit; FT_Byte* old_limit;
if ( !blend || blend->num_designs == 0 ) if ( !blend || blend->num_designs == 0 )
@ -633,7 +633,7 @@
goto Exit; goto Exit;
} }
Z1_ToToken( parser, &master ); T1_ToToken( parser, &master );
if ( master.type != t1_token_array ) if ( master.type != t1_token_array )
{ {
FT_ERROR(( "parse_weight_vector: incorrect format!\n" )); FT_ERROR(( "parse_weight_vector: incorrect format!\n" ));
@ -650,7 +650,7 @@
for ( n = 0; n < blend->num_designs; n++ ) for ( n = 0; n < blend->num_designs; n++ )
{ {
blend->default_weight_vector[n] = blend->default_weight_vector[n] =
blend->weight_vector[n] = Z1_ToFixed( parser, 0 ); blend->weight_vector[n] = T1_ToFixed( parser, 0 );
} }
parser->root.cursor = old_cursor; parser->root.cursor = old_cursor;
@ -667,9 +667,9 @@
/* */ /* */
static static
void parse_shared_dict( T1_Face face, void parse_shared_dict( T1_Face face,
Z1_Loader* loader ) T1_Loader* loader )
{ {
Z1_Parser* parser = &loader->parser; T1_ParserRec* parser = &loader->parser;
FT_UNUSED( face ); FT_UNUSED( face );
@ -678,7 +678,7 @@
parser->root.error = 0; parser->root.error = 0;
} }
#endif /* Z1_CONFIG_OPTION_NO_MM_SUPPORT */ #endif /* T1_CONFIG_OPTION_NO_MM_SUPPORT */
/*************************************************************************/ /*************************************************************************/
@ -700,7 +700,7 @@
static static
FT_Error t1_load_keyword( T1_Face face, FT_Error t1_load_keyword( T1_Face face,
Z1_Loader* loader, T1_Loader* loader,
T1_Field* field ) T1_Field* field )
{ {
FT_Error error; FT_Error error;
@ -754,10 +754,10 @@
if ( field->type == t1_field_integer_array || if ( field->type == t1_field_integer_array ||
field->type == t1_field_fixed_array ) field->type == t1_field_fixed_array )
error = Z1_Load_Field_Table( &loader->parser, field, error = T1_Load_Field_Table( &loader->parser, field,
objects, max_objects, 0 ); objects, max_objects, 0 );
else else
error = Z1_Load_Field( &loader->parser, field, error = T1_Load_Field( &loader->parser, field,
objects, max_objects, 0 ); objects, max_objects, 0 );
Exit: Exit:
@ -781,9 +781,9 @@
static static
int read_binary_data( Z1_Parser* parser, int read_binary_data( T1_ParserRec* parser,
FT_Int* size, FT_Int* size,
FT_Byte** base ) FT_Byte** base )
{ {
FT_Byte* cur; FT_Byte* cur;
FT_Byte* limit = parser->root.limit; FT_Byte* limit = parser->root.limit;
@ -794,15 +794,15 @@
/* `size' [white*] RD white ....... ND */ /* `size' [white*] RD white ....... ND */
/* */ /* */
Z1_Skip_Spaces( parser ); T1_Skip_Spaces( parser );
cur = parser->root.cursor; cur = parser->root.cursor;
if ( cur < limit && (FT_Byte)( *cur - '0' ) < 10 ) if ( cur < limit && (FT_Byte)( *cur - '0' ) < 10 )
{ {
*size = Z1_ToInt( parser ); *size = T1_ToInt( parser );
Z1_Skip_Spaces( parser ); T1_Skip_Spaces( parser );
Z1_Skip_Alpha ( parser ); /* `RD' or `-|' or something else */ T1_Skip_Alpha ( parser ); /* `RD' or `-|' or something else */
/* there is only one whitespace char after the */ /* there is only one whitespace char after the */
/* `RD' or `-|' token */ /* `RD' or `-|' token */
@ -824,18 +824,18 @@
static static
void parse_font_name( T1_Face face, void parse_font_name( T1_Face face,
Z1_Loader* loader ) T1_Loader* loader )
{ {
Z1_Parser* parser = &loader->parser; T1_ParserRec* parser = &loader->parser;
FT_Error error; FT_Error error;
FT_Memory memory = parser->root.memory; FT_Memory memory = parser->root.memory;
FT_Int len; FT_Int len;
FT_Byte* cur; FT_Byte* cur;
FT_Byte* cur2; FT_Byte* cur2;
FT_Byte* limit; FT_Byte* limit;
Z1_Skip_Spaces( parser ); T1_Skip_Spaces( parser );
cur = parser->root.cursor; cur = parser->root.cursor;
limit = parser->root.limit; limit = parser->root.limit;
@ -866,14 +866,14 @@
static static
void parse_font_bbox( T1_Face face, void parse_font_bbox( T1_Face face,
Z1_Loader* loader ) T1_Loader* loader )
{ {
Z1_Parser* parser = &loader->parser; T1_ParserRec* parser = &loader->parser;
FT_Short temp[4]; FT_Short temp[4];
FT_BBox* bbox = &face->type1.font_bbox; FT_BBox* bbox = &face->type1.font_bbox;
(void)Z1_ToCoordArray( parser, 4, temp ); (void)T1_ToCoordArray( parser, 4, temp );
bbox->xMin = temp[0]; bbox->xMin = temp[0];
bbox->yMin = temp[1]; bbox->yMin = temp[1];
bbox->xMax = temp[2]; bbox->xMax = temp[2];
@ -883,19 +883,19 @@
static static
void parse_font_matrix( T1_Face face, void parse_font_matrix( T1_Face face,
Z1_Loader* loader ) T1_Loader* loader )
{ {
Z1_Parser* parser = &loader->parser; T1_ParserRec* parser = &loader->parser;
FT_Matrix* matrix = &face->type1.font_matrix; FT_Matrix* matrix = &face->type1.font_matrix;
FT_Vector* offset = &face->type1.font_offset; FT_Vector* offset = &face->type1.font_offset;
FT_Fixed temp[6]; FT_Fixed temp[6];
if ( matrix->xx || matrix->yx ) if ( matrix->xx || matrix->yx )
/* with synthetic fonts, it's possible we get here twice */ /* with synthetic fonts, it's possible we get here twice */
return; return;
(void)Z1_ToFixedArray( parser, 6, temp, 3 ); (void)T1_ToFixedArray( parser, 6, temp, 3 );
/* we need to scale the values by 1.0/temp[3] */ /* we need to scale the values by 1.0/temp[3] */
if ( temp[3] != 0x10000L ) if ( temp[3] != 0x10000L )
@ -921,11 +921,11 @@
static static
void parse_encoding( T1_Face face, void parse_encoding( T1_Face face,
Z1_Loader* loader ) T1_Loader* loader )
{ {
Z1_Parser* parser = &loader->parser; T1_ParserRec* parser = &loader->parser;
FT_Byte* cur = parser->root.cursor; FT_Byte* cur = parser->root.cursor;
FT_Byte* limit = parser->root.limit; FT_Byte* limit = parser->root.limit;
PSAux_Interface* psaux = (PSAux_Interface*)face->psaux; PSAux_Interface* psaux = (PSAux_Interface*)face->psaux;
@ -954,11 +954,11 @@
/* read the number of entries in the encoding, should be 256 */ /* read the number of entries in the encoding, should be 256 */
count = Z1_ToInt( parser ); count = T1_ToInt( parser );
if ( parser->root.error ) if ( parser->root.error )
return; return;
/* we use a Z1_Table to store our charnames */ /* we use a T1_Table to store our charnames */
encode->num_chars = count; encode->num_chars = count;
if ( ALLOC_ARRAY( encode->char_index, count, FT_Short ) || if ( ALLOC_ARRAY( encode->char_index, count, FT_Short ) ||
ALLOC_ARRAY( encode->char_name, count, FT_String* ) || ALLOC_ARRAY( encode->char_name, count, FT_String* ) ||
@ -975,7 +975,7 @@
char* notdef = ".notdef"; char* notdef = ".notdef";
Z1_Add_Table( char_table, n, notdef, 8 ); T1_Add_Table( char_table, n, notdef, 8 );
} }
/* Now, we will need to read a record of the form */ /* Now, we will need to read a record of the form */
@ -1022,7 +1022,7 @@
parser->root.cursor = cur; parser->root.cursor = cur;
charcode = Z1_ToInt( parser ); charcode = T1_ToInt( parser );
cur = parser->root.cursor; cur = parser->root.cursor;
/* skip whitespace */ /* skip whitespace */
@ -1042,7 +1042,7 @@
len = cur2 - cur - 1; len = cur2 - cur - 1;
parser->root.error = Z1_Add_Table( char_table, charcode, parser->root.error = T1_Add_Table( char_table, charcode,
cur + 1, len + 1 ); cur + 1, len + 1 );
char_table->elements[charcode][len] = '\0'; char_table->elements[charcode][len] = '\0';
if ( parser->root.error ) if ( parser->root.error )
@ -1081,25 +1081,25 @@
static static
void parse_subrs( T1_Face face, void parse_subrs( T1_Face face,
Z1_Loader* loader ) T1_Loader* loader )
{ {
Z1_Parser* parser = &loader->parser; T1_ParserRec* parser = &loader->parser;
PS_Table* table = &loader->subrs; PS_Table* table = &loader->subrs;
FT_Memory memory = parser->root.memory; FT_Memory memory = parser->root.memory;
FT_Error error; FT_Error error;
FT_Int n; FT_Int n;
PSAux_Interface* psaux = (PSAux_Interface*)face->psaux; PSAux_Interface* psaux = (PSAux_Interface*)face->psaux;
loader->num_subrs = Z1_ToInt( parser ); loader->num_subrs = T1_ToInt( parser );
if ( parser->root.error ) if ( parser->root.error )
return; return;
/* position the parser right before the `dup' of the first subr */ /* position the parser right before the `dup' of the first subr */
Z1_Skip_Spaces( parser ); T1_Skip_Spaces( parser );
Z1_Skip_Alpha( parser ); /* `array' */ T1_Skip_Alpha( parser ); /* `array' */
Z1_Skip_Spaces( parser ); T1_Skip_Spaces( parser );
/* initialize subrs array */ /* initialize subrs array */
error = psaux->ps_table_funcs->init( table, loader->num_subrs, memory ); error = psaux->ps_table_funcs->init( table, loader->num_subrs, memory );
@ -1122,7 +1122,7 @@
if ( strncmp( (char*)parser->root.cursor, "dup", 3 ) != 0 ) if ( strncmp( (char*)parser->root.cursor, "dup", 3 ) != 0 )
break; break;
index = Z1_ToInt( parser ); index = T1_ToInt( parser );
if ( !read_binary_data( parser, &size, &base ) ) if ( !read_binary_data( parser, &size, &base ) )
return; return;
@ -1131,14 +1131,14 @@
/* (bound to `noaccess put') or by two separate tokens: */ /* (bound to `noaccess put') or by two separate tokens: */
/* `noaccess' & `put'. We position the parser right */ /* `noaccess' & `put'. We position the parser right */
/* before the next `dup', if any. */ /* before the next `dup', if any. */
Z1_Skip_Spaces( parser ); T1_Skip_Spaces( parser );
Z1_Skip_Alpha( parser ); /* `NP' or `I' or `noaccess' */ T1_Skip_Alpha( parser ); /* `NP' or `I' or `noaccess' */
Z1_Skip_Spaces( parser ); T1_Skip_Spaces( parser );
if ( strncmp( (char*)parser->root.cursor, "put", 3 ) == 0 ) if ( strncmp( (char*)parser->root.cursor, "put", 3 ) == 0 )
{ {
Z1_Skip_Alpha( parser ); /* skip `put' */ T1_Skip_Alpha( parser ); /* skip `put' */
Z1_Skip_Spaces( parser ); T1_Skip_Spaces( parser );
} }
/* some fonts use a value of -1 for lenIV to indicate that */ /* some fonts use a value of -1 for lenIV to indicate that */
@ -1148,12 +1148,12 @@
/* */ /* */
if ( face->type1.private_dict.lenIV >= 0 ) if ( face->type1.private_dict.lenIV >= 0 )
{ {
Z1_Decrypt( base, size, 4330 ); T1_Decrypt( base, size, 4330 );
size -= face->type1.private_dict.lenIV; size -= face->type1.private_dict.lenIV;
base += face->type1.private_dict.lenIV; base += face->type1.private_dict.lenIV;
} }
error = Z1_Add_Table( table, index, base, size ); error = T1_Add_Table( table, index, base, size );
if ( error ) if ( error )
goto Fail; goto Fail;
} }
@ -1166,13 +1166,13 @@
static static
void parse_charstrings( T1_Face face, void parse_charstrings( T1_Face face,
Z1_Loader* loader ) T1_Loader* loader )
{ {
Z1_Parser* parser = &loader->parser; T1_ParserRec* parser = &loader->parser;
PS_Table* code_table = &loader->charstrings; PS_Table* code_table = &loader->charstrings;
PS_Table* name_table = &loader->glyph_names; PS_Table* name_table = &loader->glyph_names;
FT_Memory memory = parser->root.memory; FT_Memory memory = parser->root.memory;
FT_Error error; FT_Error error;
PSAux_Interface* psaux = (PSAux_Interface*)face->psaux; PSAux_Interface* psaux = (PSAux_Interface*)face->psaux;
@ -1187,7 +1187,7 @@
/* with synthetic fonts, it's possible we get here twice */ /* with synthetic fonts, it's possible we get here twice */
return; return;
loader->num_glyphs = Z1_ToInt( parser ); loader->num_glyphs = T1_ToInt( parser );
if ( parser->root.error ) if ( parser->root.error )
return; return;
@ -1216,7 +1216,7 @@
/* */ /* */
/* note that we stop when we find a `def' */ /* note that we stop when we find a `def' */
/* */ /* */
Z1_Skip_Spaces( parser ); T1_Skip_Spaces( parser );
cur = parser->root.cursor; cur = parser->root.cursor;
if ( cur >= limit ) if ( cur >= limit )
@ -1236,7 +1236,7 @@
break; break;
if ( *cur != '/' ) if ( *cur != '/' )
Z1_Skip_Alpha( parser ); T1_Skip_Alpha( parser );
else else
{ {
FT_Byte* cur2 = cur + 1; FT_Byte* cur2 = cur + 1;
@ -1247,7 +1247,7 @@
cur2++; cur2++;
len = cur2 - cur - 1; len = cur2 - cur - 1;
error = Z1_Add_Table( name_table, n, cur + 1, len + 1 ); error = T1_Add_Table( name_table, n, cur + 1, len + 1 );
if ( error ) if ( error )
goto Fail; goto Fail;
@ -1268,12 +1268,12 @@
if ( face->type1.private_dict.lenIV >= 0 ) if ( face->type1.private_dict.lenIV >= 0 )
{ {
Z1_Decrypt( base, size, 4330 ); T1_Decrypt( base, size, 4330 );
size -= face->type1.private_dict.lenIV; size -= face->type1.private_dict.lenIV;
base += face->type1.private_dict.lenIV; base += face->type1.private_dict.lenIV;
} }
error = Z1_Add_Table( code_table, n, base, size ); error = T1_Add_Table( code_table, n, base, size );
if ( error ) if ( error )
goto Fail; goto Fail;
@ -1296,36 +1296,36 @@
/* index 0. Then take end of table name/code and place it into index */ /* index 0. Then take end of table name/code and place it into index */
/* notdef_index. */ /* notdef_index. */
error = Z1_Add_Table( name_table, n, error = T1_Add_Table( name_table, n,
name_table->elements[0], name_table->elements[0],
name_table->lengths [0] ); name_table->lengths [0] );
if ( error ) if ( error )
goto Fail; goto Fail;
error = Z1_Add_Table( code_table, n, error = T1_Add_Table( code_table, n,
code_table->elements[0], code_table->elements[0],
code_table->lengths [0] ); code_table->lengths [0] );
if ( error ) if ( error )
goto Fail; goto Fail;
error = Z1_Add_Table( name_table, 0, error = T1_Add_Table( name_table, 0,
name_table->elements[notdef_index], name_table->elements[notdef_index],
name_table->lengths [notdef_index] ); name_table->lengths [notdef_index] );
if ( error ) if ( error )
goto Fail; goto Fail;
error = Z1_Add_Table( code_table, 0, error = T1_Add_Table( code_table, 0,
code_table->elements[notdef_index], code_table->elements[notdef_index],
code_table->lengths [notdef_index] ); code_table->lengths [notdef_index] );
if ( error ) if ( error )
goto Fail; goto Fail;
error = Z1_Add_Table( name_table, notdef_index, error = T1_Add_Table( name_table, notdef_index,
name_table->elements[n], name_table->elements[n],
name_table->lengths [n] ); name_table->lengths [n] );
if ( error ) if ( error )
goto Fail; goto Fail;
error = Z1_Add_Table( code_table, notdef_index, error = T1_Add_Table( code_table, notdef_index,
code_table->elements[n], code_table->elements[n],
code_table->lengths [n] ); code_table->lengths [n] );
if ( error ) if ( error )
@ -1345,23 +1345,23 @@
char* notdef_name = ".notdef"; char* notdef_name = ".notdef";
error = Z1_Add_Table( name_table, n, error = T1_Add_Table( name_table, n,
name_table->elements[0], name_table->elements[0],
name_table->lengths [0] ); name_table->lengths [0] );
if ( error ) if ( error )
goto Fail; goto Fail;
error = Z1_Add_Table( code_table, n, error = T1_Add_Table( code_table, n,
code_table->elements[0], code_table->elements[0],
code_table->lengths [0] ); code_table->lengths [0] );
if ( error ) if ( error )
goto Fail; goto Fail;
error = Z1_Add_Table( name_table, 0, notdef_name, 8 ); error = T1_Add_Table( name_table, 0, notdef_name, 8 );
if ( error ) if ( error )
goto Fail; goto Fail;
error = Z1_Add_Table( code_table, 0, notdef_glyph, 5 ); error = T1_Add_Table( code_table, 0, notdef_glyph, 5 );
if ( error ) if ( error )
goto Fail; goto Fail;
@ -1384,11 +1384,11 @@
#ifdef FT_FLAT_COMPILE #ifdef FT_FLAT_COMPILE
#include "z1tokens.h" #include "t1tokens.h"
#else #else
#include <type1/z1tokens.h> #include <type1/t1tokens.h>
#endif #endif
@ -1400,7 +1400,7 @@
T1_FIELD_CALLBACK( "Subrs", parse_subrs ) T1_FIELD_CALLBACK( "Subrs", parse_subrs )
T1_FIELD_CALLBACK( "CharStrings", parse_charstrings ) T1_FIELD_CALLBACK( "CharStrings", parse_charstrings )
#ifndef Z1_CONFIG_OPTION_NO_MM_SUPPORT #ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT
T1_FIELD_CALLBACK( "BlendDesignPositions", parse_blend_design_positions ) T1_FIELD_CALLBACK( "BlendDesignPositions", parse_blend_design_positions )
T1_FIELD_CALLBACK( "BlendDesignMap", parse_blend_design_map ) T1_FIELD_CALLBACK( "BlendDesignMap", parse_blend_design_map )
T1_FIELD_CALLBACK( "BlendAxisTypes", parse_blend_axis_types ) T1_FIELD_CALLBACK( "BlendAxisTypes", parse_blend_axis_types )
@ -1414,11 +1414,11 @@
static static
FT_Error parse_dict( T1_Face face, FT_Error parse_dict( T1_Face face,
Z1_Loader* loader, T1_Loader* loader,
FT_Byte* base, FT_Byte* base,
FT_Long size ) FT_Long size )
{ {
Z1_Parser* parser = &loader->parser; T1_ParserRec* parser = &loader->parser;
parser->root.cursor = base; parser->root.cursor = base;
@ -1456,7 +1456,7 @@
/* skip the `known' keyword and the token following it */ /* skip the `known' keyword and the token following it */
cur += 5; cur += 5;
loader->parser.root.cursor = cur; loader->parser.root.cursor = cur;
Z1_ToToken( &loader->parser, &token ); T1_ToToken( &loader->parser, &token );
/* if the last token was an array, skip it! */ /* if the last token was an array, skip it! */
if ( token.type == t1_token_array ) if ( token.type == t1_token_array )
@ -1513,7 +1513,7 @@
{ {
/* we found it -- run the parsing callback! */ /* we found it -- run the parsing callback! */
parser->root.cursor = cur2; parser->root.cursor = cur2;
Z1_Skip_Spaces( parser ); T1_Skip_Spaces( parser );
parser->root.error = t1_load_keyword( face, parser->root.error = t1_load_keyword( face,
loader, loader,
keyword ); keyword );
@ -1536,7 +1536,7 @@
static static
void t1_init_loader( Z1_Loader* loader, void t1_init_loader( T1_Loader* loader,
T1_Face face ) T1_Face face )
{ {
FT_UNUSED( face ); FT_UNUSED( face );
@ -1555,29 +1555,29 @@
static static
void t1_done_loader( Z1_Loader* loader ) void t1_done_loader( T1_Loader* loader )
{ {
Z1_Parser* parser = &loader->parser; T1_ParserRec* parser = &loader->parser;
/* finalize tables */ /* finalize tables */
Z1_Release_Table( &loader->encoding_table ); T1_Release_Table( &loader->encoding_table );
Z1_Release_Table( &loader->charstrings ); T1_Release_Table( &loader->charstrings );
Z1_Release_Table( &loader->glyph_names ); T1_Release_Table( &loader->glyph_names );
Z1_Release_Table( &loader->subrs ); T1_Release_Table( &loader->subrs );
/* finalize parser */ /* finalize parser */
Z1_Done_Parser( parser ); T1_Done_Parser( parser );
} }
LOCAL_FUNC LOCAL_FUNC
FT_Error Z1_Open_Face( T1_Face face ) FT_Error T1_Open_Face( T1_Face face )
{ {
Z1_Loader loader; T1_Loader loader;
Z1_Parser* parser; T1_ParserRec* parser;
T1_Font* type1 = &face->type1; T1_Font* type1 = &face->type1;
FT_Error error; FT_Error error;
PSAux_Interface* psaux = (PSAux_Interface*)face->psaux; PSAux_Interface* psaux = (PSAux_Interface*)face->psaux;
@ -1588,7 +1588,7 @@
type1->private_dict.lenIV = 4; type1->private_dict.lenIV = 4;
parser = &loader.parser; parser = &loader.parser;
error = Z1_New_Parser( parser, error = T1_New_Parser( parser,
face->root.stream, face->root.stream,
face->root.memory, face->root.memory,
psaux ); psaux );
@ -1599,7 +1599,7 @@
if ( error ) if ( error )
goto Exit; goto Exit;
error = Z1_Get_Private_Dict( parser ); error = T1_Get_Private_Dict( parser );
if ( error ) if ( error )
goto Exit; goto Exit;
@ -1614,13 +1614,13 @@
if ( !loader.subrs.init ) if ( !loader.subrs.init )
{ {
FT_ERROR(( "Z1_Open_Face: no subrs array in face!\n" )); FT_ERROR(( "T1_Open_Face: no subrs array in face!\n" ));
error = T1_Err_Invalid_File_Format; error = T1_Err_Invalid_File_Format;
} }
if ( !loader.charstrings.init ) if ( !loader.charstrings.init )
{ {
FT_ERROR(( "Z1_Open_Face: no charstrings array in face!\n" )); FT_ERROR(( "T1_Open_Face: no charstrings array in face!\n" ));
error = T1_Err_Invalid_File_Format; error = T1_Err_Invalid_File_Format;
} }

52
src/type1/z1load.h → src/type1/t1load.h
View File

@ -1,8 +1,8 @@
/***************************************************************************/ /***************************************************************************/
/* */ /* */
/* z1load.h */ /* t1load.h */
/* */ /* */
/* Experimental Type 1 font loader (specification). */ /* Type 1 font loader (specification). */
/* */ /* */
/* Copyright 1996-2000 by */ /* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -16,8 +16,8 @@
/***************************************************************************/ /***************************************************************************/
#ifndef Z1LOAD_H #ifndef T1LOAD_H
#define Z1LOAD_H #define T1LOAD_H
#include <freetype/internal/ftstream.h> #include <freetype/internal/ftstream.h>
#include <freetype/internal/psaux.h> #include <freetype/internal/psaux.h>
@ -26,11 +26,11 @@
#ifdef FT_FLAT_COMPILE #ifdef FT_FLAT_COMPILE
#include "z1parse.h" #include "t1parse.h"
#else #else
#include <type1/z1parse.h> #include <type1/t1parse.h>
#endif #endif
@ -39,55 +39,55 @@
extern "C" { extern "C" {
#endif #endif
typedef struct Z1_Loader_ typedef struct T1_Loader_
{ {
Z1_Parser parser; /* parser used to read the stream */ T1_ParserRec parser; /* parser used to read the stream */
FT_Int num_chars; /* number of characters in encoding */ FT_Int num_chars; /* number of characters in encoding */
PS_Table encoding_table; /* PS_Table used to store the */ PS_Table encoding_table; /* PS_Table used to store the */
/* encoding character names */ /* encoding character names */
FT_Int num_glyphs; FT_Int num_glyphs;
PS_Table glyph_names; PS_Table glyph_names;
PS_Table charstrings; PS_Table charstrings;
FT_Int num_subrs; FT_Int num_subrs;
PS_Table subrs; PS_Table subrs;
FT_Bool fontdata; FT_Bool fontdata;
} Z1_Loader; } T1_Loader;
LOCAL_DEF LOCAL_DEF
FT_Error Z1_Open_Face( T1_Face face ); FT_Error T1_Open_Face( T1_Face face );
#ifndef Z1_CONFIG_OPTION_NO_MM_SUPPORT #ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT
LOCAL_DEF LOCAL_DEF
FT_Error Z1_Get_Multi_Master( T1_Face face, FT_Error T1_Get_Multi_Master( T1_Face face,
FT_Multi_Master* master ); FT_Multi_Master* master );
LOCAL_DEF LOCAL_DEF
FT_Error Z1_Set_MM_Blend( T1_Face face, FT_Error T1_Set_MM_Blend( T1_Face face,
FT_UInt num_coords, FT_UInt num_coords,
FT_Fixed* coords ); FT_Fixed* coords );
LOCAL_DEF LOCAL_DEF
FT_Error Z1_Set_MM_Design( T1_Face face, FT_Error T1_Set_MM_Design( T1_Face face,
FT_UInt num_coords, FT_UInt num_coords,
FT_Long* coords ); FT_Long* coords );
LOCAL_DEF LOCAL_DEF
void Z1_Done_Blend( T1_Face face ); void T1_Done_Blend( T1_Face face );
#endif /* !Z1_CONFIG_OPTION_NO_MM_SUPPORT */ #endif /* !T1_CONFIG_OPTION_NO_MM_SUPPORT */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* Z1LOAD_H */ #endif /* T1LOAD_H */
/* END */ /* END */

48
src/type1/z1objs.c → src/type1/t1objs.c
View File

@ -1,8 +1,8 @@
/***************************************************************************/ /***************************************************************************/
/* */ /* */
/* z1objs.c */ /* t1objs.c */
/* */ /* */
/* Experimental Type 1 objects manager (body). */ /* Type 1 objects manager (body). */
/* */ /* */
/* Copyright 1996-2000 by */ /* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -22,15 +22,15 @@
#ifdef FT_FLAT_COMPILE #ifdef FT_FLAT_COMPILE
#include "z1gload.h" #include "t1gload.h"
#include "z1load.h" #include "t1load.h"
#include "z1afm.h" #include "t1afm.h"
#else #else
#include <type1/z1gload.h> #include <type1/t1gload.h>
#include <type1/z1load.h> #include <type1/t1load.h>
#include <type1/z1afm.h> #include <type1/t1afm.h>
#endif #endif
@ -46,7 +46,7 @@
/* messages during execution. */ /* messages during execution. */
/* */ /* */
#undef FT_COMPONENT #undef FT_COMPONENT
#define FT_COMPONENT trace_z1objs #define FT_COMPONENT trace_t1objs
/*************************************************************************/ /*************************************************************************/
@ -59,7 +59,7 @@
/*************************************************************************/ /*************************************************************************/
/* */ /* */
/* <Function> */ /* <Function> */
/* Z1_Done_Face */ /* T1_Done_Face */
/* */ /* */
/* <Description> */ /* <Description> */
/* The face object destructor. */ /* The face object destructor. */
@ -68,7 +68,7 @@
/* face :: A typeless pointer to the face object to destroy. */ /* face :: A typeless pointer to the face object to destroy. */
/* */ /* */
LOCAL_FUNC LOCAL_FUNC
void Z1_Done_Face( T1_Face face ) void T1_Done_Face( T1_Face face )
{ {
FT_Memory memory; FT_Memory memory;
T1_Font* type1 = &face->type1; T1_Font* type1 = &face->type1;
@ -78,9 +78,9 @@
{ {
memory = face->root.memory; memory = face->root.memory;
#ifndef Z1_CONFIG_OPTION_NO_MM_SUPPORT #ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT
/* release multiple masters information */ /* release multiple masters information */
Z1_Done_Blend( face ); T1_Done_Blend( face );
face->blend = 0; face->blend = 0;
#endif #endif
@ -111,10 +111,10 @@
FREE( type1->encoding.char_index ); FREE( type1->encoding.char_index );
FREE( type1->font_name ); FREE( type1->font_name );
#ifndef Z1_CONFIG_OPTION_NO_AFM #ifndef T1_CONFIG_OPTION_NO_AFM
/* release afm data if present */ /* release afm data if present */
if ( face->afm_data ) if ( face->afm_data )
Z1_Done_AFM( memory, (Z1_AFM*)face->afm_data ); T1_Done_AFM( memory, (T1_AFM*)face->afm_data );
#endif #endif
/* release unicode map, if any */ /* release unicode map, if any */
@ -130,7 +130,7 @@
/*************************************************************************/ /*************************************************************************/
/* */ /* */
/* <Function> */ /* <Function> */
/* Z1_Init_Face */ /* T1_Init_Face */
/* */ /* */
/* <Description> */ /* <Description> */
/* The face object constructor. */ /* The face object constructor. */
@ -151,7 +151,7 @@
/* FreeType error code. 0 means success. */ /* FreeType error code. 0 means success. */
/* */ /* */
LOCAL_FUNC LOCAL_FUNC
FT_Error Z1_Init_Face( FT_Stream stream, FT_Error T1_Init_Face( FT_Stream stream,
T1_Face face, T1_Face face,
FT_Int face_index, FT_Int face_index,
FT_Int num_params, FT_Int num_params,
@ -188,7 +188,7 @@
} }
/* open the tokenizer, this will also check the font format */ /* open the tokenizer, this will also check the font format */
error = Z1_Open_Face( face ); error = T1_Open_Face( face );
if ( error ) if ( error )
goto Exit; goto Exit;
@ -199,7 +199,7 @@
/* check the face index */ /* check the face index */
if ( face_index != 0 ) if ( face_index != 0 )
{ {
FT_ERROR(( "Z1_Init_Face: invalid face index\n" )); FT_ERROR(( "T1_Init_Face: invalid face index\n" ));
error = T1_Err_Invalid_Argument; error = T1_Err_Invalid_Argument;
goto Exit; goto Exit;
} }
@ -278,7 +278,7 @@
FT_Int max_advance; FT_Int max_advance;
error = Z1_Compute_Max_Advance( face, &max_advance ); error = T1_Compute_Max_Advance( face, &max_advance );
/* in case of error, keep the standard width */ /* in case of error, keep the standard width */
if ( !error ) if ( !error )
@ -365,7 +365,7 @@
/*************************************************************************/ /*************************************************************************/
/* */ /* */
/* <Function> */ /* <Function> */
/* Z1_Init_Driver */ /* T1_Init_Driver */
/* */ /* */
/* <Description> */ /* <Description> */
/* Initializes a given Type 1 driver object. */ /* Initializes a given Type 1 driver object. */
@ -377,7 +377,7 @@
/* FreeType error code. 0 means success. */ /* FreeType error code. 0 means success. */
/* */ /* */
LOCAL_FUNC LOCAL_FUNC
FT_Error Z1_Init_Driver( Z1_Driver driver ) FT_Error T1_Init_Driver( T1_Driver driver )
{ {
FT_UNUSED( driver ); FT_UNUSED( driver );
@ -388,7 +388,7 @@
/*************************************************************************/ /*************************************************************************/
/* */ /* */
/* <Function> */ /* <Function> */
/* Z1_Done_Driver */ /* T1_Done_Driver */
/* */ /* */
/* <Description> */ /* <Description> */
/* Finalizes a given Type 1 driver. */ /* Finalizes a given Type 1 driver. */
@ -397,7 +397,7 @@
/* driver :: A handle to the target Type 1 driver. */ /* driver :: A handle to the target Type 1 driver. */
/* */ /* */
LOCAL_DEF LOCAL_DEF
void Z1_Done_Driver( Z1_Driver driver ) void T1_Done_Driver( T1_Driver driver )
{ {
FT_UNUSED( driver ); FT_UNUSED( driver );
} }

56
src/type1/z1objs.h → src/type1/t1objs.h
View File

@ -1,8 +1,8 @@
/***************************************************************************/ /***************************************************************************/
/* */ /* */
/* z1objs.h */ /* t1objs.h */
/* */ /* */
/* Experimental Type 1 objects manager (specification). */ /* Type 1 objects manager (specification). */
/* */ /* */
/* Copyright 1996-2000 by */ /* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -16,8 +16,8 @@
/***************************************************************************/ /***************************************************************************/
#ifndef Z1OBJS_H #ifndef T1OBJS_H
#define Z1OBJS_H #define T1OBJS_H
#include <freetype/internal/ftobjs.h> #include <freetype/internal/ftobjs.h>
#include <freetype/config/ftconfig.h> #include <freetype/config/ftconfig.h>
@ -29,47 +29,47 @@
#endif #endif
/* The following structures must be defined by the hinter */ /* The following structures must be defined by the hinter */
typedef struct Z1_Size_Hints_ Z1_Size_Hints; typedef struct T1_Size_Hints_ T1_Size_Hints;
typedef struct Z1_Glyph_Hints_ Z1_Glyph_Hints; typedef struct T1_Glyph_Hints_ T1_Glyph_Hints;
/*************************************************************************/ /*************************************************************************/
/* */ /* */
/* <Type> */ /* <Type> */
/* Z1_Driver */ /* T1_Driver */
/* */ /* */
/* <Description> */ /* <Description> */
/* A handle to a Type 1 driver object. */ /* A handle to a Type 1 driver object. */
/* */ /* */
typedef struct Z1_DriverRec_ *Z1_Driver; typedef struct T1_DriverRec_ *T1_Driver;
/*************************************************************************/ /*************************************************************************/
/* */ /* */
/* <Type> */ /* <Type> */
/* Z1_Size */ /* T1_Size */
/* */ /* */
/* <Description> */ /* <Description> */
/* A handle to a Type 1 size object. */ /* A handle to a Type 1 size object. */
/* */ /* */
typedef struct Z1_SizeRec_* Z1_Size; typedef struct T1_SizeRec_* T1_Size;
/*************************************************************************/ /*************************************************************************/
/* */ /* */
/* <Type> */ /* <Type> */
/* Z1_GlyphSlot */ /* T1_GlyphSlot */
/* */ /* */
/* <Description> */ /* <Description> */
/* A handle to a Type 1 glyph slot object. */ /* A handle to a Type 1 glyph slot object. */
/* */ /* */
typedef struct Z1_GlyphSlotRec_* Z1_GlyphSlot; typedef struct T1_GlyphSlotRec_* T1_GlyphSlot;
/*************************************************************************/ /*************************************************************************/
/* */ /* */
/* <Type> */ /* <Type> */
/* Z1_CharMap */ /* T1_CharMap */
/* */ /* */
/* <Description> */ /* <Description> */
/* A handle to a Type 1 character mapping object. */ /* A handle to a Type 1 character mapping object. */
@ -79,7 +79,7 @@
/* The driver is responsible for making up charmap objects */ /* The driver is responsible for making up charmap objects */
/* corresponding to these tables. */ /* corresponding to these tables. */
/* */ /* */
typedef struct Z1_CharMapRec_* Z1_CharMap; typedef struct T1_CharMapRec_* T1_CharMap;
/*************************************************************************/ /*************************************************************************/
@ -92,31 +92,31 @@
/*************************************************************************/ /*************************************************************************/
/* */ /* */
/* <Type> */ /* <Type> */
/* Z1_SizeRec */ /* T1_SizeRec */
/* */ /* */
/* <Description> */ /* <Description> */
/* Type 1 size record. */ /* Type 1 size record. */
/* */ /* */
typedef struct Z1_SizeRec_ typedef struct T1_SizeRec_
{ {
FT_SizeRec root; FT_SizeRec root;
FT_Bool valid; FT_Bool valid;
Z1_Size_Hints* hints; /* defined in the hinter. This allows */ T1_Size_Hints* hints; /* defined in the hinter. This allows */
/* us to experiment with different */ /* us to experiment with different */
/* hinting schemes without having to */ /* hinting schemes without having to */
/* change `z1objs' each time. */ /* change `t1objs' each time. */
} Z1_SizeRec; } T1_SizeRec;
/*************************************************************************/ /*************************************************************************/
/* */ /* */
/* <Type> */ /* <Type> */
/* Z1_GlyphSlotRec */ /* T1_GlyphSlotRec */
/* */ /* */
/* <Description> */ /* <Description> */
/* Type 1 glyph slot record. */ /* Type 1 glyph slot record. */
/* */ /* */
typedef struct Z1_GlyphSlotRec_ typedef struct T1_GlyphSlotRec_
{ {
FT_GlyphSlotRec root; FT_GlyphSlotRec root;
@ -129,33 +129,33 @@
FT_Fixed x_scale; FT_Fixed x_scale;
FT_Fixed y_scale; FT_Fixed y_scale;
Z1_Glyph_Hints* hints; /* defined in the hinter */ T1_Glyph_Hints* hints; /* defined in the hinter */
} Z1_GlyphSlotRec; } T1_GlyphSlotRec;
LOCAL_DEF LOCAL_DEF
FT_Error Z1_Init_Face( FT_Stream stream, FT_Error T1_Init_Face( FT_Stream stream,
T1_Face face, T1_Face face,
FT_Int face_index, FT_Int face_index,
FT_Int num_params, FT_Int num_params,
FT_Parameter* params ); FT_Parameter* params );
LOCAL_DEF LOCAL_DEF
void Z1_Done_Face( T1_Face face ); void T1_Done_Face( T1_Face face );
LOCAL_DEF LOCAL_DEF
FT_Error Z1_Init_Driver( Z1_Driver driver ); FT_Error T1_Init_Driver( T1_Driver driver );
LOCAL_DEF LOCAL_DEF
void Z1_Done_Driver( Z1_Driver driver ); void T1_Done_Driver( T1_Driver driver );
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* Z1OBJS_H */ #endif /* T1OBJS_H */
/* END */ /* END */

34
src/type1/z1parse.c → src/type1/t1parse.c
View File

@ -1,8 +1,8 @@
/***************************************************************************/ /***************************************************************************/
/* */ /* */
/* z1parse.c */ /* t1parse.c */
/* */ /* */
/* Experimental Type 1 parser (body). */ /* Type 1 parser (body). */
/* */ /* */
/* Copyright 1996-2000 by */ /* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -21,14 +21,14 @@
/* The Type 1 parser is in charge of the following: */ /* The Type 1 parser is in charge of the following: */
/* */ /* */
/* - provide an implementation of a growing sequence of objects called */ /* - provide an implementation of a growing sequence of objects called */
/* a `Z1_Table' (used to build various tables needed by the loader). */ /* a `T1_Table' (used to build various tables needed by the loader). */
/* */ /* */
/* - opening .pfb and .pfa files to extract their top-level and private */ /* - opening .pfb and .pfa files to extract their top-level and private */
/* dictionaries. */ /* dictionaries. */
/* */ /* */
/* - read numbers, arrays & strings from any dictionary. */ /* - read numbers, arrays & strings from any dictionary. */
/* */ /* */
/* See `z1load.c' to see how data is loaded from the font file. */ /* See `t1load.c' to see how data is loaded from the font file. */
/* */ /* */
/*************************************************************************/ /*************************************************************************/
@ -42,11 +42,11 @@
#ifdef FT_FLAT_COMPILE #ifdef FT_FLAT_COMPILE
#include "z1parse.h" #include "t1parse.h"
#else #else
#include <type1/z1parse.h> #include <type1/t1parse.h>
#endif #endif
@ -61,7 +61,7 @@
/* messages during execution. */ /* messages during execution. */
/* */ /* */
#undef FT_COMPONENT #undef FT_COMPONENT
#define FT_COMPONENT trace_z1parse #define FT_COMPONENT trace_t1parse
/*************************************************************************/ /*************************************************************************/
@ -75,10 +75,10 @@
/*************************************************************************/ /*************************************************************************/
#define IS_Z1_WHITESPACE( c ) ( (c) == ' ' || (c) == '\t' ) #define IS_T1_WHITESPACE( c ) ( (c) == ' ' || (c) == '\t' )
#define IS_Z1_LINESPACE( c ) ( (c) == '\r' || (c) == '\n' ) #define IS_T1_LINESPACE( c ) ( (c) == '\r' || (c) == '\n' )
#define IS_Z1_SPACE( c ) ( IS_Z1_WHITESPACE( c ) || IS_Z1_LINESPACE( c ) ) #define IS_T1_SPACE( c ) ( IS_T1_WHITESPACE( c ) || IS_T1_LINESPACE( c ) )
typedef struct PFB_Tag_ typedef struct PFB_Tag_
@ -127,7 +127,7 @@
LOCAL_FUNC LOCAL_FUNC
FT_Error Z1_New_Parser( Z1_Parser* parser, FT_Error T1_New_Parser( T1_ParserRec* parser,
FT_Stream stream, FT_Stream stream,
FT_Memory memory, FT_Memory memory,
PSAux_Interface* psaux ) PSAux_Interface* psaux )
@ -236,7 +236,7 @@
LOCAL_FUNC LOCAL_FUNC
void Z1_Done_Parser( Z1_Parser* parser ) void T1_Done_Parser( T1_ParserRec* parser )
{ {
FT_Memory memory = parser->root.memory; FT_Memory memory = parser->root.memory;
@ -276,7 +276,7 @@
LOCAL_FUNC LOCAL_FUNC
void Z1_Decrypt( FT_Byte* buffer, void T1_Decrypt( FT_Byte* buffer,
FT_Int length, FT_Int length,
FT_UShort seed ) FT_UShort seed )
{ {
@ -294,7 +294,7 @@
LOCAL_FUNC LOCAL_FUNC
FT_Error Z1_Get_Private_Dict( Z1_Parser* parser ) FT_Error T1_Get_Private_Dict( T1_ParserRec* parser )
{ {
FT_Stream stream = parser->stream; FT_Stream stream = parser->stream;
FT_Memory memory = parser->root.memory; FT_Memory memory = parser->root.memory;
@ -332,7 +332,7 @@
/* and allocate private dictionary buffer */ /* and allocate private dictionary buffer */
if ( parser->private_len == 0 ) if ( parser->private_len == 0 )
{ {
FT_ERROR(( "Z1_Get_Private_Dict:" )); FT_ERROR(( "T1_Get_Private_Dict:" ));
FT_ERROR(( " invalid private dictionary section\n" )); FT_ERROR(( " invalid private dictionary section\n" ));
error = T1_Err_Invalid_File_Format; error = T1_Err_Invalid_File_Format;
goto Fail; goto Fail;
@ -393,7 +393,7 @@
cur++; cur++;
if ( cur >= limit ) if ( cur >= limit )
{ {
FT_ERROR(( "Z1_Get_Private_Dict:" )); FT_ERROR(( "T1_Get_Private_Dict:" ));
FT_ERROR(( " could not find `eexec' keyword\n" )); FT_ERROR(( " could not find `eexec' keyword\n" ));
error = T1_Err_Invalid_File_Format; error = T1_Err_Invalid_File_Format;
goto Exit; goto Exit;
@ -473,7 +473,7 @@
} }
/* we now decrypt the encoded binary private dictionary */ /* we now decrypt the encoded binary private dictionary */
Z1_Decrypt( parser->private_dict, parser->private_len, 55665 ); T1_Decrypt( parser->private_dict, parser->private_len, 55665 );
parser->root.base = parser->private_dict; parser->root.base = parser->private_dict;
parser->root.cursor = parser->private_dict; parser->root.cursor = parser->private_dict;
parser->root.limit = parser->root.cursor + parser->private_len; parser->root.limit = parser->root.cursor + parser->private_len;

52
src/type1/z1parse.h → src/type1/t1parse.h
View File

@ -1,8 +1,8 @@
/***************************************************************************/ /***************************************************************************/
/* */ /* */
/* z1parse.h */ /* t1parse.h */
/* */ /* */
/* Experimental Type 1 parser (specification). */ /* Type 1 parser (specification). */
/* */ /* */
/* Copyright 1996-2000 by */ /* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -16,8 +16,8 @@
/***************************************************************************/ /***************************************************************************/
#ifndef Z1PARSE_H #ifndef T1PARSE_H
#define Z1PARSE_H #define T1PARSE_H
#include <freetype/internal/t1types.h> #include <freetype/internal/t1types.h>
#include <freetype/internal/ftstream.h> #include <freetype/internal/ftstream.h>
@ -30,10 +30,10 @@
/*************************************************************************/ /*************************************************************************/
/* */ /* */
/* <Struct> */ /* <Struct> */
/* Z1_Parser */ /* T1_ParserRec */
/* */ /* */
/* <Description> */ /* <Description> */
/* A Z1_Parser is an object used to parse a Type 1 fonts very */ /* A T1_ParserRec is an object used to parse a Type 1 fonts very */
/* quickly. */ /* quickly. */
/* */ /* */
/* <Fields> */ /* <Fields> */
@ -57,7 +57,7 @@
/* single_block :: A boolean. Indicates that the private dictionary */ /* single_block :: A boolean. Indicates that the private dictionary */
/* is stored in lieu of the base dictionary. */ /* is stored in lieu of the base dictionary. */
/* */ /* */
typedef struct Z1_Parser_ typedef struct T1_ParserRec_
{ {
T1_Parser root; T1_Parser root;
FT_Stream stream; FT_Stream stream;
@ -72,17 +72,17 @@
FT_Byte in_memory; FT_Byte in_memory;
FT_Byte single_block; FT_Byte single_block;
} Z1_Parser; } T1_ParserRec;
#define Z1_Add_Table( p, i, o, l ) (p)->funcs.add( (p), i, o, l ) #define T1_Add_Table( p, i, o, l ) (p)->funcs.add( (p), i, o, l )
#define Z1_Done_Table( p ) \ #define T1_Done_Table( p ) \
do \ do \
{ \ { \
if ( (p)->funcs.done ) \ if ( (p)->funcs.done ) \
(p)->funcs.done( p ); \ (p)->funcs.done( p ); \
} while ( 0 ) } while ( 0 )
#define Z1_Release_Table( p ) \ #define T1_Release_Table( p ) \
do \ do \
{ \ { \
if ( (p)->funcs.release ) \ if ( (p)->funcs.release ) \
@ -90,43 +90,43 @@
} while ( 0 ) } while ( 0 )
#define Z1_Skip_Spaces( p ) (p)->root.funcs.skip_spaces( &(p)->root ) #define T1_Skip_Spaces( p ) (p)->root.funcs.skip_spaces( &(p)->root )
#define Z1_Skip_Alpha( p ) (p)->root.funcs.skip_alpha ( &(p)->root ) #define T1_Skip_Alpha( p ) (p)->root.funcs.skip_alpha ( &(p)->root )
#define Z1_ToInt( p ) (p)->root.funcs.to_int( &(p)->root ) #define T1_ToInt( p ) (p)->root.funcs.to_int( &(p)->root )
#define Z1_ToFixed( p, t ) (p)->root.funcs.to_fixed( &(p)->root, t ) #define T1_ToFixed( p, t ) (p)->root.funcs.to_fixed( &(p)->root, t )
#define Z1_ToCoordArray( p, m, c ) \ #define T1_ToCoordArray( p, m, c ) \
(p)->root.funcs.to_coord_array( &(p)->root, m, c ) (p)->root.funcs.to_coord_array( &(p)->root, m, c )
#define Z1_ToFixedArray( p, m, f, t ) \ #define T1_ToFixedArray( p, m, f, t ) \
(p)->root.funcs.to_fixed_array( &(p)->root, m, f, t ) (p)->root.funcs.to_fixed_array( &(p)->root, m, f, t )
#define Z1_ToToken( p, t ) \ #define T1_ToToken( p, t ) \
(p)->root.funcs.to_token( &(p)->root, t ) (p)->root.funcs.to_token( &(p)->root, t )
#define Z1_ToTokenArray( p, t, m, c ) \ #define T1_ToTokenArray( p, t, m, c ) \
(p)->root.funcs.to_token_array( &(p)->root, t, m, c ) (p)->root.funcs.to_token_array( &(p)->root, t, m, c )
#define Z1_Load_Field( p, f, o, m, pf ) \ #define T1_Load_Field( p, f, o, m, pf ) \
(p)->root.funcs.load_field( &(p)->root, f, o, m, pf ) (p)->root.funcs.load_field( &(p)->root, f, o, m, pf )
#define Z1_Load_Field_Table( p, f, o, m, pf ) \ #define T1_Load_Field_Table( p, f, o, m, pf ) \
(p)->root.funcs.load_field_table( &(p)->root, f, o, m, pf ) (p)->root.funcs.load_field_table( &(p)->root, f, o, m, pf )
LOCAL_DEF LOCAL_DEF
FT_Error Z1_New_Parser( Z1_Parser* parser, FT_Error T1_New_Parser( T1_ParserRec* parser,
FT_Stream stream, FT_Stream stream,
FT_Memory memory, FT_Memory memory,
PSAux_Interface* psaux ); PSAux_Interface* psaux );
LOCAL_DEF LOCAL_DEF
FT_Error Z1_Get_Private_Dict( Z1_Parser* parser ); FT_Error T1_Get_Private_Dict( T1_ParserRec* parser );
LOCAL_DEF LOCAL_DEF
void Z1_Decrypt( FT_Byte* buffer, void T1_Decrypt( FT_Byte* buffer,
FT_Int length, FT_Int length,
FT_UShort seed ); FT_UShort seed );
LOCAL_DEF LOCAL_DEF
void Z1_Done_Parser( Z1_Parser* parser ); void T1_Done_Parser( T1_ParserRec* parser );
#ifdef __cplusplus #ifdef __cplusplus
@ -134,7 +134,7 @@
#endif #endif
#endif /* Z1PARSE_H */ #endif /* T1PARSE_H */
/* END */ /* END */

4
src/type1/z1tokens.h → src/type1/t1tokens.h
View File

@ -1,8 +1,8 @@
/***************************************************************************/ /***************************************************************************/
/* */ /* */
/* z1tokens.h */ /* t1tokens.h */
/* */ /* */
/* Experimental Type 1 tokenizer (specification). */ /* Type 1 tokenizer (specification). */
/* */ /* */
/* Copyright 1996-2000 by */ /* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */

30
src/type1/type1.c
View File

@ -2,7 +2,7 @@
/* */ /* */
/* type1.c */ /* type1.c */
/* */ /* */
/* FreeType experimental Type 1 driver component (body only). */ /* FreeType Type 1 driver component (body only). */
/* */ /* */
/* Copyright 1996-2000 by */ /* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -21,26 +21,26 @@
#ifdef FT_FLAT_COMPILE #ifdef FT_FLAT_COMPILE
#include "z1parse.c" #include "t1parse.c"
#include "z1load.c" #include "t1load.c"
#include "z1objs.c" #include "t1objs.c"
#include "z1driver.c" #include "t1driver.c"
#include "z1gload.c" #include "t1gload.c"
#ifndef Z1_CONFIG_OPTION_NO_AFM #ifndef T1_CONFIG_OPTION_NO_AFM
#include "z1afm.c" #include "t1afm.c"
#endif #endif
#else /* FT_FLAT_COMPILE */ #else /* FT_FLAT_COMPILE */
#include <type1/z1parse.c> #include <type1/t1parse.c>
#include <type1/z1load.c> #include <type1/t1load.c>
#include <type1/z1objs.c> #include <type1/t1objs.c>
#include <type1/z1driver.c> #include <type1/t1driver.c>
#include <type1/z1gload.c> #include <type1/t1gload.c>
#ifndef Z1_CONFIG_OPTION_NO_AFM #ifndef T1_CONFIG_OPTION_NO_AFM
#include <type1/z1afm.c> #include <type1/t1afm.c>
#endif #endif
#endif /* FT_FLAT_COMPILE */ #endif /* FT_FLAT_COMPILE */