From aa4c28f9fe5debca5822217eb3cf8dcebe7dd6a7 Mon Sep 17 00:00:00 2001 From: David Turner Date: Thu, 22 Jun 2000 00:27:15 +0000 Subject: [PATCH] added new files --- src/psnames/psmodule.c | 252 +++++++++++++++++++++++++++++++++++++++++ src/psnames/psmodule.h | 29 +++++ 2 files changed, 281 insertions(+) create mode 100644 src/psnames/psmodule.c create mode 100644 src/psnames/psmodule.h diff --git a/src/psnames/psmodule.c b/src/psnames/psmodule.c new file mode 100644 index 000000000..e00f9ac9e --- /dev/null +++ b/src/psnames/psmodule.c @@ -0,0 +1,252 @@ +#include +#include +#include +#include + +#ifndef FT_CONFIG_OPTION_NO_POSTSCRIPT_NAMES + +/* see the python script "freetype2/docs/glnames.py" which is used */ +/* to generate the following tables... */ +#include + +#ifdef FT_CONFIG_OPTION_ADOBE_GLYPH_LIST + /* return the Unicode value corresponding to a given glyph. Note that */ + /* we do deal with glyph variants by detecting a non-initial dot */ + /* in the name, as in "A.swash" or "e.final", etc.. */ + /* */ + static + FT_ULong PS_Unicode_Value( const char* glyph_name ) + { + FT_Int n; + char first = glyph_name[0]; + char temp[64]; + + /* if the name begins with "uni", then the glyph name may be a */ + /* hard-coded unicode character code.. */ + if ( glyph_name[0] == 'u' && + glyph_name[1] == 'n' && + glyph_name[2] == 'i' ) + { + /* determine wether the following characters are hexadecimal */ + FT_Int count; + FT_ULong value = 0; + const char* p = glyph_name + 4; + + for ( count = 4;count > 0; count--, p++ ) + { + char c = *p; + unsigned char d; + + d = (unsigned char)c-'0'; + if (d >= 10) + { + d = (unsigned char)c - 'A'; + if ( d >= 6 ) + d = 16; + else + d += 10; + } + /* exit if one non-uppercase-hexadecimal character was found */ + if (d >= 16) + break; + + value = (value << 4) + d; + if (count == 0) + return value; + } + } + + /* look for a non-initial dot in the glyph name in order to */ + /* sort-out variants like "A.swash", "e.final", etc.. */ + { + const char* p; + int len; + + p = glyph_name; + while ( *p && *p != '.' ) p++; + len = p-glyph_name; + + if ( *p && len < 64 ) + { + strncpy( temp, glyph_name, len ); + temp[len] = 0; + glyph_name = temp; + } + } + + /* now, lookup the glyph in the Adobe Glyph List */ + for ( n = 0; n < NUM_ADOBE_GLYPHS; n++ ) + { + const char* name = t1_standard_glyphs[n]; + + if ( first == name[0] && strcmp( glyph_name, name ) == 0 ) + return names_to_unicode[n]; + } + /* not found, there is probably no Unicode value for this glyph name */ + return 0; + } + + + /* qsort callback to sort the unicode map */ + static + int compare_uni_maps( const void* a, const void* b ) + { + PS_UniMap* map1 = (PS_UniMap*)a; + PS_UniMap* map2 = (PS_UniMap*)b; + + return ( map1->unicode < map2->unicode ? -1 : + map1->unicode > map2->unicode ? 1 : 0 ); + } + + + /* Builds a table that maps Unicode values to glyph indices */ + static + FT_Error PS_Build_Unicode_Table( FT_Memory memory, + FT_UInt num_glyphs, + const char** glyph_names, + PS_Unicodes *table ) + { + FT_Error error; + + /* we first allocate the table */ + table->num_maps = 0; + table->maps = 0; + + if ( !ALLOC_ARRAY( table->maps, num_glyphs, PS_UniMap ) ) + { + FT_UInt n; + FT_UInt count; + PS_UniMap* map; + FT_ULong uni_char; + + map = table->maps; + for ( n = 0; n < num_glyphs; n++ ) + { + const char* gname = glyph_names[n]; + if (gname) + { + uni_char = PS_Unicode_Value(gname); + if (uni_char && uni_char != 0xFFFF) + { + map->unicode = uni_char; + map->glyph_index = n; + map++; + } + } + } + + /* now, compress the table a bit */ + count = map - table->maps; + if ( count > 0 && REALLOC( table->maps, + num_glyphs*sizeof(PS_UniMap), + count*sizeof(PS_UniMap) ) ) + { + count = 0; + } + + if (count == 0) + { + FREE( table->maps ); + if (!error) + error = FT_Err_Invalid_Argument; /* no unicode chars here !! */ + } + else + /* sort the table in increasing order of unicode values */ + qsort( table->maps, count, sizeof(PS_UniMap), compare_uni_maps ); + + table->num_maps = count; + } + return error; + } + + static + FT_UInt PS_Lookup_Unicode( PS_Unicodes* table, + FT_ULong unicode ) + { + PS_UniMap *min, *max, *mid; + /* perform a binary search on the table */ + min = table->maps; + max = min + table->num_maps - 1; + + while (min <= max) + { + mid = min + (max-min)/2; + if ( mid->unicode == unicode ) + return mid->glyph_index; + + if (min == max) + break; + + if ( mid->unicode < unicode ) min = mid+1; + else max = mid-1; + } + + return 0xFFFF; + } + +#endif + + + + static + const char* PS_Macintosh_Name( FT_UInt name_index ) + { + if (name_index >= 258) + name_index = 0; + + return standard_glyph_names[ mac_standard_names[name_index] ]; + } + + + + static + const char* PS_Standard_Strings( FT_UInt sid ) + { + return (sid < NUM_STD_GLYPHS ? t1_standard_glyphs[sid] : 0); + } + + + + static const PSNames_Interface psnames_interface = + { +#ifdef FT_CONFIG_OPTION_ADOBE_GLYPH_LIST + (PS_Unicode_Value_Func) PS_Unicode_Value, + (PS_Build_Unicodes_Func) PS_Build_Unicode_Table, + (PS_Lookup_Unicode_Func) PS_Lookup_Unicode, +#else + 0, + 0, + 0, +#endif + + (PS_Macintosh_Name_Func) PS_Macintosh_Name, + (PS_Adobe_Std_Strings_Func) PS_Standard_Strings, + + t1_standard_encoding, + t1_expert_encoding + }; + +#endif /* !FT_CONFIG_OPTION_NO_POSTSCRIPT_NAMES */ + + + + const FT_Module_Class psnames_module_class = + { + 0, /* this is not a font driver, nor a renderer */ + sizeof(FT_ModuleRec), + + "psnames", /* driver name */ + 100, /* driver version */ + 200, /* driver requires FreeType 2 or above */ + +#ifdef FT_CONFIG_OPTION_NO_POSTSCRIPT_NAMES + 0, +#else + (void*)&psnames_interface, /* module specific interface */ +#endif + + (FT_Module_Constructor) 0, + (FT_Module_Destructor) 0, + (FT_Module_Requester) 0 + }; + diff --git a/src/psnames/psmodule.h b/src/psnames/psmodule.h new file mode 100644 index 000000000..5fa89d5b5 --- /dev/null +++ b/src/psnames/psmodule.h @@ -0,0 +1,29 @@ +/***************************************************************************/ +/* */ +/* psmodule.h */ +/* */ +/* High-level PSNames module interface (specification). */ +/* */ +/* Copyright 1996-1999 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 PSDRIVER_H +#define PSDRIVER_H + +#include + + FT_EXPORT_VAR(const FT_Module_Class) psnames_module_class; + +#endif /* PSMODULE_H */ + + +/* END */