downloads — Instituto Nacional da Propriedade Industrial
Você está aqui:
Pedimos desculpas pelo inconveniente, mas a página que você estava tentando acessar n?o existe neste endere?o. Você pode usar os links abaixo para encontrar o que está procurando.
Se você está certo que o endere?o informado está correto mas está encontrando um erro, por favor contate o
Você poderia estar procurando por…
por admin, em 15/04/
por CGCOM, em 12/08/
por chimento, em 19/10/
por chimento, em 07/10/
por CGCOM, em 16/04/
por chimento, em 17/08/
por CGCOM, em 15/04/
por natalia.calandrini, em 03/07/
por chimento, em 11/05/
por chimento, em 11/05/#!/usr/bin/env python
# FreeType 2 glyph name builder
# Copyright ,
# 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
This python script generates the glyph names tables defined in the
PSNames module.
Its single argument is the name of the header file to be created.
import sys, string, struct, re, os.path
# This table lists the glyphs according to the Macintosh specification.
# It is used by the TrueType Postscript names table.
/TTRefMan/RM06/Chap6post.html
# for the official list.
mac_standard_names = \
".notdef", ".null", "nonmarkingreturn", "space", "exclam",
"quotedbl", "numbersign", "dollar", "percent", "ampersand",
"quotesingle", "parenleft", "parenright", "asterisk", "plus",
"comma", "hyphen", "period", "slash", "zero",
"one", "two", "three", "four", "five",
"six", "seven", "eight", "nine", "colon",
"semicolon", "less", "equal", "greater", "question",
"at", "A", "B", "C", "D",
"E", "F", "G", "H", "I",
"J", "K", "L", "M", "N",
"O", "P", "Q", "R", "S",
"T", "U", "V", "W", "X",
"Y", "Z", "bracketleft", "backslash", "bracketright",
"asciicircum", "underscore", "grave", "a", "b",
"c", "d", "e", "f", "g",
"h", "i", "j", "k", "l",
"m", "n", "o", "p", "q",
"r", "s", "t", "u", "v",
"w", "x", "y", "z", "braceleft",
"bar", "braceright", "asciitilde", "Adieresis", "Aring",
"Ccedilla", "Eacute", "Ntilde", "Odieresis", "Udieresis",
"aacute", "agrave", "acircumflex", "adieresis", "atilde",
"aring", "ccedilla", "eacute", "egrave", "ecircumflex",
"edieresis", "iacute", "igrave", "icircumflex", "idieresis",
"ntilde", "oacute", "ograve", "ocircumflex", "odieresis",
"otilde", "uacute", "ugrave", "ucircumflex", "udieresis",
"dagger", "degree", "cent", "sterling", "section",
"bullet", "paragraph", "germandbls", "registered", "copyright",
"trademark", "acute", "dieresis", "notequal", "AE",
"Oslash", "infinity", "plusminus", "lessequal", "greaterequal",
"yen", "mu", "partialdiff", "summation", "product",
"pi", "integral", "ordfeminine", "ordmasculine", "Omega",
"ae", "oslash", "questiondown", "exclamdown", "logicalnot",
"radical", "florin", "approxequal", "Delta", "guillemotleft",
"guillemotright", "ellipsis", "nonbreakingspace", "Agrave", "Atilde",
"Otilde", "OE", "oe", "endash", "emdash",
"quotedblleft", "quotedblright", "quoteleft", "quoteright", "divide",
"lozenge", "ydieresis", "Ydieresis", "fraction", "currency",
"guilsinglleft", "guilsinglright", "fi", "fl", "daggerdbl",
"periodcentered", "quotesinglbase", "quotedblbase", "perthousand",
"Acircumflex",
"Ecircumflex", "Aacute", "Edieresis", "Egrave", "Iacute",
"Icircumflex", "Idieresis", "Igrave", "Oacute", "Ocircumflex",
"apple", "Ograve", "Uacute", "Ucircumflex", "Ugrave",
"dotlessi", "circumflex", "tilde", "macron", "breve",
"dotaccent", "ring", "cedilla", "hungarumlaut", "ogonek",
"caron", "Lslash", "lslash", "Scaron", "scaron",
"Zcaron", "zcaron", "brokenbar", "Eth", "eth",
"Yacute", "yacute", "Thorn", "thorn", "minus",
"multiply", "onesuperior", "twosuperior", "threesuperior", "onehalf",
"onequarter", "threequarters", "franc", "Gbreve", "gbreve",
"Idotaccent", "Scedilla", "scedilla", "Cacute", "cacute",
"Ccaron", "ccaron", "dcroat"
# The list of standard `SID' glyph names.
For the official list,
# see Annex A of document at
/asn/developer/pdfs/tn/5176.CFF.pdf.
sid_standard_names = \
".notdef", "space", "exclam", "quotedbl", "numbersign",
"dollar", "percent", "ampersand", "quoteright", "parenleft",
"parenright", "asterisk", "plus", "comma", "hyphen",
"period", "slash", "zero", "one", "two",
"three", "four", "five", "six", "seven",
"eight", "nine", "colon", "semicolon", "less",
"equal", "greater", "question", "at", "A",
"B", "C", "D", "E", "F",
"G", "H", "I", "J", "K",
"L", "M", "N", "O", "P",
"Q", "R", "S", "T", "U",
"V", "W", "X", "Y", "Z",
"bracketleft", "backslash", "bracketright", "asciicircum", "underscore",
"quoteleft", "a", "b", "c", "d",
"e", "f", "g", "h", "i",
"j", "k", "l", "m", "n",
"o", "p", "q", "r", "s",
"t", "u", "v", "w", "x",
"y", "z", "braceleft", "bar", "braceright",
"asciitilde", "exclamdown", "cent", "sterling", "fraction",
"yen", "florin", "section", "currency", "quotesingle",
"quotedblleft", "guillemotleft", "guilsinglleft", "guilsinglright", "fi",
"fl", "endash", "dagger", "daggerdbl", "periodcentered",
"paragraph", "bullet", "quotesinglbase", "quotedblbase", "quotedblright",
"guillemotright", "ellipsis", "perthousand", "questiondown", "grave",
"acute", "circumflex", "tilde", "macron", "breve",
"dotaccent", "dieresis", "ring", "cedilla", "hungarumlaut",
"ogonek", "caron", "emdash", "AE", "ordfeminine",
"Lslash", "Oslash", "OE", "ordmasculine", "ae",
"dotlessi", "lslash", "oslash", "oe", "germandbls",
"onesuperior", "logicalnot", "mu", "trademark", "Eth",
"onehalf", "plusminus", "Thorn", "onequarter", "divide",
"brokenbar", "degree", "thorn", "threequarters", "twosuperior",
"registered", "minus", "eth", "multiply", "threesuperior",
"copyright", "Aacute", "Acircumflex", "Adieresis", "Agrave",
"Aring", "Atilde", "Ccedilla", "Eacute", "Ecircumflex",
"Edieresis", "Egrave", "Iacute", "Icircumflex", "Idieresis",
"Igrave", "Ntilde", "Oacute", "Ocircumflex", "Odieresis",
"Ograve", "Otilde", "Scaron", "Uacute", "Ucircumflex",
"Udieresis", "Ugrave", "Yacute", "Ydieresis", "Zcaron",
"aacute", "acircumflex", "adieresis", "agrave", "aring",
"atilde", "ccedilla", "eacute", "ecircumflex", "edieresis",
"egrave", "iacute", "icircumflex", "idieresis", "igrave",
"ntilde", "oacute", "ocircumflex", "odieresis", "ograve",
"otilde", "scaron", "uacute", "ucircumflex", "udieresis",
"ugrave", "yacute", "ydieresis", "zcaron", "exclamsmall",
"Hungarumlautsmall", "dollaroldstyle", "dollarsuperior", "ampersandsmall",
"Acutesmall",
"parenleftsuperior", "parenrightsuperior", "twodotenleader",
"onedotenleader", "zerooldstyle",
"oneoldstyle", "twooldstyle", "threeoldstyle", "fouroldstyle",
"fiveoldstyle",
"sixoldstyle", "sevenoldstyle", "eightoldstyle", "nineoldstyle",
"commasuperior",
"threequartersemdash", "periodsuperior", "questionsmall", "asuperior",
"bsuperior",
"centsuperior", "dsuperior", "esuperior", "isuperior", "lsuperior",
"msuperior", "nsuperior", "osuperior", "rsuperior", "ssuperior",
"tsuperior", "ff", "ffi", "ffl", "parenleftinferior",
"parenrightinferior", "Circumflexsmall", "hyphensuperior", "Gravesmall",
"Bsmall", "Csmall", "Dsmall", "Esmall", "Fsmall",
"Gsmall", "Hsmall", "Ismall", "Jsmall", "Ksmall",
"Lsmall", "Msmall", "Nsmall", "Osmall", "Psmall",
"Qsmall", "Rsmall", "Ssmall", "Tsmall", "Usmall",
"Vsmall", "Wsmall", "Xsmall", "Ysmall", "Zsmall",
"colonmonetary", "onefitted", "rupiah", "Tildesmall", "exclamdownsmall",
"centoldstyle", "Lslashsmall", "Scaronsmall", "Zcaronsmall",
"Dieresissmall",
"Brevesmall", "Caronsmall", "Dotaccentsmall", "Macronsmall", "figuredash",
"hypheninferior", "Ogoneksmall", "Ringsmall", "Cedillasmall",
"questiondownsmall",
"oneeighth", "threeeighths", "fiveeighths", "seveneighths", "onethird",
"twothirds", "zerosuperior", "foursuperior", "fivesuperior",
"sixsuperior",
"sevensuperior", "eightsuperior", "ninesuperior", "zeroinferior",
"oneinferior",
"twoinferior", "threeinferior", "fourinferior", "fiveinferior",
"sixinferior",
"seveninferior", "eightinferior", "nineinferior", "centinferior",
"dollarinferior",
"periodinferior", "commainferior", "Agravesmall", "Aacutesmall",
"Acircumflexsmall",
"Atildesmall", "Adieresissmall", "Aringsmall", "AEsmall", "Ccedillasmall",
"Egravesmall", "Eacutesmall", "Ecircumflexsmall", "Edieresissmall",
"Igravesmall",
"Iacutesmall", "Icircumflexsmall", "Idieresissmall", "Ethsmall",
"Ntildesmall",
"Ogravesmall", "Oacutesmall", "Ocircumflexsmall", "Otildesmall",
"Odieresissmall",
"OEsmall", "Oslashsmall", "Ugravesmall", "Uacutesmall",
"Ucircumflexsmall",
"Udieresissmall", "Yacutesmall", "Thornsmall", "Ydieresissmall",
"001.000",
"001.001", "001.002", "001.003", "Black", "Bold",
"Book", "Light", "Medium", "Regular", "Roman",
"Semibold"
# This table maps character codes of the Adobe Standard Type 1
# encoding to glyph indices in the sid_standard_names table.
t1_standard_encoding = \
99, 100, 101, 102, 103, 104,
105, 106, 107, 108, 109, 110,
0, 111, 112, 113,
0, 115, 116, 117, 118, 119, 120, 121, 122,
0, 124, 125, 126, 127, 128, 129, 130,
0, 132, 133,
0, 134, 135, 136, 137,
0, 140, 141, 142, 143,
0, 146, 147,
# This table maps character codes of the Adobe Expert Type 1
# encoding to glyph indices in the sid_standard_names table.
t1_expert_encoding = \
1, 229, 230,
0, 231, 232, 233, 234,
235, 236, 237, 238,
99, 239, 240,
241, 242, 243, 244, 245, 246, 247, 248,
249, 250, 251, 252,
0, 253, 254, 255, 256, 257,
0, 259, 260, 261, 262,
0, 263, 264, 265,
0, 266, 109, 110, 267,
0, 270, 271, 272, 273, 274, 275, 276,
277, 278, 279, 280, 281, 282, 283, 284, 285, 286,
287, 288, 289, 290, 291, 292, 293, 294, 295, 296,
297, 298, 299, 300, 301, 302, 303,
0, 304, 305, 306,
0, 307, 308, 309, 310,
0, 314, 315,
0, 316, 317, 318,
0, 158, 155,
163, 319, 320, 321, 322, 323, 324, 325,
326, 150, 164, 169, 327, 328, 329, 330, 331, 332,
333, 334, 335, 336, 337, 338, 339, 340, 341, 342,
343, 344, 345, 346, 347, 348, 349, 350, 351, 352,
353, 354, 355, 356, 357, 358, 359, 360, 361, 362,
363, 364, 365, 366, 367, 368, 369, 370, 371, 372,
373, 374, 375, 376, 377, 378
# This data has been taken literally from the file `glyphlist.txt',
# version 2.0, 22 Sept 2002.
It is available from
/asn/developer/typeforum/unicodegn.html
/public/developer/en/opentype/glyphlist.txt
adobe_glyph_list = """\
Chedescen04BE
DieresisAF6CC
DieresisGF6CD
H18533;25CF
H18543;25AA
H18551;25AB
Upsilon1;03D2
Upsilon03D3
Upsilondie03D4
afii299;200E
afii300;200F
afii301;200D
afii57509;06AF
afii57514;06BA
afii57636;20AA
afii57645;05BE
afii57674;05DA
afii57675;05DB
afii57676;05DC
afii57677;05DD
afii57678;05DE
afii57679;05DF
afii57690;05EA
afii57694;FB2A
afii57695;FB2B
afii57700;FB4B
afii57705;FB1F
afii57723;FB35
afii57796;05BB
afii57807;05BC
afii57839;05BD
afii57841;05BF
afii57929;02BC
afii64937;02BD
blackl3010
blacklenticulaFE3B
blackle3011
blacklenticularFE3C
blackr25B6
blackupp25B4
chedescen04BF
controlACK;0006
controlBEL;0007
controlBS;0008
controlCAN;0018
controlCR;000D
controlDC1;0011
controlDC2;0012
controlDC3;0013
controlDC4;0014
controlDEL;007F
controlDLE;0010
controlEM;0019
controlENQ;0005
controlEOT;0004
controlESC;001B
controlETB;0017
controlETX;0003
controlFF;000C
controlFS;001C
controlGS;001D
controlHT;0009
controlLF;000A
controlNAK;0015
controlRS;001E
controlSI;000F
controlSO;000E
controlSOT;0002
controlSTX;0001
controlSUB;001A
controlSYN;0016
controlUS;001F
controlVT;000B
cornerFF62
cornerbFF63
cornerFE42
d05D3 05B2
d05D3 05B1
dblanglFE3D
dblangleFE3E
denominatorminu09F8
eightci2791
fiveci278E
fourci278D
glottal02E4
hatafpatah16;05B2
hatafpatah23;05B2
hatafpatah2f;05B2
hatafqamats1b;05B3
hatafqamats28;05B3
hatafqamats34;05B3
hatafsegol17;05B1
hatafsegol24;05B1
hatafsegol30;05B1
hehhamzFBA4
hiriq14;05B4
hiriq21;05B4
hiriq2d;05B4
holam19;05B9
holam26;05B9
holam32;05B9
ideographi3237
ideogr323D
ideogr329D
ideogr3296
kashidaaut0640
katahiraFF70
lamalefhFEF8
lamalefhamzFEF7
lamalefhFEFA
lamalefhamzFEF9
lamalefmFEF6
lamalefmaddFEF5
05DC 05B9 05BC
la05DC 05B9 05BC
lammFEDF FEE4 FEA0
lammFEDF FEE4 FEA8
middleFF65
nineci2792
omega1;03D6
patah11;05B7
patah1d;05B7
patah2a;05B7
qamats10;05B8
qamats1a;05B8
qamats1c;05B8
qamats27;05B8
qamats29;05B8
qamats33;05B8
qubuts18;05BB
qubuts25;05BB
qubuts31;05BB
0631 FEF3 FE8E 0644
rrvoca0AC4
sallallahouFDFA
segol13;05B6
segol1f;05B6
segol2c;05B6
semivoiFF9F
sevenci2790
sheva115;05B0
sheva15;05B0
sheva22;05B0
sheva2e;05B0
sigma1;03C2
sixteencurren09F9
squaredi25A9
squareorth25A6
squareupper25A7
squareupper25A8
tcFB7C FEE4
theta1;03D1
threeci278C
tortoisesFE5D
tortoiseshelFE39
tortoiseshFE5E
tortoiseshellFE3A
tsere12;05B5
tsere1e;05B5
tsere2b;05B5
vavdagesh65;FB35
whitecorneFE43
whitecornerFE44
whitediamondcontain25C8
whitedownp25BF
whiteleftp25C3
whitel3016
whitele3017
whiterightp25B9
whiter25B7
whitetort3018
whitetorto3019
whiteupp25B5
yehhamFE8B
# string table management
class StringTable:
def __init__( self, name_list, master_table_name ):
self.names
= name_list
self.master_table = master_table_name
self.indices
for name in name_list:
self.indices[name] = index
index += len( name ) + 1
self.total = index
def dump( self, file ):
write = file.write
static const char
" + self.master_table +
"[" + repr( self.total ) + "] =\n" )
for name in self.names:
line += string.join( ( re.findall( ".", name ) ), "','" )
line += "', 0,\n"
write( line + "
};\n\n\n" )
def dump_sublist( self, file, table_name, macro_name, sublist ):
write = file.write
write( "#define " + macro_name + "
" + repr( len( sublist ) ) + "\n\n" )
/* Values are offsets into the `" +
self.master_table + "' table */\n\n" )
static const short
" + table_name +
"[" + macro_name + "] =\n" )
comma = ""
for name in sublist:
line += comma
line += "%4d" % self.indices[name]
comma = ","
if col == 14:
comma = ",\n
write( line + "\n
};\n\n\n" )
# We now store the Adobe Glyph List in compressed form.
The list is put
# into a data structure called `trie' (because it has a tree-like
# appearance).
Consider, for example, that you want to store the
# following name mapping:
Abstract => 4
# It is possible to store the entries as follows.
+-acute => 6
+-alon => 2
+-stract => 4
# We see that each node in the trie has:
# - one or more `letters'
# - an optional value
# - zero or more child nodes
# The first step is to call
root = StringNode( "", 0 )
for word in map.values():
root.add( word, map[word] )
# which creates a large trie where each node has only one children.
# Executing
root = root.optimize()
# optimizes the trie by merging the letters of successive nodes whenever
# possible.
# Each node of the trie is stored as follows.
# - First the node's letter, according to the following scheme.
use the fact that in the AGL no name contains character codes > 127.
description
----------------------------------------------------------------
Set to 1 if this is not the last letter
in the word.
The letter's ASCII value.
# - The letter is followed by a children count and the value of the
current key (if any).
Again we can do some optimization because all
AGL entries are from the BMP; this means that 16 bits are sufficient
to store its Unicode values.
Additionally, no node has more than
127 children.
description
-----------------------------------------
Set to 1 if a 16-bit Unicode value follows.
num_children
Number of childrens.
Can be 0 only if
`hasvalue' is set to 1.
Optional Unicode value.
# - A node is finished by a list of 16bit absolute offsets to the
children, which must be sorted in increasing order of their first
# For simplicity, all 16bit quantities are stored in big-endian order.
# The root node has first letter = 0, and no value.
class StringNode:
def __init__( self, letter, value ):
self.letter
self.value
self.children = {}
def __cmp__( self, other ):
return ord( self.letter[0] ) - ord( other.letter[0] )
def add( self, word, value ):
if len( word ) == 0:
self.value = value
letter = word[0]
= word[1:]
if self.children.has_key( letter ):
child = self.children[letter]
child = StringNode( letter, 0 )
self.children[letter] = child
child.add( word, value )
def optimize( self ):
# optimize all children first
= self.children.values()
self.children = {}
for child in children:
self.children[child.letter[0]] = child.optimize()
# don't optimize if there's a value,
# if we don't have any child or if we
# have more than one child
if ( self.value != 0 ) or ( not children ) or len( children ) > 1:
return self
child = children[0]
self.letter
+= child.letter
self.value
= child.value
self.children = child.children
return self
def dump_debug( self, write, margin ):
# this is used during debugging
line = margin + "+-"
if len( self.letter ) == 0:
line += ""
line += self.letter
if self.value:
line += " => " + repr( self.value )
write( line + "\n" )
if self.children:
margin += "| "
for child in self.children.values():
child.dump_debug( write, margin )
def locate( self, index ):
self.index = index
if len( self.letter ) > 0:
index += len( self.letter ) + 1
index += 2
if self.value != 0:
index += 2
children = self.children.values()
children.sort()
index += 2 * len( children )
for child in children:
index = child.locate( index )
return index
def store( self, storage ):
# write the letters
l = len( self.letter )
if l == 0:
storage += struct.pack( "B", 0 )
for n in range( l ):
val = ord( self.letter[n] )
write( line )
write( line + "\n
};\n\n\n" )
def main():
"""main program body"""
if len( sys.argv ) != 2:
print __doc__ % sys.argv[0]
sys.exit( 1 )
= open( sys.argv[1], "w\n" )
write = file.write
count_sid = len( sid_standard_names )
# `mac_extras' contains the list of glyph names in the Macintosh standard
# encoding which are not in the SID Standard Names.
mac_extras = filter_glyph_names( mac_standard_names, sid_standard_names )
# `base_list' contains the names of our final glyph names table.
# It consists of the `mac_extras' glyph names, followed by the SID
# standard names.
mac_extras_count = len( mac_extras )
= mac_extras + sid_standard_names
write( "/***************************************************************************/\n" )
write( "/*
write( "/*
%-71s*/\n" % os.path.basename( sys.argv[1] ) )
write( "/*
write( "/*
PostScript glyph names.
write( "/*
write( "/*
Copyright 2005 by
write( "/*
David Turner, Robert Wilhelm, and Werner Lemberg.
write( "/*
write( "/*
This file is part of the FreeType project, and may only be used,
write( "/*
modified, and distributed under the terms of the FreeType project
write( "/*
license, LICENSE.TXT.
By continuing to use, modify, or distribute
write( "/*
this file you indicate that you have read the license and
write( "/*
understand and accept it fully.
write( "/*
write( "/***************************************************************************/\n" )
write( "\n" )
write( "\n" )
/* This file has been generated automatically -- do not edit! */\n" )
write( "\n" )
write( "\n" )
# dump final glyph list (mac extras + sid standard names)
st = StringTable( base_list, "ft_standard_glyph_names" )
st.dump( file )
st.dump_sublist( file, "ft_mac_names",
"FT_NUM_MAC_NAMES", mac_standard_names )
st.dump_sublist( file, "ft_sid_names",
"FT_NUM_SID_NAMES", sid_standard_names )
dump_encoding( file, "t1_standard_encoding", t1_standard_encoding )
dump_encoding( file, "t1_expert_encoding", t1_expert_encoding )
# dump the AGL in its compressed form
agl_glyphs, agl_values = adobe_glyph_values()
dict = StringNode( "", 0 )
for g in range( len( agl_glyphs ) ):
dict.add( agl_glyphs[g], eval( "0x" + agl_values[g] ) )
= dict.optimize()
= dict.locate( 0 )
dict_array = dict.store( "" )
write( """\
This table is a compressed version of the Adobe Glyph List (AGL),
optimized for efficient searching.
It has been generated by the
`glnames.py' python script located in the `src/tools' directory.
The lookup function to get the Unicode value for a given string
is defined below the table.
dump_array( dict_array, write, "ft_adobe_glyph_list" )
# write the lookup routine now
write( """\
This function searches the compressed table efficiently.
static unsigned long
ft_get_adobe_glyph_index( const char*
const char*
count, min,
const unsigned char*
p = ft_adobe_glyph_
if ( name == 0 || name >= limit )
= *name++;
count = p[1];
while ( min > 1;
const unsigned char*
= p + mid * 2;
q = ft_adobe_glyph_list + ( ( (int)q[0] << 8 ) | q[1] );
c2 = q[0] & 127;
if ( c2 == c )
if ( c2 = limit )
if ( (p[0] & 128) == 0 &&
(p[1] & 128) != 0 )
return (unsigned long)( ( (int)p[2] < 0; count--, p += 2 )
offset = ( (int)p[0] << 8 ) | p[1];
const unsigned char*
= ft_adobe_glyph_list +
if ( c == ( q[0] & 127 ) )
goto NextI
# generate unit test, or don't
# now write the unit test to check that everything works OK
write( "#ifdef TEST\n\n" )
write( "static const char* const
the_names[] = {\n" )
for name in agl_glyphs:
"' + name + '",\n' )
0\n};\n" )
write( "static const unsigned long
the_values[] = {\n" )
for val in agl_values:
0x' + val + ',\n' )
0\n};\n" )
write( """
main( void )
result = 0;
const char* const*
const unsigned long*
values = the_
for ( ; * names++, values++ )
const char*
unsigned long
reference = *
value = ft_get_adobe_glyph_index( name, name + strlen( name ) );
if ( value != reference )
result = 1;
fprintf( stderr, "name '%s' => %04x instead of %04x\\n",
name, value, reference );
write( "#endif /* TEST */\n" )
write("\n/* END */\n")
# Now run the main routine}