AuroraMiddleware/freetype
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

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

Browse Source 
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
- "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
allow us to re-use nearly un-modified in lots of other projects
(including FreeType Layout)
@ -13,10 +16,10 @@ LATEST CHANGES
- updated "docs/docmaker.py", a draft API reference is available at
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
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"
@ -354,7 +357,7 @@ OLD CHANGES FOR BETA 7
- 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
see any difference ;-)
see any difference ;-)
- removed TT_MAX_SUBGLYPHS, there is no static limit on the number of
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/smooth/smooth.c - the anti-aliasing raster module
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
Windows FNT format), is a single file.

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

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

2
src/base/ftmac.c
View File

@ -59,7 +59,7 @@
#include <freetype/freetype.h>
#include <freetype/internal/ftstream.h>
#include <truetype/ttobjs.h>
#include <type1z/z1objs.h>
#include <type1/t1objs.h>
#include <Resources.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)
#
T1_DRV_SRC := $(T1_DIR_)z1parse.c \
$(T1_DIR_)z1load.c \
$(T1_DIR_)z1driver.c \
$(T1_DIR_)z1afm.c \
$(T1_DIR_)z1gload.c \
$(T1_DIR_)z1objs.c
T1_DRV_SRC := $(T1_DIR_)t1parse.c \
$(T1_DIR_)t1load.c \
$(T1_DIR_)t1driver.c \
$(T1_DIR_)t1afm.c \
$(T1_DIR_)t1gload.c \
$(T1_DIR_)t1objs.c
# Type1 driver headers
#
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_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_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
# 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_COMPILE) $T$@ $(T1_DRV_SRC_S)
# Type1z driver - multiple objects
# Type1 driver - multiple objects
#
$(OBJ_)%.$O: $(T1_DIR_)%.c $(FREETYPE_H) $(T1_DRV_H)
$(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). */
/* */
@ -18,11 +18,11 @@
#ifdef FT_FLAT_COMPILE
#include "z1afm.h"
#include "t1afm.h"
#else
#include <type1/z1afm.h>
#include <type1/t1afm.h>
#endif
@ -42,12 +42,12 @@
/* messages during execution. */
/* */
#undef FT_COMPONENT
#define FT_COMPONENT trace_z1afm
#define FT_COMPONENT trace_t1afm
LOCAL_FUNC
void Z1_Done_AFM( FT_Memory memory,
Z1_AFM* afm )
void T1_Done_AFM( FT_Memory memory,
T1_AFM* afm )
{
FREE( afm->kern_pairs );
afm->num_pairs = 0;
@ -153,8 +153,8 @@
int compare_kern_pairs( const void* a,
const void* b )
{
Z1_Kern_Pair* pair1 = (Z1_Kern_Pair*)a;
Z1_Kern_Pair* pair2 = (Z1_Kern_Pair*)b;
T1_Kern_Pair* pair1 = (T1_Kern_Pair*)a;
T1_Kern_Pair* pair2 = (T1_Kern_Pair*)b;
FT_ULong index1 = KERN_INDEX( pair1->glyph1, pair1->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 */
LOCAL_FUNC
FT_Error Z1_Read_AFM( FT_Face t1_face,
FT_Error T1_Read_AFM( FT_Face t1_face,
FT_Stream stream )
{
FT_Error error;
@ -175,9 +175,9 @@
FT_Byte* limit;
FT_Byte* p;
FT_Int count = 0;
Z1_Kern_Pair* pair;
T1_Kern_Pair* pair;
T1_Font* type1 = &((T1_Face)t1_face)->type1;
Z1_AFM* afm = 0;
T1_AFM* afm = 0;
if ( ACCESS_Frame( stream->size ) )
@ -202,7 +202,7 @@
/* allocate the pairs */
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;
/* now, read each kern pair */
@ -237,7 +237,7 @@
}
/* 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 );
Exit:
@ -252,12 +252,12 @@
/* find the kerning for a given glyph pair */
LOCAL_FUNC
void Z1_Get_Kerning( Z1_AFM* afm,
void T1_Get_Kerning( T1_AFM* afm,
FT_UInt glyph1,
FT_UInt glyph2,
FT_Vector* kerning )
{
Z1_Kern_Pair *min, *mid, *max;
T1_Kern_Pair *min, *mid, *max;
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). */
/* */
@ -16,17 +16,17 @@
/***************************************************************************/
#ifndef Z1AFM_H
#define Z1AFM_H
#ifndef T1AFM_H
#define T1AFM_H
#ifdef FT_FLAT_COMPILE
#include "z1objs.h"
#include "t1objs.h"
#else
#include <type1/z1objs.h>
#include <type1/t1objs.h>
#endif
@ -36,33 +36,33 @@
#endif
typedef struct Z1_Kern_Pair_
typedef struct T1_Kern_Pair_
{
FT_UInt glyph1;
FT_UInt glyph2;
FT_Vector kerning;
} Z1_Kern_Pair;
} T1_Kern_Pair;
typedef struct Z1_AFM_
typedef struct T1_AFM_
{
FT_Int num_pairs;
Z1_Kern_Pair* kern_pairs;
T1_Kern_Pair* kern_pairs;
} Z1_AFM;
} T1_AFM;
LOCAL_DEF
FT_Error Z1_Read_AFM( FT_Face face,
FT_Error T1_Read_AFM( FT_Face face,
FT_Stream stream );
LOCAL_DEF
void Z1_Done_AFM( FT_Memory memory,
Z1_AFM* afm );
void T1_Done_AFM( FT_Memory memory,
T1_AFM* afm );
LOCAL_DEF
void Z1_Get_Kerning( Z1_AFM* afm,
void T1_Get_Kerning( T1_AFM* afm,
FT_UInt glyph1,
FT_UInt glyph2,
FT_Vector* kerning );
@ -73,7 +73,7 @@
#endif
#endif /* Z1AFM_H */
#endif /* T1AFM_H */
/* 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 */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -18,17 +18,17 @@
#ifdef FT_FLAT_COMPILE
#include "z1driver.h"
#include "z1gload.h"
#include "z1load.h"
#include "z1afm.h"
#include "t1driver.h"
#include "t1gload.h"
#include "t1load.h"
#include "t1afm.h"
#else
#include <type1/z1driver.h>
#include <type1/z1gload.h>
#include <type1/z1load.h>
#include <type1/z1afm.h>
#include <type1/t1driver.h>
#include <type1/t1gload.h>
#include <type1/t1load.h>
#include <type1/t1afm.h>
#endif
@ -47,11 +47,11 @@
/* messages during execution. */
/* */
#undef FT_COMPONENT
#define FT_COMPONENT trace_z1driver
#define FT_COMPONENT trace_t1driver
static
FT_Error get_z1_glyph_name( T1_Face face,
FT_Error get_t1_glyph_name( T1_Face face,
FT_UInt glyph_index,
FT_Pointer buffer,
FT_UInt buffer_max )
@ -112,23 +112,23 @@
FT_UNUSED( interface );
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 )
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 )
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 )
return (FT_Module_Interface)Z1_Set_MM_Blend;
return (FT_Module_Interface)T1_Set_MM_Blend;
#endif
return 0;
}
#ifndef Z1_CONFIG_OPTION_NO_AFM
#ifndef T1_CONFIG_OPTION_NO_AFM
/*************************************************************************/
/* */
@ -168,15 +168,15 @@
FT_UInt right_glyph,
FT_Vector* kerning )
{
Z1_AFM* afm;
T1_AFM* afm;
kerning->x = 0;
kerning->y = 0;
afm = (Z1_AFM*)face->afm_data;
afm = (T1_AFM*)face->afm_data;
if ( afm )
Z1_Get_Kerning( afm, left_glyph, right_glyph, kerning );
T1_Get_Kerning( afm, left_glyph, right_glyph, kerning );
return T1_Err_Ok;
}
@ -295,17 +295,17 @@
0, /* format interface */
(FT_Module_Constructor)Z1_Init_Driver,
(FT_Module_Destructor) Z1_Done_Driver,
(FT_Module_Constructor)T1_Init_Driver,
(FT_Module_Destructor) T1_Done_Driver,
(FT_Module_Requester) Get_Interface,
},
sizeof( T1_FaceRec ),
sizeof( Z1_SizeRec ),
sizeof( Z1_GlyphSlotRec ),
sizeof( T1_SizeRec ),
sizeof( T1_GlyphSlotRec ),
(FTDriver_initFace) Z1_Init_Face,
(FTDriver_doneFace) Z1_Done_Face,
(FTDriver_initFace) T1_Init_Face,
(FTDriver_doneFace) T1_Done_Face,
(FTDriver_initSize) 0,
(FTDriver_doneSize) 0,
(FTDriver_initGlyphSlot)0,
@ -313,15 +313,15 @@
(FTDriver_setCharSizes) 0,
(FTDriver_setPixelSizes)0,
(FTDriver_loadGlyph) Z1_Load_Glyph,
(FTDriver_loadGlyph) T1_Load_Glyph,
(FTDriver_getCharIndex) Get_Char_Index,
#ifdef Z1_CONFIG_OPTION_NO_AFM
#ifdef T1_CONFIG_OPTION_NO_AFM
(FTDriver_getKerning) 0,
(FTDriver_attachFile) 0,
#else
(FTDriver_getKerning) Get_Kerning,
(FTDriver_attachFile) Z1_Read_AFM,
(FTDriver_attachFile) T1_Read_AFM,
#endif
(FTDriver_getAdvances) 0
};
@ -331,7 +331,7 @@
EXPORT_FUNC( const FT_Driver_Class* ) getDriverClass( void )
{
return &t1z_driver_class;
return &t1_driver_class;
}
#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 */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -16,8 +16,8 @@
/***************************************************************************/
#ifndef Z1DRIVER_H
#define Z1DRIVER_H
#ifndef T1DRIVER_H
#define T1DRIVER_H
#include <freetype/internal/ftdriver.h>
@ -33,7 +33,7 @@
#endif
#endif /* Z1DRIVER_H */
#endif /* T1DRIVER_H */
/* 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 */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -18,11 +18,11 @@
#ifdef FT_FLAT_COMPILE
#include "z1gload.h"
#include "t1gload.h"
#else
#include <type1/z1gload.h>
#include <type1/t1gload.h>
#endif
@ -43,7 +43,7 @@
/* messages during execution. */
/* */
#undef FT_COMPONENT
#define FT_COMPONENT trace_z1gload
#define FT_COMPONENT trace_t1gload
/*************************************************************************/
@ -64,7 +64,7 @@
LOCAL_FUNC_X
FT_Error Z1_Parse_Glyph( T1_Decoder* decoder,
FT_Error T1_Parse_Glyph( T1_Decoder* decoder,
FT_UInt glyph_index )
{
T1_Face face = (T1_Face)decoder->builder.face;
@ -82,7 +82,7 @@
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_Error error;
@ -101,7 +101,7 @@
0, /* glyph slot */
(FT_Byte**)type1->glyph_names,
face->blend,
Z1_Parse_Glyph );
T1_Parse_Glyph );
if ( error )
return error;
@ -117,7 +117,7 @@
for ( glyph_index = 0; glyph_index < type1->num_glyphs; glyph_index++ )
{
/* 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 */
}
@ -144,8 +144,8 @@
LOCAL_FUNC
FT_Error Z1_Load_Glyph( Z1_GlyphSlot glyph,
Z1_Size size,
FT_Error T1_Load_Glyph( T1_GlyphSlot glyph,
T1_Size size,
FT_Int glyph_index,
FT_Int load_flags )
{
@ -180,7 +180,7 @@
(FT_GlyphSlot)glyph,
(FT_Byte**)type1->glyph_names,
face->blend,
Z1_Parse_Glyph );
T1_Parse_Glyph );
if ( error )
goto Exit;
@ -192,7 +192,7 @@
/* now load the unscaled outline */
error = Z1_Parse_Glyph( &decoder, glyph_index );
error = T1_Parse_Glyph( &decoder, glyph_index );
if ( error )
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 */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -16,17 +16,17 @@
/***************************************************************************/
#ifndef Z1GLOAD_H
#define Z1GLOAD_H
#ifndef T1GLOAD_H
#define T1GLOAD_H
#ifdef FT_FLAT_COMPILE
#include "z1objs.h"
#include "t1objs.h"
#else
#include <type1/z1objs.h>
#include <type1/t1objs.h>
#endif
@ -37,12 +37,12 @@
LOCAL_DEF
FT_Error Z1_Compute_Max_Advance( T1_Face face,
FT_Error T1_Compute_Max_Advance( T1_Face face,
FT_Int* max_advance );
LOCAL_DEF
FT_Error Z1_Load_Glyph( Z1_GlyphSlot glyph,
Z1_Size size,
FT_Error T1_Load_Glyph( T1_GlyphSlot glyph,
T1_Size size,
FT_Int glyph_index,
FT_Int load_flags );
@ -52,7 +52,7 @@
#endif
#endif /* Z1GLOAD_H */
#endif /* T1GLOAD_H */
/* 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 */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -71,11 +71,11 @@
#ifdef FT_FLAT_COMPILE
#include "z1load.h"
#include "t1load.h"
#else
#include <type1/z1load.h>
#include <type1/t1load.h>
#endif
@ -91,10 +91,10 @@
/* messages during execution. */
/* */
#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
FT_Error Z1_Get_Multi_Master( T1_Face face,
FT_Error T1_Get_Multi_Master( T1_Face face,
FT_Multi_Master* master )
{
T1_Blend* blend = face->blend;
@ -222,7 +222,7 @@
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_Fixed* coords )
{
@ -268,7 +268,7 @@
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_Long* coords )
{
@ -330,7 +330,7 @@
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;
@ -338,7 +338,7 @@
LOCAL_FUNC
void Z1_Done_Blend( T1_Face face )
void T1_Done_Blend( T1_Face face )
{
FT_Memory memory = face->root.memory;
T1_Blend* blend = face->blend;
@ -391,7 +391,7 @@
static
void parse_blend_axis_types( T1_Face face,
Z1_Loader* loader )
T1_Loader* loader )
{
T1_Token axis_tokens[ T1_MAX_MM_AXIS ];
FT_Int n, num_axis;
@ -401,7 +401,7 @@
/* take an array of objects */
Z1_ToTokenArray( &loader->parser, axis_tokens,
T1_ToTokenArray( &loader->parser, axis_tokens,
T1_MAX_MM_AXIS, &num_axis );
if ( num_axis <= 0 || num_axis > T1_MAX_MM_AXIS )
{
@ -452,19 +452,19 @@
static
void parse_blend_design_positions( T1_Face face,
Z1_Loader* loader )
T1_Loader* loader )
{
T1_Token design_tokens[ T1_MAX_MM_DESIGNS ];
FT_Int num_designs;
FT_Int num_axis;
Z1_Parser* parser = &loader->parser;
T1_Token design_tokens[ T1_MAX_MM_DESIGNS ];
FT_Int num_designs;
FT_Int num_axis;
T1_ParserRec* parser = &loader->parser;
FT_Error error = 0;
T1_Blend* blend;
FT_Error error = 0;
T1_Blend* blend;
/* 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 )
{
FT_ERROR(( "parse_blend_design_positions:" ));
@ -494,7 +494,7 @@
token = design_tokens + n;
parser->root.cursor = token->start - 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 )
{
@ -519,7 +519,7 @@
parser->root.cursor = token2->start;
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
void parse_blend_design_map( T1_Face face,
Z1_Loader* loader )
T1_Loader* loader )
{
FT_Error error = 0;
Z1_Parser* parser = &loader->parser;
T1_Blend* blend;
T1_Token axis_tokens[ T1_MAX_MM_AXIS ];
FT_Int n, num_axis;
FT_Byte* old_cursor;
FT_Byte* old_limit;
FT_Memory memory = face->root.memory;
FT_Error error = 0;
T1_ParserRec* parser = &loader->parser;
T1_Blend* blend;
T1_Token axis_tokens[ T1_MAX_MM_AXIS ];
FT_Int n, num_axis;
FT_Byte* old_cursor;
FT_Byte* old_limit;
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 )
{
FT_ERROR(( "parse_blend_design_map: incorrect number of axes: %d\n",
@ -600,8 +600,8 @@
for ( p = 0; p < num_points; p++ )
{
map->design_points[p] = Z1_ToInt( parser );
map->blend_points [p] = Z1_ToFixed( parser, 0 );
map->design_points[p] = T1_ToInt( parser );
map->blend_points [p] = T1_ToFixed( parser, 0 );
}
}
@ -615,15 +615,15 @@
static
void parse_weight_vector( T1_Face face,
Z1_Loader* loader )
T1_Loader* loader )
{
FT_Error error = 0;
Z1_Parser* parser = &loader->parser;
T1_Blend* blend = face->blend;
T1_Token master;
FT_UInt n;
FT_Byte* old_cursor;
FT_Byte* old_limit;
FT_Error error = 0;
T1_ParserRec* parser = &loader->parser;
T1_Blend* blend = face->blend;
T1_Token master;
FT_UInt n;
FT_Byte* old_cursor;
FT_Byte* old_limit;
if ( !blend || blend->num_designs == 0 )
@ -633,7 +633,7 @@
goto Exit;
}
Z1_ToToken( parser, &master );
T1_ToToken( parser, &master );
if ( master.type != t1_token_array )
{
FT_ERROR(( "parse_weight_vector: incorrect format!\n" ));
@ -650,7 +650,7 @@
for ( n = 0; n < blend->num_designs; 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;
@ -667,9 +667,9 @@
/* */
static
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 );
@ -678,7 +678,7 @@
parser->root.error = 0;
}
#endif /* Z1_CONFIG_OPTION_NO_MM_SUPPORT */
#endif /* T1_CONFIG_OPTION_NO_MM_SUPPORT */
/*************************************************************************/
@ -700,7 +700,7 @@
static
FT_Error t1_load_keyword( T1_Face face,
Z1_Loader* loader,
T1_Loader* loader,
T1_Field* field )
{
FT_Error error;
@ -754,10 +754,10 @@
if ( field->type == t1_field_integer_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 );
else
error = Z1_Load_Field( &loader->parser, field,
error = T1_Load_Field( &loader->parser, field,
objects, max_objects, 0 );
Exit:
@ -781,9 +781,9 @@
static
int read_binary_data( Z1_Parser* parser,
FT_Int* size,
FT_Byte** base )
int read_binary_data( T1_ParserRec* parser,
FT_Int* size,
FT_Byte** base )
{
FT_Byte* cur;
FT_Byte* limit = parser->root.limit;
@ -794,15 +794,15 @@
/* `size' [white*] RD white ....... ND */
/* */
Z1_Skip_Spaces( parser );
T1_Skip_Spaces( parser );
cur = parser->root.cursor;
if ( cur < limit && (FT_Byte)( *cur - '0' ) < 10 )
{
*size = Z1_ToInt( parser );
*size = T1_ToInt( parser );
Z1_Skip_Spaces( parser );
Z1_Skip_Alpha ( parser ); /* `RD' or `-|' or something else */
T1_Skip_Spaces( parser );
T1_Skip_Alpha ( parser ); /* `RD' or `-|' or something else */
/* there is only one whitespace char after the */
/* `RD' or `-|' token */
@ -824,18 +824,18 @@
static
void parse_font_name( T1_Face face,
Z1_Loader* loader )
T1_Loader* loader )
{
Z1_Parser* parser = &loader->parser;
FT_Error error;
FT_Memory memory = parser->root.memory;
FT_Int len;
FT_Byte* cur;
FT_Byte* cur2;
FT_Byte* limit;
T1_ParserRec* parser = &loader->parser;
FT_Error error;
FT_Memory memory = parser->root.memory;
FT_Int len;
FT_Byte* cur;
FT_Byte* cur2;
FT_Byte* limit;
Z1_Skip_Spaces( parser );
T1_Skip_Spaces( parser );
cur = parser->root.cursor;
limit = parser->root.limit;
@ -866,14 +866,14 @@
static
void parse_font_bbox( T1_Face face,
Z1_Loader* loader )
T1_Loader* loader )
{
Z1_Parser* parser = &loader->parser;
FT_Short temp[4];
FT_BBox* bbox = &face->type1.font_bbox;
T1_ParserRec* parser = &loader->parser;
FT_Short temp[4];
FT_BBox* bbox = &face->type1.font_bbox;
(void)Z1_ToCoordArray( parser, 4, temp );
(void)T1_ToCoordArray( parser, 4, temp );
bbox->xMin = temp[0];
bbox->yMin = temp[1];
bbox->xMax = temp[2];
@ -883,19 +883,19 @@
static
void parse_font_matrix( T1_Face face,
Z1_Loader* loader )
T1_Loader* loader )
{
Z1_Parser* parser = &loader->parser;
FT_Matrix* matrix = &face->type1.font_matrix;
FT_Vector* offset = &face->type1.font_offset;
FT_Fixed temp[6];
T1_ParserRec* parser = &loader->parser;
FT_Matrix* matrix = &face->type1.font_matrix;
FT_Vector* offset = &face->type1.font_offset;
FT_Fixed temp[6];
if ( matrix->xx || matrix->yx )
/* with synthetic fonts, it's possible we get here twice */
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] */
if ( temp[3] != 0x10000L )
@ -921,11 +921,11 @@
static
void parse_encoding( T1_Face face,
Z1_Loader* loader )
T1_Loader* loader )
{
Z1_Parser* parser = &loader->parser;
FT_Byte* cur = parser->root.cursor;
FT_Byte* limit = parser->root.limit;
T1_ParserRec* parser = &loader->parser;
FT_Byte* cur = parser->root.cursor;
FT_Byte* limit = parser->root.limit;
PSAux_Interface* psaux = (PSAux_Interface*)face->psaux;
@ -954,11 +954,11 @@
/* read the number of entries in the encoding, should be 256 */
count = Z1_ToInt( parser );
count = T1_ToInt( parser );
if ( parser->root.error )
return;
/* we use a Z1_Table to store our charnames */
/* we use a T1_Table to store our charnames */
encode->num_chars = count;
if ( ALLOC_ARRAY( encode->char_index, count, FT_Short ) ||
ALLOC_ARRAY( encode->char_name, count, FT_String* ) ||
@ -975,7 +975,7 @@
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 */
@ -1022,7 +1022,7 @@
parser->root.cursor = cur;
charcode = Z1_ToInt( parser );
charcode = T1_ToInt( parser );
cur = parser->root.cursor;
/* skip whitespace */
@ -1042,7 +1042,7 @@
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 );
char_table->elements[charcode][len] = '\0';
if ( parser->root.error )
@ -1081,25 +1081,25 @@
static
void parse_subrs( T1_Face face,
Z1_Loader* loader )
T1_Loader* loader )
{
Z1_Parser* parser = &loader->parser;
PS_Table* table = &loader->subrs;
FT_Memory memory = parser->root.memory;
FT_Error error;
FT_Int n;
T1_ParserRec* parser = &loader->parser;
PS_Table* table = &loader->subrs;
FT_Memory memory = parser->root.memory;
FT_Error error;
FT_Int n;
PSAux_Interface* psaux = (PSAux_Interface*)face->psaux;
loader->num_subrs = Z1_ToInt( parser );
loader->num_subrs = T1_ToInt( parser );
if ( parser->root.error )
return;
/* position the parser right before the `dup' of the first subr */
Z1_Skip_Spaces( parser );
Z1_Skip_Alpha( parser ); /* `array' */
Z1_Skip_Spaces( parser );
T1_Skip_Spaces( parser );
T1_Skip_Alpha( parser ); /* `array' */
T1_Skip_Spaces( parser );
/* initialize subrs array */
error = psaux->ps_table_funcs->init( table, loader->num_subrs, memory );
@ -1122,7 +1122,7 @@
if ( strncmp( (char*)parser->root.cursor, "dup", 3 ) != 0 )
break;
index = Z1_ToInt( parser );
index = T1_ToInt( parser );
if ( !read_binary_data( parser, &size, &base ) )
return;
@ -1131,14 +1131,14 @@
/* (bound to `noaccess put') or by two separate tokens: */
/* `noaccess' & `put'. We position the parser right */
/* before the next `dup', if any. */
Z1_Skip_Spaces( parser );
Z1_Skip_Alpha( parser ); /* `NP' or `I' or `noaccess' */
Z1_Skip_Spaces( parser );
T1_Skip_Spaces( parser );
T1_Skip_Alpha( parser ); /* `NP' or `I' or `noaccess' */
T1_Skip_Spaces( parser );
if ( strncmp( (char*)parser->root.cursor, "put", 3 ) == 0 )
{
Z1_Skip_Alpha( parser ); /* skip `put' */
Z1_Skip_Spaces( parser );
T1_Skip_Alpha( parser ); /* skip `put' */
T1_Skip_Spaces( parser );
}
/* some fonts use a value of -1 for lenIV to indicate that */
@ -1148,12 +1148,12 @@
/* */
if ( face->type1.private_dict.lenIV >= 0 )
{
Z1_Decrypt( base, size, 4330 );
T1_Decrypt( base, size, 4330 );
size -= 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 )
goto Fail;
}
@ -1166,13 +1166,13 @@
static
void parse_charstrings( T1_Face face,
Z1_Loader* loader )
T1_Loader* loader )
{
Z1_Parser* parser = &loader->parser;
PS_Table* code_table = &loader->charstrings;
PS_Table* name_table = &loader->glyph_names;
FT_Memory memory = parser->root.memory;
FT_Error error;
T1_ParserRec* parser = &loader->parser;
PS_Table* code_table = &loader->charstrings;
PS_Table* name_table = &loader->glyph_names;
FT_Memory memory = parser->root.memory;
FT_Error error;
PSAux_Interface* psaux = (PSAux_Interface*)face->psaux;
@ -1187,7 +1187,7 @@
/* with synthetic fonts, it's possible we get here twice */
return;
loader->num_glyphs = Z1_ToInt( parser );
loader->num_glyphs = T1_ToInt( parser );
if ( parser->root.error )
return;
@ -1216,7 +1216,7 @@
/* */
/* note that we stop when we find a `def' */
/* */
Z1_Skip_Spaces( parser );
T1_Skip_Spaces( parser );
cur = parser->root.cursor;
if ( cur >= limit )
@ -1236,7 +1236,7 @@
break;
if ( *cur != '/' )
Z1_Skip_Alpha( parser );
T1_Skip_Alpha( parser );
else
{
FT_Byte* cur2 = cur + 1;
@ -1247,7 +1247,7 @@
cur2++;
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 )
goto Fail;
@ -1268,12 +1268,12 @@
if ( face->type1.private_dict.lenIV >= 0 )
{
Z1_Decrypt( base, size, 4330 );
T1_Decrypt( base, size, 4330 );
size -= 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 )
goto Fail;
@ -1296,36 +1296,36 @@
/* index 0. Then take end of table name/code and place it into index */
/* notdef_index. */
error = Z1_Add_Table( name_table, n,
error = T1_Add_Table( name_table, n,
name_table->elements[0],
name_table->lengths [0] );
if ( error )
goto Fail;
error = Z1_Add_Table( code_table, n,
error = T1_Add_Table( code_table, n,
code_table->elements[0],
code_table->lengths [0] );
if ( error )
goto Fail;
error = Z1_Add_Table( name_table, 0,
error = T1_Add_Table( name_table, 0,
name_table->elements[notdef_index],
name_table->lengths [notdef_index] );
if ( error )
goto Fail;
error = Z1_Add_Table( code_table, 0,
error = T1_Add_Table( code_table, 0,
code_table->elements[notdef_index],
code_table->lengths [notdef_index] );
if ( error )
goto Fail;
error = Z1_Add_Table( name_table, notdef_index,
error = T1_Add_Table( name_table, notdef_index,
name_table->elements[n],
name_table->lengths [n] );
if ( error )
goto Fail;
error = Z1_Add_Table( code_table, notdef_index,
error = T1_Add_Table( code_table, notdef_index,
code_table->elements[n],
code_table->lengths [n] );
if ( error )
@ -1345,23 +1345,23 @@
char* notdef_name = ".notdef";
error = Z1_Add_Table( name_table, n,
error = T1_Add_Table( name_table, n,
name_table->elements[0],
name_table->lengths [0] );
if ( error )
goto Fail;
error = Z1_Add_Table( code_table, n,
error = T1_Add_Table( code_table, n,
code_table->elements[0],
code_table->lengths [0] );
if ( error )
goto Fail;
error = Z1_Add_Table( name_table, 0, notdef_name, 8 );
error = T1_Add_Table( name_table, 0, notdef_name, 8 );
if ( error )
goto Fail;
error = Z1_Add_Table( code_table, 0, notdef_glyph, 5 );
error = T1_Add_Table( code_table, 0, notdef_glyph, 5 );
if ( error )
goto Fail;
@ -1384,11 +1384,11 @@
#ifdef FT_FLAT_COMPILE
#include "z1tokens.h"
#include "t1tokens.h"
#else
#include <type1/z1tokens.h>
#include <type1/t1tokens.h>
#endif
@ -1400,7 +1400,7 @@
T1_FIELD_CALLBACK( "Subrs", parse_subrs )
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( "BlendDesignMap", parse_blend_design_map )
T1_FIELD_CALLBACK( "BlendAxisTypes", parse_blend_axis_types )
@ -1414,11 +1414,11 @@
static
FT_Error parse_dict( T1_Face face,
Z1_Loader* loader,
T1_Loader* loader,
FT_Byte* base,
FT_Long size )
{
Z1_Parser* parser = &loader->parser;
T1_ParserRec* parser = &loader->parser;
parser->root.cursor = base;
@ -1456,7 +1456,7 @@
/* skip the `known' keyword and the token following it */
cur += 5;
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 ( token.type == t1_token_array )
@ -1513,7 +1513,7 @@
{
/* we found it -- run the parsing callback! */
parser->root.cursor = cur2;
Z1_Skip_Spaces( parser );
T1_Skip_Spaces( parser );
parser->root.error = t1_load_keyword( face,
loader,
keyword );
@ -1536,7 +1536,7 @@
static
void t1_init_loader( Z1_Loader* loader,
void t1_init_loader( T1_Loader* loader,
T1_Face face )
{
FT_UNUSED( face );
@ -1555,29 +1555,29 @@
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 */
Z1_Release_Table( &loader->encoding_table );
Z1_Release_Table( &loader->charstrings );
Z1_Release_Table( &loader->glyph_names );
Z1_Release_Table( &loader->subrs );
T1_Release_Table( &loader->encoding_table );
T1_Release_Table( &loader->charstrings );
T1_Release_Table( &loader->glyph_names );
T1_Release_Table( &loader->subrs );
/* finalize parser */
Z1_Done_Parser( parser );
T1_Done_Parser( parser );
}
LOCAL_FUNC
FT_Error Z1_Open_Face( T1_Face face )
FT_Error T1_Open_Face( T1_Face face )
{
Z1_Loader loader;
Z1_Parser* parser;
T1_Font* type1 = &face->type1;
FT_Error error;
T1_Loader loader;
T1_ParserRec* parser;
T1_Font* type1 = &face->type1;
FT_Error error;
PSAux_Interface* psaux = (PSAux_Interface*)face->psaux;
@ -1588,7 +1588,7 @@
type1->private_dict.lenIV = 4;
parser = &loader.parser;
error = Z1_New_Parser( parser,
error = T1_New_Parser( parser,
face->root.stream,
face->root.memory,
psaux );
@ -1599,7 +1599,7 @@
if ( error )
goto Exit;
error = Z1_Get_Private_Dict( parser );
error = T1_Get_Private_Dict( parser );
if ( error )
goto Exit;
@ -1614,13 +1614,13 @@
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;
}
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;
}

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 */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -16,8 +16,8 @@
/***************************************************************************/
#ifndef Z1LOAD_H
#define Z1LOAD_H
#ifndef T1LOAD_H
#define T1LOAD_H
#include <freetype/internal/ftstream.h>
#include <freetype/internal/psaux.h>
@ -26,11 +26,11 @@
#ifdef FT_FLAT_COMPILE
#include "z1parse.h"
#include "t1parse.h"
#else
#include <type1/z1parse.h>
#include <type1/t1parse.h>
#endif
@ -39,55 +39,55 @@
extern "C" {
#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 */
PS_Table encoding_table; /* PS_Table used to store the */
/* encoding character names */
FT_Int num_chars; /* number of characters in encoding */
PS_Table encoding_table; /* PS_Table used to store the */
/* encoding character names */
FT_Int num_glyphs;
PS_Table glyph_names;
PS_Table charstrings;
FT_Int num_glyphs;
PS_Table glyph_names;
PS_Table charstrings;
FT_Int num_subrs;
PS_Table subrs;
FT_Bool fontdata;
FT_Int num_subrs;
PS_Table subrs;
FT_Bool fontdata;
} Z1_Loader;
} T1_Loader;
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
FT_Error Z1_Get_Multi_Master( T1_Face face,
FT_Error T1_Get_Multi_Master( T1_Face face,
FT_Multi_Master* master );
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_Fixed* coords );
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_Long* coords );
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
}
#endif
#endif /* Z1LOAD_H */
#endif /* T1LOAD_H */
/* 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 */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -22,15 +22,15 @@
#ifdef FT_FLAT_COMPILE
#include "z1gload.h"
#include "z1load.h"
#include "z1afm.h"
#include "t1gload.h"
#include "t1load.h"
#include "t1afm.h"
#else
#include <type1/z1gload.h>
#include <type1/z1load.h>
#include <type1/z1afm.h>
#include <type1/t1gload.h>
#include <type1/t1load.h>
#include <type1/t1afm.h>
#endif
@ -46,7 +46,7 @@
/* messages during execution. */
/* */
#undef FT_COMPONENT
#define FT_COMPONENT trace_z1objs
#define FT_COMPONENT trace_t1objs
/*************************************************************************/
@ -59,7 +59,7 @@
/*************************************************************************/
/* */
/* <Function> */
/* Z1_Done_Face */
/* T1_Done_Face */
/* */
/* <Description> */
/* The face object destructor. */
@ -68,7 +68,7 @@
/* face :: A typeless pointer to the face object to destroy. */
/* */
LOCAL_FUNC
void Z1_Done_Face( T1_Face face )
void T1_Done_Face( T1_Face face )
{
FT_Memory memory;
T1_Font* type1 = &face->type1;
@ -78,9 +78,9 @@
{
memory = face->root.memory;
#ifndef Z1_CONFIG_OPTION_NO_MM_SUPPORT
#ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT
/* release multiple masters information */
Z1_Done_Blend( face );
T1_Done_Blend( face );
face->blend = 0;
#endif
@ -111,10 +111,10 @@
FREE( type1->encoding.char_index );
FREE( type1->font_name );
#ifndef Z1_CONFIG_OPTION_NO_AFM
#ifndef T1_CONFIG_OPTION_NO_AFM
/* release afm data if present */
if ( face->afm_data )
Z1_Done_AFM( memory, (Z1_AFM*)face->afm_data );
T1_Done_AFM( memory, (T1_AFM*)face->afm_data );
#endif
/* release unicode map, if any */
@ -130,7 +130,7 @@
/*************************************************************************/
/* */
/* <Function> */
/* Z1_Init_Face */
/* T1_Init_Face */
/* */
/* <Description> */
/* The face object constructor. */
@ -151,7 +151,7 @@
/* FreeType error code. 0 means success. */
/* */
LOCAL_FUNC
FT_Error Z1_Init_Face( FT_Stream stream,
FT_Error T1_Init_Face( FT_Stream stream,
T1_Face face,
FT_Int face_index,
FT_Int num_params,
@ -188,7 +188,7 @@
}
/* open the tokenizer, this will also check the font format */
error = Z1_Open_Face( face );
error = T1_Open_Face( face );
if ( error )
goto Exit;
@ -199,7 +199,7 @@
/* check the face index */
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;
goto Exit;
}
@ -278,7 +278,7 @@
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 */
if ( !error )
@ -365,7 +365,7 @@
/*************************************************************************/
/* */
/* <Function> */
/* Z1_Init_Driver */
/* T1_Init_Driver */
/* */
/* <Description> */
/* Initializes a given Type 1 driver object. */
@ -377,7 +377,7 @@
/* FreeType error code. 0 means success. */
/* */
LOCAL_FUNC
FT_Error Z1_Init_Driver( Z1_Driver driver )
FT_Error T1_Init_Driver( T1_Driver driver )
{
FT_UNUSED( driver );
@ -388,7 +388,7 @@
/*************************************************************************/
/* */
/* <Function> */
/* Z1_Done_Driver */
/* T1_Done_Driver */
/* */
/* <Description> */
/* Finalizes a given Type 1 driver. */
@ -397,7 +397,7 @@
/* driver :: A handle to the target Type 1 driver. */
/* */
LOCAL_DEF
void Z1_Done_Driver( Z1_Driver driver )
void T1_Done_Driver( T1_Driver 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 */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -16,8 +16,8 @@
/***************************************************************************/
#ifndef Z1OBJS_H
#define Z1OBJS_H
#ifndef T1OBJS_H
#define T1OBJS_H
#include <freetype/internal/ftobjs.h>
#include <freetype/config/ftconfig.h>
@ -29,47 +29,47 @@
#endif
/* The following structures must be defined by the hinter */
typedef struct Z1_Size_Hints_ Z1_Size_Hints;
typedef struct Z1_Glyph_Hints_ Z1_Glyph_Hints;
typedef struct T1_Size_Hints_ T1_Size_Hints;
typedef struct T1_Glyph_Hints_ T1_Glyph_Hints;
/*************************************************************************/
/* */
/* <Type> */
/* Z1_Driver */
/* T1_Driver */
/* */
/* <Description> */
/* A handle to a Type 1 driver object. */
/* */
typedef struct Z1_DriverRec_ *Z1_Driver;
typedef struct T1_DriverRec_ *T1_Driver;
/*************************************************************************/
/* */
/* <Type> */
/* Z1_Size */
/* T1_Size */
/* */
/* <Description> */
/* A handle to a Type 1 size object. */
/* */
typedef struct Z1_SizeRec_* Z1_Size;
typedef struct T1_SizeRec_* T1_Size;
/*************************************************************************/
/* */
/* <Type> */
/* Z1_GlyphSlot */
/* T1_GlyphSlot */
/* */
/* <Description> */
/* A handle to a Type 1 glyph slot object. */
/* */
typedef struct Z1_GlyphSlotRec_* Z1_GlyphSlot;
typedef struct T1_GlyphSlotRec_* T1_GlyphSlot;
/*************************************************************************/
/* */
/* <Type> */
/* Z1_CharMap */
/* T1_CharMap */
/* */
/* <Description> */
/* A handle to a Type 1 character mapping object. */
@ -79,7 +79,7 @@
/* The driver is responsible for making up charmap objects */
/* corresponding to these tables. */
/* */
typedef struct Z1_CharMapRec_* Z1_CharMap;
typedef struct T1_CharMapRec_* T1_CharMap;
/*************************************************************************/
@ -92,31 +92,31 @@
/*************************************************************************/
/* */
/* <Type> */
/* Z1_SizeRec */
/* T1_SizeRec */
/* */
/* <Description> */
/* Type 1 size record. */
/* */
typedef struct Z1_SizeRec_
typedef struct T1_SizeRec_
{
FT_SizeRec root;
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 */
/* hinting schemes without having to */
/* change `z1objs' each time. */
} Z1_SizeRec;
/* change `t1objs' each time. */
} T1_SizeRec;
/*************************************************************************/
/* */
/* <Type> */
/* Z1_GlyphSlotRec */
/* T1_GlyphSlotRec */
/* */
/* <Description> */
/* Type 1 glyph slot record. */
/* */
typedef struct Z1_GlyphSlotRec_
typedef struct T1_GlyphSlotRec_
{
FT_GlyphSlotRec root;
@ -129,33 +129,33 @@
FT_Fixed x_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
FT_Error Z1_Init_Face( FT_Stream stream,
FT_Error T1_Init_Face( FT_Stream stream,
T1_Face face,
FT_Int face_index,
FT_Int num_params,
FT_Parameter* params );
LOCAL_DEF
void Z1_Done_Face( T1_Face face );
void T1_Done_Face( T1_Face face );
LOCAL_DEF
FT_Error Z1_Init_Driver( Z1_Driver driver );
FT_Error T1_Init_Driver( T1_Driver driver );
LOCAL_DEF
void Z1_Done_Driver( Z1_Driver driver );
void T1_Done_Driver( T1_Driver driver );
#ifdef __cplusplus
}
#endif
#endif /* Z1OBJS_H */
#endif /* T1OBJS_H */
/* 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 */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -21,14 +21,14 @@
/* The Type 1 parser is in charge of the following: */
/* */
/* - 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 */
/* dictionaries. */
/* */
/* - 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
#include "z1parse.h"
#include "t1parse.h"
#else
#include <type1/z1parse.h>
#include <type1/t1parse.h>
#endif
@ -61,7 +61,7 @@
/* messages during execution. */
/* */
#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_Z1_LINESPACE( c ) ( (c) == '\r' || (c) == '\n' )
#define IS_T1_WHITESPACE( c ) ( (c) == ' ' || (c) == '\t' )
#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_
@ -127,7 +127,7 @@
LOCAL_FUNC
FT_Error Z1_New_Parser( Z1_Parser* parser,
FT_Error T1_New_Parser( T1_ParserRec* parser,
FT_Stream stream,
FT_Memory memory,
PSAux_Interface* psaux )
@ -236,7 +236,7 @@
LOCAL_FUNC
void Z1_Done_Parser( Z1_Parser* parser )
void T1_Done_Parser( T1_ParserRec* parser )
{
FT_Memory memory = parser->root.memory;
@ -276,7 +276,7 @@
LOCAL_FUNC
void Z1_Decrypt( FT_Byte* buffer,
void T1_Decrypt( FT_Byte* buffer,
FT_Int length,
FT_UShort seed )
{
@ -294,7 +294,7 @@
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_Memory memory = parser->root.memory;
@ -332,7 +332,7 @@
/* and allocate private dictionary buffer */
if ( parser->private_len == 0 )
{
FT_ERROR(( "Z1_Get_Private_Dict:" ));
FT_ERROR(( "T1_Get_Private_Dict:" ));
FT_ERROR(( " invalid private dictionary section\n" ));
error = T1_Err_Invalid_File_Format;
goto Fail;
@ -393,7 +393,7 @@
cur++;
if ( cur >= limit )
{
FT_ERROR(( "Z1_Get_Private_Dict:" ));
FT_ERROR(( "T1_Get_Private_Dict:" ));
FT_ERROR(( " could not find `eexec' keyword\n" ));
error = T1_Err_Invalid_File_Format;
goto Exit;
@ -473,7 +473,7 @@
}
/* 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.cursor = parser->private_dict;
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 */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
@ -16,8 +16,8 @@
/***************************************************************************/
#ifndef Z1PARSE_H
#define Z1PARSE_H
#ifndef T1PARSE_H
#define T1PARSE_H
#include <freetype/internal/t1types.h>
#include <freetype/internal/ftstream.h>
@ -30,10 +30,10 @@
/*************************************************************************/
/* */
/* <Struct> */
/* Z1_Parser */
/* T1_ParserRec */
/* */
/* <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. */
/* */
/* <Fields> */
@ -57,7 +57,7 @@
/* single_block :: A boolean. Indicates that the private dictionary */
/* is stored in lieu of the base dictionary. */
/* */
typedef struct Z1_Parser_
typedef struct T1_ParserRec_
{
T1_Parser root;
FT_Stream stream;
@ -72,17 +72,17 @@
FT_Byte in_memory;
FT_Byte single_block;
} Z1_Parser;
} T1_ParserRec;
#define Z1_Add_Table( p, i, o, l ) (p)->funcs.add( (p), i, o, l )
#define Z1_Done_Table( p ) \
#define T1_Add_Table( p, i, o, l ) (p)->funcs.add( (p), i, o, l )
#define T1_Done_Table( p ) \
do \
{ \
if ( (p)->funcs.done ) \
(p)->funcs.done( p ); \
} while ( 0 )
#define Z1_Release_Table( p ) \
#define T1_Release_Table( p ) \
do \
{ \
if ( (p)->funcs.release ) \
@ -90,43 +90,43 @@
} while ( 0 )
#define Z1_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_Spaces( p ) (p)->root.funcs.skip_spaces( &(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 Z1_ToFixed( p, t ) (p)->root.funcs.to_fixed( &(p)->root, t )
#define T1_ToInt( p ) (p)->root.funcs.to_int( &(p)->root )
#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 )
#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 )
#define Z1_ToToken( p, t ) \
#define T1_ToToken( p, 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 )
#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 )
#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 )
LOCAL_DEF
FT_Error Z1_New_Parser( Z1_Parser* parser,
FT_Error T1_New_Parser( T1_ParserRec* parser,
FT_Stream stream,
FT_Memory memory,
PSAux_Interface* psaux );
LOCAL_DEF
FT_Error Z1_Get_Private_Dict( Z1_Parser* parser );
FT_Error T1_Get_Private_Dict( T1_ParserRec* parser );
LOCAL_DEF
void Z1_Decrypt( FT_Byte* buffer,
void T1_Decrypt( FT_Byte* buffer,
FT_Int length,
FT_UShort seed );
LOCAL_DEF
void Z1_Done_Parser( Z1_Parser* parser );
void T1_Done_Parser( T1_ParserRec* parser );
#ifdef __cplusplus
@ -134,7 +134,7 @@
#endif
#endif /* Z1PARSE_H */
#endif /* T1PARSE_H */
/* 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 */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */

30
src/type1/type1.c
View File

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