Group :: System/Libraries
RPM: libfontenc
Navigation
Main Changelog Spec Patches Sources Download Gear Bugs and FR Repocop
pax_global_header 0000666 0000000 0000000 00000000064 12136374753 0014525 g ustar 00root root 0000000 0000000 52 comment=3acba630d8b57084f7e92c15732408711ed5137a
libfontenc-1.1.2/ 0000755 0000000 0000000 00000000000 12136374753 0013647 5 ustar 00root root 0000000 0000000 libfontenc-1.1.2/.gitignore 0000644 0000000 0000000 00000001753 12136374753 0015645 0 ustar 00root root 0000000 0000000 #
# X.Org module default exclusion patterns
# The next section if for module specific patterns
#
# Do not edit the following section
# GNU Build System (Autotools)
aclocal.m4
autom4te.cache/
autoscan.log
ChangeLog
compile
config.guess
config.h
config.h.in
config.log
config-ml.in
config.py
config.status
config.status.lineno
config.sub
configure
configure.scan
depcomp
.deps/
INSTALL
install-sh
.libs/
libtool
libtool.m4
ltmain.sh
lt~obsolete.m4
ltoptions.m4
ltsugar.m4
ltversion.m4
Makefile
Makefile.in
mdate-sh
missing
mkinstalldirs
*.pc
py-compile
stamp-h?
symlink-tree
texinfo.tex
ylwrap
# Do not edit the following section
# Edit Compile Debug Document Distribute
*~
*.[0-9]
*.[0-9]x
*.bak
*.bin
core
*.dll
*.exe
*-ISO*.bdf
*-JIS*.bdf
*-KOI8*.bdf
*.kld
*.ko
*.ko.cmd
*.lai
*.l[oa]
*.[oa]
*.obj
*.patch
*.so
*.pcf.gz
*.pdb
*.tar.bz2
*.tar.gz
#
# Add & Override patterns for libfontenc
#
# Edit the following section as needed
# For example, !report.pc overrides *.pc. See 'man gitignore'
#
libfontenc-1.1.2/COPYING 0000644 0000000 0000000 00000002057 12136374753 0014706 0 ustar 00root root 0000000 0000000 Copyright (c) 1998-2001 by Juliusz Chroboczek
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
libfontenc-1.1.2/Makefile.am 0000644 0000000 0000000 00000002617 12136374753 0015711 0 ustar 00root root 0000000 0000000 #
# Copyright 2005 Red Hat, Inc.
#
# Permission to use, copy, modify, distribute, and sell this software and its
# documentation for any purpose is hereby granted without fee, provided that
# the above copyright notice appear in all copies and that both that
# copyright notice and this permission notice appear in supporting
# documentation, and that the name of Red Hat not be used in
# advertising or publicity pertaining to distribution of the software without
# specific, written prior permission. Red Hat makes no
# representations about the suitability of this software for any purpose. It
# is provided "as is" without express or implied warranty.
#
# RED HAT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
# INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
# EVENT SHALL RED HAT BE LIABLE FOR ANY SPECIAL, INDIRECT OR
# CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
# DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
# TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
# PERFORMANCE OF THIS SOFTWARE.
SUBDIRS = src
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = fontenc.pc
MAINTAINERCLEANFILES = ChangeLog INSTALL
.PHONY: ChangeLog INSTALL
INSTALL:
$(INSTALL_CMD)
ChangeLog:
$(CHANGELOG_CMD)
dist-hook: ChangeLog INSTALL
if LINT
lint:
(cd src && $(MAKE) $(MFLAGS) lint)
endif LINT
libfontenc-1.1.2/README 0000644 0000000 0000000 00000001240 12136374753 0014524 0 ustar 00root root 0000000 0000000 libfontenc - font encoding library
All questions regarding this software should be directed at the
Xorg mailing list:
http://lists.freedesktop.org/mailman/listinfo/xorg
Please submit bug reports to the Xorg bugzilla:
https://bugs.freedesktop.org/enter_bug.cgi?product=xorg
The master development code repository can be found at:
git://anongit.freedesktop.org/git/xorg/lib/libfontenc
http://cgit.freedesktop.org/xorg/lib/libfontenc
For patch submission instructions, see:
http://www.x.org/wiki/Development/Documentation/SubmittingPatches
For more information on the git code manager, see:
http://wiki.x.org/wiki/GitPage
libfontenc-1.1.2/autogen.sh 0000755 0000000 0000000 00000000321 12136374753 0015644 0 ustar 00root root 0000000 0000000 #! /bin/sh
srcdir=`dirname $0`
test -z "$srcdir" && srcdir=.
ORIGDIR=`pwd`
cd $srcdir
autoreconf -v --install || exit 1
cd $ORIGDIR || exit $?
if test -z "$NOCONFIGURE"; then
$srcdir/configure "$@"
fi
libfontenc-1.1.2/configure.ac 0000644 0000000 0000000 00000004560 12136374753 0016142 0 ustar 00root root 0000000 0000000 # Copyright 2005 Red Hat, Inc.
#
# Permission to use, copy, modify, distribute, and sell this software and its
# documentation for any purpose is hereby granted without fee, provided that
# the above copyright notice appear in all copies and that both that
# copyright notice and this permission notice appear in supporting
# documentation, and that the name of Red Hat not be used in
# advertising or publicity pertaining to distribution of the software without
# specific, written prior permission. Red Hat makes no
# representations about the suitability of this software for any purpose. It
# is provided "as is" without express or implied warranty.
#
# RED HAT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
# INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
# EVENT SHALL RED HAT BE LIABLE FOR ANY SPECIAL, INDIRECT OR
# CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
# DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
# TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
# PERFORMANCE OF THIS SOFTWARE.
#
# Initialize Autoconf
AC_PREREQ([2.60])
AC_INIT([libfontenc], [1.1.2],
[https://bugs.freedesktop.org/enter_bug.cgi?product=xorg], [libfontenc])
AC_CONFIG_SRCDIR([Makefile.am])
AC_CONFIG_HEADERS([config.h])
# Initialize Automake
AM_INIT_AUTOMAKE([foreign dist-bzip2])
# Initialize libtool
AC_PROG_LIBTOOL
# Require X.Org macros 1.8 or later
m4_ifndef([XORG_MACROS_VERSION],
[m4_fatal([must install xorg-macros 1.8 or later before running autoconf/autogen])])
XORG_MACROS_VERSION(1.8)
XORG_DEFAULT_OPTIONS
# Require X.Org's font util macros 1.1 or later for XORG_FONTROOTDIR
m4_ifndef([XORG_FONT_MACROS_VERSION],
[m4_fatal([must install X.Org font-util 1.1 or later before running autoconf/autogen])])
XORG_FONT_MACROS_VERSION(1.1)
XORG_FONTSUBDIR([ENCODINGSDIR], [encodingsdir], [encodings])
# zlib
AC_CHECK_HEADER([zlib.h], [],
AC_MSG_FAILURE([zlib.h is required to compile libfontenc]))
AC_CHECK_LIB(z, gzclose, [],
AC_MSG_FAILURE([zlib is required to compile libfontenc]))
# Obtain compiler/linker options for depedencies
PKG_CHECK_MODULES(FONTENC, xproto)
# Allow checking code with lint, sparse, etc.
XORG_WITH_LINT
LINT_FLAGS="${LINT_FLAGS} ${FONTENC_CFLAGS}"
AC_CONFIG_FILES([Makefile
src/Makefile
fontenc.pc])
AC_OUTPUT
libfontenc-1.1.2/fontenc.pc.in 0000644 0000000 0000000 00000000321 12136374753 0016230 0 ustar 00root root 0000000 0000000 prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
includedir=@includedir@
Name: fontenc
Description: The fontenc Library
Version: @PACKAGE_VERSION@
Cflags: -I${includedir}
Libs: -L${libdir} -lfontenc
libfontenc-1.1.2/include/ 0000755 0000000 0000000 00000000000 12136374753 0015272 5 ustar 00root root 0000000 0000000 libfontenc-1.1.2/include/X11/ 0000755 0000000 0000000 00000000000 12136374753 0015643 5 ustar 00root root 0000000 0000000 libfontenc-1.1.2/include/X11/fonts/ 0000755 0000000 0000000 00000000000 12136374753 0016774 5 ustar 00root root 0000000 0000000 libfontenc-1.1.2/include/X11/fonts/fontenc.h 0000644 0000000 0000000 00000011605 12136374753 0020604 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 1998-2001 by Juliusz Chroboczek
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
/* Header for backend-independent encoding code */
/* An encoding is identified with a name. An encoding contains some
global encoding data, such as its size, and a set of mappings.
Mappings are identified by their type and two integers, known as
pid and eid, the interpretation of which is type dependent. */
#ifndef _FONTENC_H
#define _FONTENC_H
/* Encoding types. For future extensions, clients should be prepared
to ignore unknown encoding types. */
/* 0 is treated specially. */
#define FONT_ENCODING_UNICODE 1
#define FONT_ENCODING_TRUETYPE 2
#define FONT_ENCODING_POSTSCRIPT 3
/* This structure represents a mapping, either from numeric codes from
numeric codes, or from numeric codes to strings. */
/* It is expected that only one of `recode' and `name' will actually
be present. However, having both fields simplifies the interface
somewhat. */
typedef struct _FontMap {
int type; /* the type of the mapping */
int pid, eid; /* the identification of the mapping */
unsigned (*recode)(unsigned, void*); /* mapping function */
char *(*name)(unsigned, void*); /* function returning glyph names */
void *client_data; /* second parameter of the two above */
struct _FontMap *next; /* link to next element in list */
/* The following was added for version 0.3 of the font interface. */
/* It should be kept at the end to preserve binary compatibility. */
struct _FontEnc *encoding;
} FontMapRec, *FontMapPtr;
/* This is the structure that holds all the info for one encoding. It
consists of a charset name, its size, and a linked list of mappings
like above. */
typedef struct _FontEnc {
char *name; /* the name of the encoding */
char **aliases; /* its aliases, null terminated */
int size; /* its size, either in bytes or rows */
int row_size; /* the size of a row, or 0 if bytes */
FontMapPtr mappings; /* linked list of mappings */
struct _FontEnc *next; /* link to next element */
/* the following two were added in version 0.2 of the font interface */
/* they should be kept at the end to preserve binary compatibility */
int first; /* first byte or row */
int first_col; /* first column in each row */
} FontEncRec, *FontEncPtr;
typedef struct _FontMapReverse {
unsigned int (*reverse)(unsigned, void*);
void *data;
} FontMapReverseRec, *FontMapReversePtr;
/* Function prototypes */
/* extract an encoding name from an XLFD name. Returns a pointer to a
*static* buffer, or NULL */
char *FontEncFromXLFD(const char*, int);
/* find the encoding data for a given encoding name; second parameter
is the filename of the font for which the encoding is needed.
Returns NULL on failure. */
FontEncPtr FontEncFind(const char*, const char*);
/* Find a given mapping for an encoding. This is only a convenience
function, as clients are allowed to scavenge the data structures
themselves (as the TrueType backend does). */
FontMapPtr FontMapFind(FontEncPtr, int, int, int);
/* Do both in a single step */
FontMapPtr FontEncMapFind(const char *, int, int, int, const char *);
/* Recode a code. Always succeeds. */
unsigned FontEncRecode(unsigned, FontMapPtr);
/* Return a name for a code. Returns a string or NULL. */
char *FontEncName(unsigned, FontMapPtr);
/* Return a pointer to the name of the system encodings directory. */
/* This string is static and should not be modified. */
char* FontEncDirectory(void);
/* Identify an encoding file. If fileName doesn't exist, or is not an
encoding file, return NULL, otherwise returns a NULL-terminated
array of strings. */
char **FontEncIdentify(const char *fileName);
FontMapReversePtr FontMapReverse(FontMapPtr);
void FontMapReverseFree(FontMapReversePtr);
#endif
libfontenc-1.1.2/src/ 0000755 0000000 0000000 00000000000 12136374753 0014436 5 ustar 00root root 0000000 0000000 libfontenc-1.1.2/src/Makefile.am 0000644 0000000 0000000 00000001364 12136374753 0016476 0 ustar 00root root 0000000 0000000 lib_LTLIBRARIES = libfontenc.la
libfontenc_la_SOURCES = \
encparse.c \
fontenc.c \
fontencI.h
AM_CFLAGS = \
$(FONTENC_CFLAGS) \
$(CWARNFLAGS)
FONTENCDIR=@ENCODINGSDIR@
FONTENCDEFS = -DFONT_ENCODINGS_DIRECTORY=\"$(FONTENCDIR)/encodings.dir\"
AM_CPPFLAGS = -I$(top_srcdir)/include $(FONTENCDEFS)
libfontenc_la_LIBADD = @FONTENC_LIBS@
libfontenc_la_LDFLAGS = -version-number 1:0:0 -no-undefined
libfontencincludedir = $(includedir)/X11/fonts
libfontencinclude_HEADERS = \
$(top_srcdir)/include/X11/fonts/fontenc.h
if LINT
ALL_LINT_FLAGS=$(LINT_FLAGS) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
$(AM_CPPFLAGS) $(CPPFLAGS)
lint:
$(LINT) $(ALL_LINT_FLAGS) $(libfontenc_la_SOURCES) $(libfontenc_la_LIBADD) $(LIBS)
endif LINT
libfontenc-1.1.2/src/encparse.c 0000644 0000000 0000000 00000062730 12136374753 0016412 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 1998-2001 by Juliusz Chroboczek
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
/* Parser for encoding files */
/* This code assumes that we are using ASCII. We don't use the ctype
functions, as they depend on the current locale. On the other
hand, we do use strcasecmp, but only on strings that we've checked
to be pure ASCII. Bloody ``Code Set Independence''. */
#include <string.h>
#include <strings.h>
#include <stdio.h>
#include <stdlib.h>
#include "zlib.h"
typedef gzFile FontFilePtr;
#define FontFileGetc(f) gzgetc(f)
#define FontFileOpen(filename) gzopen(filename, "rb")
#define FontFileClose(f) gzclose(f)
#define MAXFONTFILENAMELEN 1024
#define MAXFONTNAMELEN 1024
#include <X11/fonts/fontenc.h>
#include "fontencI.h"
#define MAXALIASES 20
#define EOF_TOKEN -1
#define ERROR_TOKEN -2
#define EOL_TOKEN 0
#define NUMBER_TOKEN 1
#define KEYWORD_TOKEN 2
#define EOF_LINE -1
#define ERROR_LINE -2
#define STARTENCODING_LINE 1
#define STARTMAPPING_LINE 2
#define ENDMAPPING_LINE 3
#define CODE_LINE 4
#define CODE_RANGE_LINE 5
#define CODE_UNDEFINE_LINE 6
#define NAME_LINE 7
#define SIZE_LINE 8
#define ALIAS_LINE 9
#define FIRSTINDEX_LINE 10
/* Return from lexer */
#define MAXKEYWORDLEN 100
static long number_value;
static char keyword_value[MAXKEYWORDLEN+1];
static long value1, value2, value3;
/* Lexer code */
/* Skip to the beginning of new line */
static void
skipEndOfLine(FontFilePtr f, int c)
{
if(c == 0)
c = FontFileGetc(f);
for(;;)
if(c <= 0 || c == '\n')
return;
else
c = FontFileGetc(f);
}
/* Get a number; we're at the first digit. */
static unsigned
getnum(FontFilePtr f, int c, int *cp)
{
unsigned n = 0;
int base = 10;
/* look for `0' or `0x' prefix */
if(c == '0') {
c = FontFileGetc(f);
base = 8;
if(c == 'x' || c == 'X') {
base = 16;
c = FontFileGetc(f);
}
}
/* accumulate digits */
for(;;) {
if ('0' <= c && c <= '9') {
n *= base; n += c - '0';
} else if('a' <= c && c <= 'f') {
n *= base; n += c - 'a' + 10;
} else if('A' <=c && c <= 'F') {
n *= base; n += c - 'A' + 10;
} else
break;
c = FontFileGetc(f);
}
*cp = c; return n;
}
/* Skip to beginning of new line; return 1 if only whitespace was found. */
static int
endOfLine(FontFilePtr f, int c)
{
if(c == 0)
c = FontFileGetc(f);
for(;;) {
if(c <= 0 || c == '\n')
return 1;
else if(c == '#') {
skipEndOfLine(f,c);
return 1;
}
else if(c == ' ' || c == '\t') {
skipEndOfLine(f,c);
return 0;
}
c = FontFileGetc(f);
}
}
/* Get a token; we're at first char */
static int
gettoken(FontFilePtr f, int c, int *cp)
{
char *p;
if(c <= 0)
c = FontFileGetc(f);
if(c <= 0) {
return EOF_TOKEN;
}
while(c == ' ' || c == '\t')
c = FontFileGetc(f);
if(c=='\n') {
return EOL_TOKEN;
} else if(c == '#') {
skipEndOfLine(f,c);
return EOL_TOKEN;
} else if(c >= '0' && c <= '9') {
number_value = getnum(f,c,cp);
return NUMBER_TOKEN;
} else if((c >= 'A' && c <= 'Z') ||
(c >= 'a' && c <= 'z') ||
c == '/' || c == '_' || c == '-' || c == '.') {
p = keyword_value;
*p++ = c;
while(p-keyword_value < MAXKEYWORDLEN) {
c = FontFileGetc(f);
if(c <= ' ' || c > '~' || c == '#')
break;
*p++ = c;
}
*cp = c;
*p = '\0';
return KEYWORD_TOKEN;
} else {
*cp = c;
return ERROR_TOKEN;
}
}
/* Parse a line.
* Always skips to the beginning of a new line, even if an error occurs */
static int
getnextline(FontFilePtr f)
{
int c, token;
c = FontFileGetc(f);
if(c <= 0)
return EOF_LINE;
again:
token=gettoken(f,c,&c);
switch(token) {
case EOF_TOKEN:
return EOF_LINE;
case EOL_TOKEN:
/* empty line */
c = FontFileGetc(f);
goto again;
case NUMBER_TOKEN:
value1 = number_value;
token = gettoken(f,c,&c);
switch(token) {
case NUMBER_TOKEN:
value2 = number_value;
token = gettoken(f,c,&c);
switch(token) {
case NUMBER_TOKEN:
value3 = number_value;
return CODE_RANGE_LINE;
case EOL_TOKEN:
return CODE_LINE;
default:
skipEndOfLine(f,c);
return ERROR_LINE;
}
case KEYWORD_TOKEN:
if(!endOfLine(f,c))
return ERROR_LINE;
else
return NAME_LINE;
default:
skipEndOfLine(f,c);
return ERROR_LINE;
}
case KEYWORD_TOKEN:
if(!strcasecmp(keyword_value, "STARTENCODING")) {
token = gettoken(f,c,&c);
if(token == KEYWORD_TOKEN) {
if(endOfLine(f,c))
return STARTENCODING_LINE;
else
return ERROR_LINE;
} else {
skipEndOfLine(f,c);
return ERROR_LINE;
}
} else if(!strcasecmp(keyword_value, "ALIAS")) {
token = gettoken(f,c,&c);
if(token == KEYWORD_TOKEN) {
if(endOfLine(f,c))
return ALIAS_LINE;
else
return ERROR_LINE;
} else {
skipEndOfLine(f,c);
return ERROR_LINE;
}
} else if(!strcasecmp(keyword_value, "SIZE")) {
token = gettoken(f,c,&c);
if(token == NUMBER_TOKEN) {
value1 = number_value;
token = gettoken(f,c,&c);
switch(token) {
case NUMBER_TOKEN:
value2 = number_value;
return SIZE_LINE;
case EOL_TOKEN:
value2=0;
return SIZE_LINE;
default:
skipEndOfLine(f,c);
return ERROR_LINE;
}
} else {
skipEndOfLine(f,c);
return ERROR_LINE;
}
} else if(!strcasecmp(keyword_value, "FIRSTINDEX")) {
token = gettoken(f,c,&c);
if(token == NUMBER_TOKEN) {
value1 = number_value;
token = gettoken(f,c,&c);
switch(token) {
case NUMBER_TOKEN:
value2 = number_value;
return FIRSTINDEX_LINE;
case EOL_TOKEN:
value2 = 0;
return FIRSTINDEX_LINE;
default:
skipEndOfLine(f,c);
return ERROR_LINE;
}
} else {
skipEndOfLine(f,c);
return ERROR_LINE;
}
} else if(!strcasecmp(keyword_value, "STARTMAPPING")) {
keyword_value[0] = 0;
value1 = 0; value1 = 0;
/* first a keyword */
token = gettoken(f,c,&c);
if(token != KEYWORD_TOKEN) {
skipEndOfLine(f, c);
return ERROR_LINE;
}
/* optional first integer */
token = gettoken(f,c,&c);
if(token == NUMBER_TOKEN) {
value1 = number_value;
} else if(token == EOL_TOKEN) {
return STARTMAPPING_LINE;
} else {
skipEndOfLine(f, c);
return ERROR_LINE;
}
/* optional second integer */
token = gettoken(f,c,&c);
if(token == NUMBER_TOKEN) {
value2 = number_value;
} else if(token == EOL_TOKEN) {
return STARTMAPPING_LINE;
} else {
skipEndOfLine(f, c);
return ERROR_LINE;
}
if(!endOfLine(f,c))
return ERROR_LINE;
else {
return STARTMAPPING_LINE;
}
} else if(!strcasecmp(keyword_value, "UNDEFINE")) {
/* first integer */
token = gettoken(f,c,&c);
if(token != NUMBER_TOKEN) {
skipEndOfLine(f,c);
return ERROR_LINE;
}
value1 = number_value;
/* optional second integer */
token = gettoken(f,c,&c);
if(token == EOL_TOKEN) {
value2 = value1;
return CODE_UNDEFINE_LINE;
} else if(token == NUMBER_TOKEN) {
value2 = number_value;
if(endOfLine(f,c)) {
return CODE_UNDEFINE_LINE;
} else
return ERROR_LINE;
} else {
skipEndOfLine(f,c);
return ERROR_LINE;
}
} else if(!strcasecmp(keyword_value, "ENDENCODING")) {
if(endOfLine(f,c))
return EOF_LINE;
else
return ERROR_LINE;
} else if(!strcasecmp(keyword_value, "ENDMAPPING")) {
if(endOfLine(f,c))
return ENDMAPPING_LINE;
else
return ERROR_LINE;
} else {
skipEndOfLine(f,c);
return ERROR_LINE;
}
default:
return ERROR_LINE;
}
}
static void
install_mapping(FontEncPtr encoding, FontMapPtr mapping)
{
FontMapPtr m;
if(encoding->mappings == NULL)
encoding->mappings = mapping;
else {
m = encoding->mappings;
while(m->next != NULL)
m = m->next;
m->next = mapping;
}
mapping->next = NULL;
mapping->encoding = encoding;
}
static int
setCode(unsigned from, unsigned to, unsigned row_size,
unsigned *first, unsigned *last,
unsigned *encsize, unsigned short **enc)
{
unsigned index, i;
unsigned short *newenc;
if(from>0xFFFF)
return 0; /* success */
if(row_size==0)
index=from;
else {
if((value1 & 0xFF) >= row_size)
return 0; /* ignore out of range mappings */
index = (from>>8) * row_size + (from&0xFF);
}
/* Optimize away useless identity mappings. This is only expected
to be useful with linear encodings. */
if(index == to && (index < *first || index > *last))
return 0;
if(*encsize == 0) {
*encsize = (index < 256) ? 256 : 0x10000;
*enc = malloc((*encsize) * sizeof(unsigned short));
if(*enc == NULL) {
*encsize = 0;
return 1;
}
} else if(*encsize <= index) {
*encsize = 0x10000;
if((newenc = realloc(*enc, (*encsize) * sizeof(unsigned short)))==NULL)
return 1;
*enc = newenc;
}
if(*first > *last) {
*first = *last = index;
}
if(index < *first) {
for(i = index; i < *first; i++)
(*enc)[i] = i;
*first = index;
}
if(index > *last) {
for(i = *last + 1; i <= index; i++)
(*enc)[i] = i;
*last = index;
}
(*enc)[index] = to;
return 0;
}
/* Parser. If headerOnly is true, we're only interested in the
data contained in the encoding file's header. */
/* As font encodings are currently never freed, the allocations done
by this function are mostly its private business. Note, however,
that FontEncIdentify needs to free the header fields -- so if you
change this function, you may need to change FontEncIdentify. */
/* I want a garbage collector. */
static FontEncPtr
parseEncodingFile(FontFilePtr f, int headerOnly)
{
int line;
unsigned short *enc=NULL;
char **nam = NULL, **newnam;
unsigned i, first = 0xFFFF, last=0, encsize=0, namsize=0;
FontEncPtr encoding = NULL;
FontMapPtr mapping = NULL;
FontEncSimpleMapPtr sm;
FontEncSimpleNamePtr sn;
char *aliases[MAXALIASES];
int numaliases=0;
#if 0
/* GCC complains about unused labels. Please fix GCC rather than
obfuscating my code. */
no_encoding:
#endif
line = getnextline(f);
switch(line) {
case EOF_LINE:
goto error;
case STARTENCODING_LINE:
encoding = malloc(sizeof(FontEncRec));
if(encoding == NULL)
goto error;
encoding->name = strdup(keyword_value);
if(encoding->name == NULL)
goto error;
encoding->size = 256;
encoding->row_size = 0;
encoding->mappings = NULL;
encoding->next = NULL;
encoding->first = encoding->first_col=0;
goto no_mapping;
default:
goto error;
}
no_mapping:
line = getnextline(f);
switch(line) {
case EOF_LINE: goto done;
case ALIAS_LINE:
if(numaliases < MAXALIASES) {
aliases[numaliases] = strdup(keyword_value);
if(aliases[numaliases] == NULL)
goto error;
numaliases++;
}
goto no_mapping;
case SIZE_LINE:
encoding->size = value1;
encoding->row_size = value2;
goto no_mapping;
case FIRSTINDEX_LINE:
encoding->first = value1;
encoding->first_col = value2;
goto no_mapping;
case STARTMAPPING_LINE:
if(headerOnly)
goto done;
if(!strcasecmp(keyword_value, "unicode")) {
mapping = malloc(sizeof(FontMapRec));
if(mapping == NULL)
goto error;
mapping->type = FONT_ENCODING_UNICODE;
mapping->pid = 0;
mapping->eid = 0;
mapping->recode = NULL;
mapping->name = NULL;
mapping->client_data = NULL;
mapping->next = NULL;
goto mapping;
} else if(!strcasecmp(keyword_value, "cmap")) {
mapping = malloc(sizeof(FontMapRec));
if(mapping == NULL)
goto error;
mapping->type = FONT_ENCODING_TRUETYPE;
mapping->pid = value1;
mapping->eid = value2;
mapping->recode = NULL;
mapping->name = NULL;
mapping->client_data = NULL;
mapping->next = NULL;
goto mapping;
} else if(!strcasecmp(keyword_value, "postscript")) {
mapping = malloc(sizeof(FontMapRec));
if(mapping == NULL)
goto error;
mapping->type = FONT_ENCODING_POSTSCRIPT;
mapping->pid = 0;
mapping->eid = 0;
mapping->recode = NULL;
mapping->name = NULL;
mapping->client_data = NULL;
mapping->next = NULL;
goto string_mapping;
} else { /* unknown mapping type -- ignore */
goto skipmapping;
}
/* NOTREACHED */
goto error;
default: goto no_mapping; /* ignore unknown lines */
}
skipmapping:
line = getnextline(f);
switch(line) {
case ENDMAPPING_LINE:
goto no_mapping;
case EOF_LINE:
goto error;
default:
goto skipmapping;
}
mapping:
line = getnextline(f);
switch(line) {
case EOF_LINE: goto error;
case ENDMAPPING_LINE:
mapping->recode = FontEncSimpleRecode;
mapping->name = FontEncUndefinedName;
mapping->client_data = sm = malloc(sizeof(FontEncSimpleMapRec));
if(sm == NULL)
goto error;
sm->row_size = encoding->row_size;
if(first <= last) {
unsigned short *newmap;
sm->first = first;
sm->len=last-first+1;
newmap = malloc(sm->len * sizeof(unsigned short));
if(newmap == NULL) {
free(sm);
mapping->client_data = sm = NULL;
goto error;
}
for(i=0; i < sm->len; i++)
newmap[i] = enc[first+i];
sm->map = newmap;
} else {
sm->first = 0;
sm->len = 0;
sm->map = NULL;
}
install_mapping(encoding, mapping);
mapping = NULL;
first = 0xFFFF; last=0;
goto no_mapping;
case CODE_LINE:
if(setCode(value1, value2, encoding->row_size,
&first, &last, &encsize, &enc))
goto error;
goto mapping;
case CODE_RANGE_LINE:
if(value1 > 0x10000)
value1 = 0x10000;
if(value2 > 0x10000)
value2 = 0x10000;
if(value2 < value1)
goto mapping;
/* Do the last value first to avoid having to realloc() */
if(setCode(value2, value3+(value2-value1), encoding->row_size,
&first, &last, &encsize, &enc))
goto error;
for(i=value1; i<value2; i++) {
if(setCode(i, value3+(i-value1), encoding->row_size,
&first, &last, &encsize, &enc))
goto error;
}
goto mapping;
case CODE_UNDEFINE_LINE:
if(value1 > 0x10000)
value1 = 0x10000;
if(value2 > 0x10000)
value2 = 0x10000;
if(value2 < value1)
goto mapping;
/* Do the last value first to avoid having to realloc() */
if(setCode(value2, 0, encoding->row_size,
&first, &last, &encsize, &enc))
goto error;
for(i = value1; i < value2; i++) {
if(setCode(i, 0, encoding->row_size,
&first, &last, &encsize, &enc))
goto error;
}
goto mapping;
default: goto mapping; /* ignore unknown lines */
}
string_mapping:
line = getnextline(f);
switch(line) {
case EOF_LINE: goto error;
case ENDMAPPING_LINE:
mapping->recode = FontEncUndefinedRecode;
mapping->name = FontEncSimpleName;
mapping->client_data = sn = malloc(sizeof(FontEncSimpleNameRec));
if(sn == NULL)
goto error;
if(first > last) {
free(sn);
mapping->client_data = sn = NULL;
goto error;
}
sn->first = first;
sn->len = last - first + 1;
sn->map = malloc(sn->len*sizeof(char*));
if(sn->map == NULL) {
free(sn);
mapping->client_data = sn = NULL;
goto error;
}
for(i = 0; i < sn->len; i++)
sn->map[i] = nam[first+i];
install_mapping(encoding,mapping);
mapping = NULL;
first = 0xFFFF; last=0;
goto no_mapping;
case NAME_LINE:
if(value1 >= 0x10000) goto string_mapping;
if(namsize == 0) {
namsize = (value1) < 256 ? 256 : 0x10000;
nam = malloc(namsize * sizeof(char*));
if(nam == NULL) {
namsize=0;
goto error;
}
} else if(namsize <= value1) {
namsize = 0x10000;
if((newnam = (char**)realloc(nam, namsize)) == NULL)
goto error;
nam = newnam;
}
if(first > last) {
first = last = value1;
}
if(value1 < first) {
for(i = value1; i < first; i++)
nam[i] = NULL;
first = value1;
}
if(value1 > last) {
for(i=last+1; i <= value1; i++)
nam[i]=NULL;
last = value1;
}
nam[value1] = strdup(keyword_value);
if(nam[value1] == NULL) {
goto error;
}
goto string_mapping;
default: goto string_mapping; /* ignore unknown lines */
}
done:
if(encsize) free(enc); encsize=0; enc = NULL;
if(namsize) free(nam); namsize=0; nam = NULL; /* don't free entries! */
encoding->aliases=NULL;
if(numaliases) {
encoding->aliases = malloc((numaliases+1)*sizeof(char*));
if(encoding->aliases == NULL)
goto error;
for(i=0; i<numaliases; i++)
encoding->aliases[i] = aliases[i];
encoding->aliases[numaliases]=NULL;
}
return encoding;
error:
if(encsize) free(enc); encsize=0;
if(namsize) {
for(i = first; i <= last; i++)
free(nam[i]);
free(nam);
}
if(mapping) {
free(mapping->client_data);
free(mapping);
}
if(encoding) {
FontMapPtr nextmap;
free(encoding->name);
for (mapping = encoding->mappings; mapping; mapping = nextmap) {
free(mapping->client_data);
nextmap = mapping->next;
free(mapping);
}
free(encoding);
}
for(i = 0; i < numaliases; i++)
free(aliases[i]);
/* We don't need to free sn and sm as they handled locally in the body.*/
return NULL;
}
char*
FontEncDirectory(void)
{
static char* dir = NULL;
if(dir == NULL) {
char *c = getenv("FONT_ENCODINGS_DIRECTORY");
if(c) {
dir = strdup(c);
if(!dir)
return NULL;
} else {
dir = FONT_ENCODINGS_DIRECTORY;
}
}
return dir;
}
static void
parseFontFileName(const char *fontFileName, char *buf, char *dir)
{
const char *p;
char *q, *lastslash;
for(p = fontFileName, q = dir, lastslash = NULL; *p; p++, q++) {
*q = *p;
if(*p == '/')
lastslash = q+1;
}
if(!lastslash)
lastslash = dir;
*lastslash = '\0';
if(buf && strlen(dir) + 14 < MAXFONTFILENAMELEN) {
strcpy(buf, dir);
strcat(buf, "encodings.dir");
}
}
static FontEncPtr
FontEncReallyReallyLoad(const char *charset,
const char *dirname, const char *dir)
{
FontFilePtr f;
FILE *file;
FontEncPtr encoding;
char file_name[MAXFONTFILENAMELEN], encoding_name[MAXFONTNAMELEN],
buf[MAXFONTFILENAMELEN];
int count, n;
static char format[24] = "";
/* As we don't really expect to open encodings that often, we don't
take the trouble of caching encodings directories. */
if((file = fopen(dirname, "r")) == NULL) {
return NULL;
}
count = fscanf(file, "%d\n", &n);
if(count == EOF || count != 1) {
fclose(file);
return NULL;
}
encoding = NULL;
if (!format[0]) {
sprintf(format, "%%%ds %%%d[^\n]\n", (int)sizeof(encoding_name) - 1,
(int)sizeof(file_name) - 1);
}
for(;;) {
count = fscanf(file, format, encoding_name, file_name);
if(count == EOF)
break;
if(count != 2)
break;
if(!strcasecmp(encoding_name, charset)) {
/* Found it */
if(file_name[0] != '/') {
if(strlen(dir) + strlen(file_name) >= MAXFONTFILENAMELEN) {
fclose(file);
return NULL;
}
strcpy(buf, dir);
strcat(buf, file_name);
} else {
strcpy(buf , file_name);
}
f = FontFileOpen(buf);
if(f == NULL) {
fclose(file);
return NULL;
}
encoding = parseEncodingFile(f, 0);
FontFileClose(f);
break;
}
}
fclose(file);
return encoding;
}
/* Parser ntrypoint -- used by FontEncLoad */
FontEncPtr
FontEncReallyLoad(const char *charset, const char *fontFileName)
{
FontEncPtr encoding;
char dir[MAXFONTFILENAMELEN], dirname[MAXFONTFILENAMELEN];
char *d;
if(fontFileName) {
parseFontFileName(fontFileName, dirname, dir);
encoding = FontEncReallyReallyLoad(charset, dirname, dir);
if(encoding)
return(encoding);
}
d = FontEncDirectory();
if(d) {
parseFontFileName(d, NULL, dir);
encoding = FontEncReallyReallyLoad(charset, d, dir);
return encoding;
}
return NULL;
}
/* Return a NULL-terminated array of encoding names. Note that this
* function has incestuous knowledge of the allocations done by
* parseEncodingFile. */
char **
FontEncIdentify(const char *fileName)
{
FontFilePtr f;
FontEncPtr encoding;
char **names, **name, **alias;
int numaliases;
if((f = FontFileOpen(fileName))==NULL) {
return NULL;
}
encoding = parseEncodingFile(f, 1);
FontFileClose(f);
if(!encoding)
return NULL;
numaliases = 0;
if(encoding->aliases)
for(alias = encoding->aliases; *alias; alias++)
numaliases++;
names = malloc((numaliases+2)*sizeof(char*));
if(names == NULL) {
free(encoding->aliases);
free(encoding);
return NULL;
}
name = names;
*(name++) = encoding->name;
if(numaliases > 0)
for(alias = encoding->aliases; *alias; alias++, name++)
*name = *alias;
*name = NULL;
free(encoding->aliases);
free(encoding);
return names;
}
libfontenc-1.1.2/src/fontenc.c 0000644 0000000 0000000 00000071466 12136374753 0016254 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 1998-2001 by Juliusz Chroboczek
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
/* Backend-independent encoding code */
#include <string.h>
#include <strings.h>
#include <stdlib.h>
#define FALSE 0
#define TRUE 1
#define MAXFONTNAMELEN 1024
#define MAXFONTFILENAMELEN 1024
#include <X11/fonts/fontenc.h>
#include "fontencI.h"
/* Functions local to this file */
static FontEncPtr FontEncLoad(const char*, const char*);
/* Early versions of this code only knew about hardwired encodings,
hence the following data. Now that the code knows how to load an
encoding from a file, most of these tables could go away. */
/* At any rate, no new hardcoded encodings will be added. */
static FontMapRec iso10646[]=
{
{FONT_ENCODING_UNICODE,0,0,NULL,NULL,NULL,NULL,NULL},
{0,0,0,NULL,NULL,NULL,NULL,NULL}
};
/* Notice that the Apple encodings do not have all the characters in
the corresponding ISO 8859, and therefore the table has some holes.
There's not much more we can do with fonts without a Unicode cmap
unless we are willing to combine cmaps (which we are not). */
static const unsigned short
iso8859_1_apple_roman[]=
{ 0xCA, 0xC1, 0xA2, 0xA3, 0xDB, 0xB4, 0x00, 0xA4,
0xAC, 0xA9, 0xBB, 0xC7, 0xC2, 0x00, 0xA8, 0xF8,
0xA1, 0xB1, 0x00, 0x00, 0xAB, 0xB5, 0xA6, 0xE1,
0xFC, 0x00, 0xBC, 0xC8, 0x00, 0x00, 0x00, 0xC0,
0xCB, 0xE7, 0xE5, 0xCC, 0x80, 0x81, 0xAE, 0x82,
0xE9, 0x83, 0xE6, 0xE8, 0xED, 0xEA, 0xEB, 0xEC,
0x00, 0x84, 0xF1, 0xEE, 0xEF, 0xCD, 0x85, 0x00,
0xAF, 0xF4, 0xF2, 0xF3, 0x86, 0x00, 0x00, 0xA7,
0x88, 0x87, 0x89, 0x8B, 0x8A, 0x8C, 0xBE, 0x8D,
0x8F, 0x8E, 0x90, 0x91, 0x93, 0x92, 0x94, 0x95,
0x00, 0x96, 0x98, 0x97, 0x99, 0x9B, 0x9A, 0xD6,
0xBF, 0x9D, 0x9C, 0x9E, 0x9F, 0x00, 0x00, 0xD8 };
/* Cannot use simple_recode because need to eliminate 0x80<=code<0xA0 */
static unsigned
iso8859_1_to_apple_roman(unsigned isocode, void *client_data)
{
if(isocode<=0x80)
return isocode;
else if(isocode>=0xA0)
return iso8859_1_apple_roman[isocode-0xA0];
else
return 0;
}
static FontMapRec iso8859_1[]=
{
{FONT_ENCODING_TRUETYPE,2,2,NULL,NULL,NULL,NULL,NULL}, /* ISO 8859-1 */
{FONT_ENCODING_UNICODE,0,0,NULL,NULL,NULL,NULL,NULL}, /* ISO 8859-1 coincides with Unicode*/
{FONT_ENCODING_TRUETYPE,1,0,iso8859_1_to_apple_roman,NULL,NULL,NULL,NULL},
{0,0,0,NULL,NULL,NULL,NULL,NULL}
};
static const unsigned short iso8859_2_tophalf[]=
{ 0x00A0, 0x0104, 0x02D8, 0x0141, 0x00A4, 0x013D, 0x015A, 0x00A7,
0x00A8, 0x0160, 0x015E, 0x0164, 0x0179, 0x00AD, 0x017D, 0x017B,
0x00B0, 0x0105, 0x02DB, 0x0142, 0x00B4, 0x013E, 0x015B, 0x02C7,
0x00B8, 0x0161, 0x015F, 0x0165, 0x017A, 0x02DD, 0x017E, 0x017C,
0x0154, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0139, 0x0106, 0x00C7,
0x010C, 0x00C9, 0x0118, 0x00CB, 0x011A, 0x00CD, 0x00CE, 0x010E,
0x0110, 0x0143, 0x0147, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x00D7,
0x0158, 0x016E, 0x00DA, 0x0170, 0x00DC, 0x00DD, 0x0162, 0x00DF,
0x0155, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x013A, 0x0107, 0x00E7,
0x010D, 0x00E9, 0x0119, 0x00EB, 0x011B, 0x00ED, 0x00EE, 0x010F,
0x0111, 0x0144, 0x0148, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x00F7,
0x0159, 0x016F, 0x00FA, 0x0171, 0x00FC, 0x00FD, 0x0163, 0x02D9 };
static FontEncSimpleMapRec iso8859_2_to_unicode_map=
{0x60, 0, 0xA0, iso8859_2_tophalf };
static const unsigned short iso8859_2_apple_centeuro[]=
{ 0xCA, 0x84, 0x00, 0xFC, 0x00, 0xBB, 0xE5, 0xA4,
0xAC, 0xE1, 0x00, 0xE8, 0x8F, 0x00, 0xEB, 0xFB,
0xA1, 0x88, 0x00, 0xB8, 0x00, 0xBC, 0xE6, 0xFF,
0x00, 0xE4, 0x00, 0xE9, 0x90, 0x00, 0xEC, 0xFD,
0xD9, 0xE7, 0x00, 0x00, 0x80, 0xBD, 0x8C, 0x00,
0x89, 0x83, 0xA2, 0x00, 0x9D, 0xEA, 0x00, 0x91,
0x00, 0xC1, 0xC5, 0xEE, 0xEF, 0xCC, 0x85, 0x00,
0xDB, 0xF1, 0xF2, 0xF4, 0x86, 0xF8, 0x00, 0xA7,
0xDA, 0x87, 0x00, 0x00, 0x8A, 0xBE, 0x8D, 0x00,
0x8B, 0x8E, 0xAB, 0x00, 0x9E, 0x92, 0x00, 0x93,
0x00, 0xC4, 0xCB, 0x97, 0x99, 0xCE, 0x9A, 0xD6,
0xDE, 0xF3, 0x9C, 0xF5, 0x9F, 0xF9, 0x00, 0x00 };
static unsigned
iso8859_2_to_apple_centeuro(unsigned isocode, void *client_data)
{
if(isocode<=0x80)
return isocode;
else if(isocode>=0xA0)
return iso8859_2_apple_centeuro[isocode-0xA0];
else
return 0;
}
static FontMapRec iso8859_2[]=
{
{FONT_ENCODING_UNICODE,0,0,
FontEncSimpleRecode,NULL,&iso8859_2_to_unicode_map,NULL,NULL},
{FONT_ENCODING_TRUETYPE,1,29,iso8859_2_to_apple_centeuro,NULL,NULL,NULL,NULL},
{0,0,0,NULL,NULL,NULL,NULL,NULL}
};
static const unsigned short iso8859_3_tophalf[]=
{ 0x00A0, 0x0126, 0x02D8, 0x00A3, 0x00A4, 0x0000, 0x0124, 0x00A7,
0x00A8, 0x0130, 0x015E, 0x011E, 0x0134, 0x00AD, 0x0000, 0x017B,
0x00B0, 0x0127, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x0125, 0x00B7,
0x00B8, 0x0131, 0x015F, 0x011F, 0x0135, 0x00BD, 0x0000, 0x017C,
0x00C0, 0x00C1, 0x00C2, 0x0000, 0x00C4, 0x010A, 0x0108, 0x00C7,
0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
0x0000, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x0120, 0x00D6, 0x00D7,
0x011C, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x016C, 0x015C, 0x00DF,
0x00E0, 0x00E1, 0x00E2, 0x0000, 0x00E4, 0x010B, 0x0109, 0x00E7,
0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
0x0000, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x0121, 0x00F6, 0x00F7,
0x011D, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x016D, 0x015D, 0x02D9};
static FontEncSimpleMapRec iso8859_3_to_unicode_map=
{ 0x60, 0, 0xA0, iso8859_3_tophalf };
static FontMapRec iso8859_3[]=
{
{FONT_ENCODING_UNICODE,0,0,
FontEncSimpleRecode,NULL,&iso8859_3_to_unicode_map,NULL,NULL},
{0,0,0,NULL,NULL,NULL,NULL,NULL}
};
static const unsigned short iso8859_4_tophalf[]=
{ 0x00A0, 0x0104, 0x0138, 0x0156, 0x00A4, 0x0128, 0x013B, 0x00A7,
0x00A8, 0x0160, 0x0112, 0x0122, 0x0166, 0x00AD, 0x017D, 0x00AF,
0x00B0, 0x0105, 0x02DB, 0x0157, 0x00B4, 0x0129, 0x013C, 0x02C7,
0x00B8, 0x0161, 0x0113, 0x0123, 0x0167, 0x014A, 0x017E, 0x014B,
0x0100, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x012E,
0x010C, 0x00C9, 0x0118, 0x00CB, 0x0116, 0x00CD, 0x00CE, 0x012A,
0x0110, 0x0145, 0x014C, 0x0136, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
0x00D8, 0x0172, 0x00DA, 0x00DB, 0x00DC, 0x0168, 0x016A, 0x00DF,
0x0101, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x012F,
0x010D, 0x00E9, 0x0119, 0x00EB, 0x0117, 0x00ED, 0x00EE, 0x012B,
0x0111, 0x0146, 0x014D, 0x0137, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
0x00F8, 0x0173, 0x00FA, 0x00FB, 0x00FC, 0x0169, 0x016B, 0x02D9,
};
static FontEncSimpleMapRec iso8859_4_to_unicode_map=
{ 0x60, 0, 0xA0, iso8859_4_tophalf };
static FontMapRec iso8859_4[]=
{
{FONT_ENCODING_UNICODE,0,0,FontEncSimpleRecode,NULL,
&iso8859_4_to_unicode_map,NULL,NULL},
{0,0,0,NULL,NULL,NULL,NULL,NULL}
};
static const unsigned short iso8859_5_tophalf[]=
{ 0x00A0, 0x0401, 0x0402, 0x0403, 0x0404, 0x0405, 0x0406, 0x0407,
0x0408, 0x0409, 0x040A, 0x040B, 0x040C, 0x00AD, 0x040E, 0x040F,
0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417,
0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427,
0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
0x2116, 0x0451, 0x0452, 0x0453, 0x0454, 0x0455, 0x0456, 0x0457,
0x0458, 0x0459, 0x045A, 0x045B, 0x045C, 0x00A7, 0x045E, 0x045F};
static FontEncSimpleMapRec iso8859_5_to_unicode_map=
{ 0x60, 0, 0xA0, iso8859_5_tophalf };
static const unsigned short
iso8859_5_apple_cyrillic[]=
{ 0xCA, 0xDD, 0xAB, 0xAE, 0xB8, 0xC1, 0xA7, 0xBA,
0xB7, 0xBC, 0xBE, 0xCB, 0xCD, 0x00, 0xD8, 0xDA,
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xDF,
0xDC, 0xDE, 0xAC, 0xAF, 0xB9, 0xCF, 0xB4, 0xBB,
0xC0, 0xBD, 0xBF, 0xCC, 0xCE, 0xA4, 0xD9, 0xDB };
static unsigned
iso8859_5_to_apple_cyrillic(unsigned isocode, void *client_data)
{
if(isocode<=0x80)
return isocode;
else if(isocode>=0xA0)
return iso8859_5_apple_cyrillic[isocode-0x80];
else return 0;
}
static FontMapRec iso8859_5[]=
{
{FONT_ENCODING_UNICODE,0,0,FontEncSimpleRecode,NULL,
&iso8859_5_to_unicode_map,NULL,NULL},
{FONT_ENCODING_TRUETYPE,1,7,iso8859_5_to_apple_cyrillic,NULL,NULL,NULL,NULL},
{0,0,0,NULL,NULL,NULL,NULL,NULL}
};
/* ISO 8859-6 seems useless for serving fonts (not enough presentation
* forms). What do Arabic-speakers use? */
static unsigned
iso8859_6_to_unicode(unsigned isocode, void *client_data)
{
if(isocode<=0xA0 || isocode==0xA4 || isocode==0xAD)
return isocode;
else if(isocode==0xAC || isocode==0xBB ||
isocode==0xBF ||
(isocode>=0xC1 && isocode<=0xDA) ||
(isocode>=0xE0 && isocode<=0xEF) ||
(isocode>=0xF0 && isocode<=0xF2))
return isocode-0xA0+0x0600;
else
return 0;
}
static FontMapRec iso8859_6[]=
{
{FONT_ENCODING_UNICODE,0,0,iso8859_6_to_unicode,NULL,NULL,NULL,NULL},
{0,0,0,NULL,NULL,NULL,NULL,NULL}
};
static unsigned
iso8859_7_to_unicode(unsigned isocode, void *client_data)
{
if(isocode<=0xA0 ||
(isocode>=0xA3 && isocode<=0xAD) ||
(isocode>=0xB0 && isocode<=0xB3) ||
isocode==0xB7 || isocode==0xBB || isocode==0xBD)
return isocode;
else if(isocode==0xA1)
return 0x02BD;
else if(isocode==0xA2)
return 0x02BC;
else if(isocode==0xAF)
return 0x2015;
else if(isocode==0xD2) /* unassigned */
return 0;
else if(isocode>=0xB4)
return isocode-0xA0+0x0370;
else
return 0;
}
static FontMapRec iso8859_7[]=
{
{FONT_ENCODING_UNICODE,0,0,iso8859_7_to_unicode,NULL,NULL,NULL,NULL},
{0,0,0,NULL,NULL,NULL,NULL,NULL}
};
static unsigned
iso8859_8_to_unicode(unsigned isocode, void *client_data)
{
if(isocode==0xA1)
return 0;
else if(isocode<0xBF)
return isocode;
else if(isocode==0xDF)
return 0x2017;
else if(isocode>=0xE0 && isocode<=0xFA)
return isocode+0x04F0;
else
return 0;
}
static FontMapRec iso8859_8[]=
{
{FONT_ENCODING_UNICODE,0,0,iso8859_8_to_unicode,NULL,NULL,NULL,NULL},
{0,0,0,NULL,NULL,NULL,NULL,NULL}
};
static unsigned
iso8859_9_to_unicode(unsigned isocode, void *client_data)
{
switch(isocode) {
case 0xD0: return 0x011E;
case 0xDD: return 0x0130;
case 0xDE: return 0x015E;
case 0xF0: return 0x011F;
case 0xFD: return 0x0131;
case 0xFE: return 0x015F;
default: return isocode;
}
}
static FontMapRec iso8859_9[]=
{
{FONT_ENCODING_UNICODE,0,0,iso8859_9_to_unicode,NULL,NULL,NULL,NULL},
{0,0,0,NULL,NULL,NULL,NULL,NULL}
};
static const unsigned short iso8859_10_tophalf[]=
{ 0x00A0, 0x0104, 0x0112, 0x0122, 0x012A, 0x0128, 0x0136, 0x00A7,
0x013B, 0x0110, 0x0160, 0x0166, 0x017D, 0x00AD, 0x016A, 0x014A,
0x00B0, 0x0105, 0x0113, 0x0123, 0x012B, 0x0129, 0x0137, 0x00B7,
0x013C, 0x0111, 0x0161, 0x0167, 0x017E, 0x2014, 0x016B, 0x014B,
0x0100, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x012E,
0x010C, 0x00C9, 0x0118, 0x00CB, 0x0116, 0x00CD, 0x00CE, 0x00CF,
0x00D0, 0x0145, 0x014C, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x0168,
0x00D8, 0x0172, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
0x0101, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x012F,
0x010D, 0x00E9, 0x0119, 0x00EB, 0x0117, 0x00ED, 0x00EE, 0x00EF,
0x00F0, 0x0146, 0x014D, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x0169,
0x00F8, 0x0173, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x0138};
static FontEncSimpleMapRec iso8859_10_to_unicode_map=
{ 0x60, 0, 0xA0, iso8859_10_tophalf };
static FontMapRec iso8859_10[]=
{
{FONT_ENCODING_UNICODE,0,0,FontEncSimpleRecode,NULL,
&iso8859_10_to_unicode_map,NULL,NULL},
{0,0,0,NULL,NULL,NULL,NULL,NULL}
};
static unsigned
iso8859_15_to_unicode(unsigned isocode, void *client_data)
{
switch(isocode) {
case 0xA4: return 0x20AC;
case 0xA6: return 0x0160;
case 0xA8: return 0x0161;
case 0xB4: return 0x017D;
case 0xB8: return 0x017E;
case 0xBC: return 0x0152;
case 0xBD: return 0x0153;
case 0xBE: return 0x0178;
default: return isocode;
}
}
static FontMapRec iso8859_15[]=
{
{FONT_ENCODING_UNICODE,0,0,iso8859_15_to_unicode,NULL,NULL,NULL,NULL},
{0,0,0,NULL,NULL,NULL,NULL,NULL}
};
static const unsigned short koi8_r_tophalf[]=
{ 0x2500, 0x2502, 0x250C, 0x2510, 0x2514, 0x2518, 0x251C, 0x2524,
0x252C, 0x2534, 0x253C, 0x2580, 0x2584, 0x2588, 0x258C, 0x2590,
0x2591, 0x2592, 0x2593, 0x2320, 0x25A0, 0x2022, 0x221A, 0x2248,
0x2264, 0x2265, 0x00A0, 0x2321, 0x00B0, 0x00B2, 0x00B7, 0x00F7,
0x2550, 0x2551, 0x2552, 0x0451, 0x2553, 0x2554, 0x2555, 0x2556,
0x2557, 0x2558, 0x2559, 0x255A, 0x255B, 0x255C, 0x255D, 0x255E,
0x255F, 0x2560, 0x2561, 0x0401, 0x2562, 0x2563, 0x2564, 0x2565,
0x2566, 0x2567, 0x2568, 0x2569, 0x256A, 0x256B, 0x256C, 0x00A9,
0x044E, 0x0430, 0x0431, 0x0446, 0x0434, 0x0435, 0x0444, 0x0433,
0x0445, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E,
0x043F, 0x044F, 0x0440, 0x0441, 0x0442, 0x0443, 0x0436, 0x0432,
0x044C, 0x044B, 0x0437, 0x0448, 0x044D, 0x0449, 0x0447, 0x044A,
0x042E, 0x0410, 0x0411, 0x0426, 0x0414, 0x0415, 0x0424, 0x0413,
0x0425, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E,
0x041F, 0x042F, 0x0420, 0x0421, 0x0422, 0x0423, 0x0416, 0x0412,
0x042C, 0x042B, 0x0417, 0x0428, 0x042D, 0x0429, 0x0427, 0x042A};
static FontEncSimpleMapRec koi8_r_to_unicode_map=
{ 0x80, 0, 0x80, koi8_r_tophalf };
static FontMapRec koi8_r[]=
{
{FONT_ENCODING_UNICODE,0,0,FontEncSimpleRecode,NULL,
&koi8_r_to_unicode_map,NULL,NULL},
{0,0,0,NULL,NULL,NULL,NULL,NULL}
};
static unsigned
koi8_ru_to_unicode(unsigned koicode, void *client_data)
{
switch(koicode) {
case 0x93: return 0x201C;
case 0x96: return 0x201D;
case 0x97: return 0x2014;
case 0x98: return 0x2116;
case 0x99: return 0x2122;
case 0x9B: return 0x00BB;
case 0x9C: return 0x00AE;
case 0x9D: return 0x00AB;
case 0x9F: return 0x00A4;
case 0xA4: return 0x0454;
case 0xA6: return 0x0456;
case 0xA7: return 0x0457;
case 0xAD: return 0x0491;
case 0xAE: return 0x045E;
case 0xB4: return 0x0404;
case 0xB6: return 0x0406;
case 0xB7: return 0x0407;
case 0xBD: return 0x0490;
case 0xBE: return 0x040E;
default: return FontEncSimpleRecode(koicode, &koi8_r_to_unicode_map);
}
}
static FontMapRec koi8_ru[]=
{
{FONT_ENCODING_UNICODE,0,0,koi8_ru_to_unicode,NULL,NULL,NULL,NULL},
{0,0,0,NULL,NULL,NULL,NULL,NULL}
};
/* koi8-e, ISO-IR-111 or ECMA-Cyrillic */
static const unsigned short koi8_e_A0_BF[]=
{ 0x00A0, 0x0452, 0x0453, 0x0451, 0x0454, 0x0455, 0x0456, 0x0457,
0x0458, 0x0459, 0x045A, 0x045B, 0x045C, 0x00AD, 0x045E, 0x045F,
0x2116, 0x0402, 0x0403, 0x0401, 0x0404, 0x0405, 0x0406, 0x0407,
0x0408, 0x0409, 0x040A, 0x040B, 0x040C, 0x00A4, 0x040E, 0x040F };
static unsigned
koi8_e_to_unicode(unsigned koicode, void *client_data)
{
if(koicode<0xA0)
return koicode;
else if(koicode<0xC0)
return koi8_e_A0_BF[koicode-0xA0];
else
return FontEncSimpleRecode(koicode, &koi8_r_to_unicode_map);
}
static FontMapRec koi8_e[]=
{
{FONT_ENCODING_UNICODE,0,0,koi8_e_to_unicode,NULL,NULL,NULL,NULL},
{0,0,0,NULL,NULL,NULL,NULL,NULL}
};
/* Koi8 unified */
static const unsigned short koi8_uni_80_BF[]=
{ 0x2500, 0x2502, 0x250C, 0x2510, 0x2514, 0x2518, 0x251C, 0x2524,
0x252C, 0x2534, 0x253C, 0x2580, 0x2584, 0x2588, 0x258C, 0x2590,
0x2591, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
0x00A9, 0x2122, 0x00A0, 0x00BB, 0x00AE, 0x00AB, 0x00B7, 0x00A4,
0x00A0, 0x0452, 0x0453, 0x0451, 0x0454, 0x0455, 0x0456, 0x0457,
0x0458, 0x0459, 0x045A, 0x045B, 0x045C, 0x0491, 0x045E, 0x045F,
0x2116, 0x0402, 0x0403, 0x0401, 0x0404, 0x0405, 0x0406, 0x0407,
0x0408, 0x0409, 0x040A, 0x040B, 0x040C, 0x0490, 0x040E, 0x040F };
static unsigned
koi8_uni_to_unicode(unsigned koicode, void *client_data)
{
if(koicode<0x80)
return koicode;
else if(koicode<0xC0)
return koi8_uni_80_BF[koicode-0x80];
else
return FontEncSimpleRecode(koicode, &koi8_r_to_unicode_map);
}
static FontMapRec koi8_uni[]=
{
{FONT_ENCODING_UNICODE,0,0,koi8_uni_to_unicode,NULL,NULL,NULL,NULL},
{0,0,0,NULL,NULL,NULL,NULL,NULL}
};
/* Ukrainian variant of Koi8-R; see RFC 2319 */
static unsigned
koi8_u_to_unicode(unsigned koicode, void *client_data)
{
switch(koicode) {
case 0xA4: return 0x0454;
case 0xA6: return 0x0456;
case 0xA7: return 0x0457;
case 0xAD: return 0x0491;
case 0xB4: return 0x0404;
case 0xB6: return 0x0406;
case 0xB7: return 0x0407;
case 0xBD: return 0x0490;
default: return FontEncSimpleRecode(koicode, &koi8_r_to_unicode_map);
}
}
static FontMapRec koi8_u[]=
{
{FONT_ENCODING_UNICODE,0,0,koi8_u_to_unicode,NULL,NULL,NULL},
{0,0,0,NULL,NULL,NULL,NULL,NULL}
};
/* Microsoft Symbol, which is only meaningful for TrueType fonts, is
treated specially in ftenc.c, where we add usFirstCharIndex-0x20 to
the glyph index before applying the cmap. Lovely design. */
static FontMapRec microsoft_symbol[]=
{{FONT_ENCODING_TRUETYPE,3,0,NULL,NULL,NULL,NULL,NULL},
/* You never know */
{FONT_ENCODING_TRUETYPE,3,1,NULL,NULL,NULL,NULL,NULL},
{0,0,0,NULL,NULL,NULL,NULL,NULL}};
static FontMapRec apple_roman[]=
{{FONT_ENCODING_TRUETYPE,1,0,NULL,NULL,NULL,NULL,NULL},
{0,0,0,NULL,NULL,NULL,NULL,NULL}};
/* The data for recodings */
/* For compatibility with X11R6.4. Losers. */
static char *iso8859_15_aliases[2]={"fcd8859-15",NULL};
static FontEncRec initial_encodings[]=
{
{"iso10646-1",NULL,256*256,0,iso10646,NULL,0,0}, /* Unicode */
{"iso8859-1",NULL,256,0,iso8859_1,NULL,0,0}, /* Latin 1 (West European) */
{"iso8859-2",NULL,256,0,iso8859_2,NULL,0,0}, /* Latin 2 (East European) */
{"iso8859-3",NULL,256,0,iso8859_3,NULL,0,0}, /* Latin 3 (South European) */
{"iso8859-4",NULL,256,0,iso8859_4,NULL,0,0}, /* Latin 4 (North European) */
{"iso8859-5",NULL,256,0,iso8859_5,NULL,0,0}, /* Cyrillic */
{"iso8859-6",NULL,256,0,iso8859_6,NULL,0,0}, /* Arabic */
{"iso8859-7",NULL,256,0,iso8859_7,NULL,0,0}, /* Greek */
{"iso8859-8",NULL,256,0,iso8859_8,NULL,0,0}, /* Hebrew */
{"iso8859-9",NULL,256,0,iso8859_9,NULL,0,0}, /* Latin 5 (Turkish) */
{"iso8859-10",NULL,256,0,iso8859_10,NULL,0,0}, /* Latin 6 (Nordic) */
{"iso8859-15",iso8859_15_aliases,256,0,iso8859_15,NULL,0,0}, /* Latin 9 */
{"koi8-r",NULL,256,0,koi8_r,NULL,0,0}, /* Russian */
{"koi8-ru",NULL,256,0,koi8_ru,NULL,0,0}, /* Ukrainian */
{"koi8-uni",NULL,256,0,koi8_uni,NULL,0,0}, /* Russian/Ukrainian/Bielorussian */
{"koi8-e",NULL,256,0,koi8_e,NULL,0,0}, /* ``European'' */
{"koi8-u",NULL,256,0,koi8_u,NULL,0,0}, /* Ukrainian too */
{"microsoft-symbol",NULL,256,0,microsoft_symbol,NULL,0,0},
{"apple-roman",NULL,256,0,apple_roman,NULL,0,0},
{NULL,NULL,0,0,NULL,NULL,0,0}
};
static FontEncPtr font_encodings=NULL;
static void
define_initial_encoding_info(void)
{
FontEncPtr encoding;
FontMapPtr mapping;
font_encodings = initial_encodings;
for(encoding = font_encodings; ; encoding++) {
encoding->next = encoding + 1;
for(mapping = encoding->mappings; ; mapping++) {
mapping->next = mapping+1;
mapping->encoding = encoding;
if(mapping->next->type == 0) {
mapping->next = NULL;
break;
}
}
if(!encoding->next->name) {
encoding->next = NULL;
break;
}
}
}
char*
FontEncFromXLFD(const char *name, int length)
{
const char *p;
char *q;
static char charset[MAXFONTNAMELEN];
int len;
if(length > MAXFONTNAMELEN - 1)
return NULL;
if(name == NULL)
p = NULL;
else {
p = name + length - 1;
while(p > name && *p != '-')
p--;
p--;
while(p >= name && *p != '-')
p--;
if(p <= name)
p = NULL;
}
/* now p either is null or points at the '-' before the charset registry */
if(p == NULL)
return NULL;
len = length - (p - name) - 1;
memcpy(charset, p+1, len);
charset[len] = 0;
/* check for a subset specification */
if((q = strchr(charset, (int)'[')))
*q = 0;
return charset;
}
unsigned
FontEncRecode(unsigned code, FontMapPtr mapping)
{
FontEncPtr encoding = mapping->encoding;
if(encoding && mapping->recode) {
if(encoding->row_size == 0) {
/* linear encoding */
if(code < encoding->first || code>=encoding->size)
return 0;
} else {
/* matrix encoding */
int row = code/0x100, col = code&0xFF;
if(row < encoding->first || row >= encoding->size ||
col < encoding->first_col || col >= encoding->row_size)
return 0;
}
return (*mapping->recode)(code, mapping->client_data);
} else
return code;
}
char*
FontEncName(unsigned code, FontMapPtr mapping)
{
FontEncPtr encoding = mapping->encoding;
if(encoding && mapping->name) {
if((encoding->row_size == 0 && code >= encoding->size) ||
(encoding->row_size != 0 &&
(code/0x100 >= encoding->size ||
(code&0xFF) >= encoding->row_size)))
return NULL;
return (*mapping->name)(code, mapping->client_data);
} else
return NULL;
}
FontEncPtr
FontEncFind(const char *encoding_name, const char *filename)
{
FontEncPtr encoding;
char **alias;
if(font_encodings == NULL) define_initial_encoding_info();
for(encoding = font_encodings; encoding; encoding = encoding->next) {
if(!strcasecmp(encoding->name, encoding_name))
return encoding;
if(encoding->aliases)
for(alias=encoding->aliases; *alias; alias++)
if(!strcasecmp(*alias, encoding_name))
return encoding;
}
/* Unknown charset, try to load a definition file */
return FontEncLoad(encoding_name, filename);
}
FontMapPtr
FontMapFind(FontEncPtr encoding, int type, int pid, int eid)
{
FontMapPtr mapping;
if(encoding == NULL)
return NULL;
for(mapping = encoding->mappings; mapping; mapping = mapping->next) {
if(mapping->type != type)
continue;
if(pid > 0 && mapping->pid != pid)
continue;
if(eid > 0 && mapping->eid != eid)
continue;
return mapping;
}
return NULL;
}
FontMapPtr
FontEncMapFind(const char *encoding_name, int type, int pid, int eid,
const char *filename)
{
FontEncPtr encoding;
FontMapPtr mapping;
encoding = FontEncFind(encoding_name, filename);
if(encoding == NULL)
return NULL;
mapping = FontMapFind(encoding, type, pid, eid);
return mapping;
}
static FontEncPtr
FontEncLoad(const char *encoding_name, const char *filename)
{
FontEncPtr encoding;
encoding = FontEncReallyLoad(encoding_name, filename);
if (encoding == NULL) {
return NULL;
} else {
char **alias;
int found = 0;
/* Check whether the name is already known for this encoding */
if(strcasecmp(encoding->name, encoding_name) == 0) {
found = 1;
} else {
if(encoding->aliases) {
for(alias=encoding->aliases; *alias; alias++)
if(!strcasecmp(*alias, encoding_name)) {
found = 1;
break;
}
}
}
if(!found) {
/* Add a new alias. This works because we know that this
particular encoding has been allocated dynamically */
char **new_aliases;
char *new_name;
int numaliases = 0;
new_name = strdup(encoding_name);
if(new_name == NULL)
return NULL;
if(encoding->aliases) {
for(alias = encoding->aliases; *alias; alias++)
numaliases++;
}
new_aliases = malloc((numaliases+2)*sizeof(char*));
if(new_aliases == NULL) {
free(new_name);
return NULL;
}
if(encoding->aliases) {
memcpy(new_aliases, encoding->aliases, numaliases*sizeof(char*));
free(encoding->aliases);
}
new_aliases[numaliases] = new_name;
new_aliases[numaliases+1] = NULL;
encoding->aliases = new_aliases;
}
/* register the new encoding */
encoding->next=font_encodings;
font_encodings=encoding;
return encoding;
}
}
unsigned
FontEncSimpleRecode(unsigned code, void *client_data)
{
FontEncSimpleMapPtr map;
unsigned index;
map = client_data;
if(code > 0xFFFF || (map->row_size && (code&0xFF) >= map->row_size))
return 0;
if(map->row_size)
index = (code&0xFF)+(code>>8)*map->row_size;
else
index = code;
if(map->map && index>=map->first && index<map->first+map->len)
return map->map[index-map->first];
else
return code;
}
char *
FontEncSimpleName(unsigned code, void *client_data)
{
FontEncSimpleNamePtr map;
map = client_data;
if(map && code >= map->first && code<map->first+map->len)
return map->map[code-map->first];
else
return NULL;
}
unsigned
FontEncUndefinedRecode(unsigned code, void *client_data)
{
return code;
}
char *
FontEncUndefinedName(unsigned code, void *client_data)
{
return NULL;
}
#define FONTENC_SEGMENT_SIZE 256
#define FONTENC_SEGMENTS 256
#define FONTENC_INVERSE_CODES (FONTENC_SEGMENT_SIZE * FONTENC_SEGMENTS)
static unsigned int
reverse_reverse(unsigned i, void* data)
{
int s, j;
unsigned **map = (unsigned**)data;
if(i >= FONTENC_INVERSE_CODES)
return 0;
if(map == NULL)
return 0;
s = i / FONTENC_SEGMENT_SIZE;
j = i % FONTENC_SEGMENT_SIZE;
if(map[s] == NULL)
return 0;
else
return map[s][j];
}
static int
tree_set(unsigned int **map, unsigned int i, unsigned int j)
{
int s, c;
if(i >= FONTENC_INVERSE_CODES)
return FALSE;
s = i / FONTENC_SEGMENT_SIZE;
c = i % FONTENC_SEGMENT_SIZE;
if(map[s] == NULL) {
map[s] = calloc(FONTENC_SEGMENT_SIZE, sizeof(int));
if(map[s] == NULL)
return FALSE;
}
map[s][c] = j;
return TRUE;
}
FontMapReversePtr
FontMapReverse(FontMapPtr mapping)
{
FontEncPtr encoding = mapping->encoding;
FontMapReversePtr reverse = NULL;
unsigned int **map = NULL;
int i, j, k;
if(encoding == NULL) goto bail;
map = calloc(FONTENC_SEGMENTS, sizeof(int*));
if(map == NULL) goto bail;
if(encoding->row_size == 0) {
for(i = encoding->first; i < encoding->size; i++) {
k = FontEncRecode(i, mapping);
if(k != 0)
if(!tree_set(map, k, i))
goto bail;
}
} else {
for(i = encoding->first; i < encoding->size; i++) {
for(j = encoding->first_col; j < encoding->row_size; j++) {
k = FontEncRecode(i*256 + j, mapping);
if(k != 0)
if(!tree_set(map, k, i*256+j))
goto bail;
}
}
}
reverse = malloc(sizeof(FontMapReverseRec));
if(!reverse) goto bail;
reverse->reverse = reverse_reverse;
reverse->data = map;
return reverse;
bail:
free(map);
free(reverse);
return NULL;
}
void
FontMapReverseFree(FontMapReversePtr delendum)
{
unsigned int **map = (unsigned int**)delendum;
int i;
if(map == NULL)
return;
for(i = 0; i < FONTENC_SEGMENTS; i++)
free(map[i]);
free(map);
return;
}
libfontenc-1.1.2/src/fontencI.h 0000644 0000000 0000000 00000003406 12136374753 0016357 0 ustar 00root root 0000000 0000000 /*
Copyright (c) 1998-2001 by Juliusz Chroboczek
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
/* Private types and functions for the encoding code. */
/* Used by the files `fontenc.h' and `encparse.h' */
typedef struct _FontEncSimpleMap {
unsigned len; /* might be 0x10000 */
unsigned short row_size;
unsigned short first;
const unsigned short *map;
} FontEncSimpleMapRec, *FontEncSimpleMapPtr;
typedef struct _FontEncSimpleName {
unsigned len;
unsigned short first;
char **map;
} FontEncSimpleNameRec, *FontEncSimpleNamePtr;
unsigned FontEncSimpleRecode(unsigned, void*);
unsigned FontEncUndefinedRecode(unsigned, void*);
char *FontEncSimpleName(unsigned, void*);
char *FontEncUndefinedName(unsigned, void*);
FontEncPtr FontEncReallyLoad(const char*, const char*);