fontmap.c

Go to the documentation of this file.

/* encoding.c - functions to manipulate encodings and fontmaps */
/*
 * Copyright (C) 2000, Matias Atria
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#include <config.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <sys/stat.h>

#include "mdvi.h"
#include "private.h"

#include <kpathsea/expand.h>
#include <kpathsea/pathsearch.h>

typedef struct _DviFontMap DviFontMap;

struct _DviFontMap {
    ListHead entries;
    DviHashTable fonts;
};

typedef struct _PSFontMap {
    struct _PSFontMap *next;
    struct _PSFontMap *prev;
    char    *psname;
    char    *mapname;
    char    *fullname;
} PSFontMap;

/* these variables control PS font maps */
static char *pslibdir = NULL;   /* path where we look for PS font maps */
static char *psfontdir = NULL;  /* PS font search path */
static int psinitialized = 0;   /* did we expand the path already? */

static ListHead psfonts = MDVI_EMPTY_LIST_HEAD;
static DviHashTable pstable = MDVI_EMPTY_HASH_TABLE;

static ListHead fontmaps;
static DviHashTable maptable;
static int fontmaps_loaded = 0;

#define MAP_HASH_SIZE   57
#define ENC_HASH_SIZE   31
#define PSMAP_HASH_SIZE 57

/* this hash table should be big enough to 
 * hold (ideally) one glyph name per bucket */
#define ENCNAME_HASH_SIZE   131 /* most TeX fonts have 128 glyphs */

static ListHead encodings = MDVI_EMPTY_LIST_HEAD;
static DviEncoding *tex_text_encoding = NULL;
static DviEncoding *default_encoding = NULL;

/* we keep two hash tables for encodings: one for their base files (e.g.
 * "8r.enc"), and another one for their names (e.g. "TeXBase1Encoding") */ 
static DviHashTable enctable = MDVI_EMPTY_HASH_TABLE;
static DviHashTable enctable_file = MDVI_EMPTY_HASH_TABLE;

/* the TeX text encoding, from dvips */
static char *tex_text_vector[256] = {
    "Gamma", "Delta", "Theta", "Lambda", "Xi", "Pi", "Sigma", "Upsilon",
    "Phi", "Psi", "Omega", "arrowup", "arrowdown", "quotesingle",
    "exclamdown", "questiondown", "dotlessi", "dotlessj", "grave",
    "acute", "caron", "breve", "macron", "ring", "cedilla",
    "germandbls", "ae", "oe", "oslash", "AE", "OE", "Oslash", "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", "circumflex",
    "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", "tilde",
    "dieresis", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

static void ps_init_default_paths __PROTO((void));
static int  mdvi_set_default_encoding __PROTO((const char *name));
static int  mdvi_init_fontmaps __PROTO((void));

/* 
 * What we do here is allocate one block large enough to hold the entire
 * file (these files are small) minus the leading comments. This is much
 * better than allocating up to 256 tiny strings per encoding vector. */
static int read_encoding(DviEncoding *enc)
{
    FILE    *in;
    int curr;
    char    *line;
    char    *name;
    char    *next;
    struct stat st;
    
    ASSERT(enc->private == NULL);

    in = fopen(enc->filename, "rb");
    if(in == NULL) {
        DEBUG((DBG_FMAP, "%s: could not read `%s' (%s)\n",
            enc->name, enc->filename, strerror(errno)));
        return -1;
    }
    if(fstat(fileno(in), &st) < 0) {
        /* should not happen */
        fclose(in);
        return -1;
    }
    st.st_size -= enc->offset;

    /* this will be one big string */
    enc->private = (char *)malloc(st.st_size + 1);
    /* setup the hash table */
    mdvi_hash_create(&enc->nametab, ENCNAME_HASH_SIZE);
    /* setup the encoding vector */
    enc->vector = (char **)mdvi_malloc(256 * sizeof(char *));

    /* jump to the beginning of the interesting part */
    fseek(in, enc->offset, SEEK_SET);
    /* and read everything */
    if(fread(enc->private, st.st_size, 1, in) != 1) {
        fclose(in);
        mdvi_free(enc->private);
        enc->private = NULL;
        return -1;
    }
    /* we don't need this anymore */
    fclose(in);
    curr = 0;

    next = name = NULL;
    DEBUG((DBG_FMAP, "%s: reading encoding vector\n", enc->name));  
    for(line = enc->private; *line && curr < 256; line = next) {
        SKIPSP(line);
        if(*line == ']') {
            line++; SKIPSP(line);
            if(STRNEQ(line, "def", 3))
                break;
        }
        name = getword(line, " \t\n", &next);
        if(name == NULL)
            break;
        /* next > line */
        if(*name < ' ')
            continue;
        if(*name == '%') {
            while(*next && *next != '\n')
                next++;
            if(*next) next++; /* skip \n */
            continue;
        }

        /* got a name */
        if(*next) *next++ = 0;
        
        if(*name == '/')
            name++;
        enc->vector[curr] = name;
        /* add it to the hash table */
        if(!STREQ(name, ".notdef")) {
            mdvi_hash_add(&enc->nametab, MDVI_KEY(name), 
                Int2Ptr(curr + 1), MDVI_HASH_REPLACE);
        }
        curr++;
    }
    if(curr == 0) {
        mdvi_hash_reset(&enc->nametab, 0);
        mdvi_free(enc->private);
        mdvi_free(enc);
        return -1;
    }
    while(curr < 256)
        enc->vector[curr++] = NULL;
    return 0;
}

static DviEncoding *find_encoding(const char *name)
{
    return (DviEncoding *)(encodings.count ? 
        mdvi_hash_lookup(&enctable, MDVI_KEY(name)) : NULL);
}

static void destroy_encoding(DviEncoding *enc)
{
    if(enc == default_encoding) {
        default_encoding = tex_text_encoding;
        /* now we use reference counts again */
        mdvi_release_encoding(enc, 1);
    }
    if(enc != tex_text_encoding) {
        mdvi_hash_reset(&enc->nametab, 0);
        if(enc->private) {
            mdvi_free(enc->private);
            mdvi_free(enc->vector);
        }
        if(enc->name)
            mdvi_free(enc->name);
        if(enc->filename)
            mdvi_free(enc->filename);
        mdvi_free(enc);
    }
}

/* this is used for the `enctable_file' hash table */
static void file_hash_free(DviHashKey key, void *data)
{
    mdvi_free(key);
}

static DviEncoding *register_encoding(const char *basefile, int replace)
{
    DviEncoding *enc;
    FILE    *in;
    char    *filename;
    char    *name;
    Dstring input;
    char    *line;
    long    offset;

    DEBUG((DBG_FMAP, "register_encoding(%s)\n", basefile));

    if(encodings.count) {
        enc = mdvi_hash_lookup(&enctable_file, MDVI_KEY(basefile));
        if(enc != NULL) {
            DEBUG((DBG_FMAP, "%s: already there\n", basefile));
            return enc; /* no error */
        }
    } 

    /* try our own files first */
    filename = kpse_find_file(basefile, 
        kpse_program_text_format, 0);

    /* then try the system-wide ones */
    if(filename == NULL)
        filename = kpse_find_file(basefile, 
            kpse_tex_ps_header_format, 0);
    if(filename == NULL)
        filename = kpse_find_file(basefile,
            kpse_dvips_config_format, 0);

    /* finally try the given name */
    if(filename == NULL)
        filename = mdvi_strdup(basefile);

    in = fopen(filename, "rb");
    if(in == NULL) {
        mdvi_free(filename);
        return NULL;
    }
    
    /* just lookup the name of the encoding */
    name = NULL;
    dstring_init(&input);
    while((line = dgets(&input, in)) != NULL) {
        if(STRNEQ(line, "Encoding=", 9)) {
            name = getword(line + 9, " \t", &line);
            if(*line) *line++ = 0;
            break;
        } else if(*line == '/') {
            char    *label = getword(line + 1, " \t", &line);
            if(*line) {
                *line++ = 0;
                SKIPSP(line);
                if(*line == '[') {
                    *line = 0;
                    name = label;
                    break;
                }
            }
        }
    }
    offset = ftell(in);
    fclose(in);
    if(name == NULL || *name == 0) {
        DEBUG((DBG_FMAP, 
            "%s: could not determine name of encoding\n",
            basefile));
        mdvi_free(filename);
        return NULL;
    }
    
    /* check if the encoding is already there */
    enc = find_encoding(name);
    if(enc == tex_text_encoding) {
        /* A special case: if the vector we found is the static one,
         * allow the user to override it with an external file */
        listh_remove(&encodings, LIST(enc));
        mdvi_hash_remove(&enctable, MDVI_KEY(enc->name));
        if(enc == default_encoding)
            default_encoding = NULL;
    } else if(enc) {
        /* if the encoding is being used, refuse to remove it */
        if(enc->links) {
            mdvi_free(filename);
            dstring_reset(&input);
            return NULL;
        }
        if(replace) {
            mdvi_hash_remove(&enctable, MDVI_KEY(name));
            mdvi_hash_remove(&enctable_file, MDVI_KEY(basefile));
            listh_remove(&encodings, LIST(enc));
            if(enc == default_encoding) {
                default_encoding = NULL;
                mdvi_release_encoding(enc, 1);
            }
            DEBUG((DBG_FMAP, "%s: overriding encoding\n", name));
            destroy_encoding(enc);
        } else {
            mdvi_free(filename);
            dstring_reset(&input);
            return enc; /* no error */
        }
    }
    enc = xalloc(DviEncoding);
    enc->name = mdvi_strdup(name);
    enc->filename = filename;
    enc->links = 0;
    enc->offset = offset;
    enc->private = NULL;
    enc->vector = NULL;
    mdvi_hash_init(&enc->nametab);
    dstring_reset(&input);
    if(default_encoding == NULL)
        default_encoding = enc;
    mdvi_hash_add(&enctable, MDVI_KEY(enc->name), 
        enc, MDVI_HASH_UNCHECKED);
    mdvi_hash_add(&enctable_file, MDVI_KEY(mdvi_strdup(basefile)), 
        enc, MDVI_HASH_REPLACE);
    listh_prepend(&encodings, LIST(enc));
    DEBUG((DBG_FMAP, "%s: encoding `%s' registered\n",
        basefile, enc->name));
    return enc;
}

DviEncoding *mdvi_request_encoding(const char *name)
{
    DviEncoding *enc = find_encoding(name);

    if(enc == NULL) {
        DEBUG((DBG_FMAP, "%s: encoding not found, returning default `%s'\n",
            name, default_encoding->name));
        return default_encoding;
    }
    /* we don't keep reference counts for this */
    if(enc == tex_text_encoding)
        return enc;
    if(!enc->private && read_encoding(enc) < 0)
        return NULL;
    enc->links++;

    /* if the hash table is empty, rebuild it */
    if(enc->nametab.nkeys == 0) {
        int i;

        DEBUG((DBG_FMAP, "%s: rehashing\n", enc->name));        
        for(i = 0; i < 256; i++) {
            if(enc->vector[i] == NULL)
                continue;
            mdvi_hash_add(&enc->nametab,
                MDVI_KEY(enc->vector[i]),
                (DviHashKey)Int2Ptr(i),
                MDVI_HASH_REPLACE);
        }
    }
    return enc;
}

void    mdvi_release_encoding(DviEncoding *enc, int should_free)
{
    /* ignore our static encoding */
    if(enc == tex_text_encoding)
        return;
    if(!enc->links || --enc->links > 0 || !should_free)
        return;
    DEBUG((DBG_FMAP, "%s: resetting encoding vector\n", enc->name));
    mdvi_hash_reset(&enc->nametab, 1); /* we'll reuse it */
}

int mdvi_encode_glyph(DviEncoding *enc, const char *name)
{
    void    *data;
    
    data = mdvi_hash_lookup(&enc->nametab, MDVI_KEY(name));
    if(data == NULL)
        return -1;
    /* we added +1 to the hashed index just to distinguish
     * a failed lookup from a zero index. Adjust it now. */
    return (Ptr2Int(data) - 1);
}

/****************
 * Fontmaps     *
 ****************/

static void parse_spec(DviFontMapEnt *ent, char *spec)
{
    char    *arg, *command;
    
    /* this is a ridiculously simple parser, and recognizes only
     * things of the form <argument> <command>. Of these, only
     * command=SlantFont, ExtendFont and ReEncodeFont are handled */
    while(*spec) {
        arg = getword(spec, " \t", &spec);
        if(*spec) *spec++ = 0;
        command = getword(spec, " \t", &spec);
        if(*spec) *spec++ = 0;
        if(!arg || !command)    
            continue;
        if(STREQ(command, "SlantFont")) {
            double  x = 10000 * strtod(arg, 0);
        
            /* SFROUND evaluates arguments twice */ 
            ent->slant = SFROUND(x);
        } else if(STREQ(command, "ExtendFont")) {
            double  x = 10000 * strtod(arg, 0);
            
            ent->extend = SFROUND(x);
        } else if(STREQ(command, "ReEncodeFont")) {
            if(ent->encoding)
                mdvi_free(ent->encoding);
            ent->encoding = mdvi_strdup(arg);
        }
    }
}

#if 0
static void print_ent(DviFontMapEnt *ent)
{
    printf("Entry for `%s':\n", ent->fontname);
    printf("  PS name: %s\n", ent->psname ? ent->psname : "(none)");
    printf("  Encoding: %s\n", ent->encoding ? ent->encoding : "(default)");
    printf("  EncFile: %s\n", ent->encfile ? ent->encfile : "(none)");
    printf("  FontFile: %s\n", ent->fontfile ? ent->fontfile : "(same)");
    printf("  Extend: %ld\n", ent->extend);
    printf("  Slant: %ld\n", ent->slant);
}
#endif

DviFontMapEnt   *mdvi_load_fontmap(const char *file)
{
    char    *ptr;
    FILE    *in;
    int lineno = 1;
    Dstring input;
    ListHead list;
    DviFontMapEnt *ent;
    DviEncoding *last_encoding;
    char    *last_encfile;

    ptr = kpse_find_file(file, kpse_program_text_format, 0);
    if(ptr == NULL)
        ptr = kpse_find_file(file, kpse_tex_ps_header_format, 0);
    if(ptr == NULL)
        ptr = kpse_find_file(file, kpse_dvips_config_format, 0);
    if(ptr == NULL)
        in = fopen(file, "rb");
    else {
        in = fopen(ptr, "rb");
        mdvi_free(ptr);
    }
    if(in == NULL)
        return NULL;
        
    ent = NULL;
    listh_init(&list);
    dstring_init(&input);
    last_encoding = NULL;
    last_encfile  = NULL;
        
    while((ptr = dgets(&input, in)) != NULL) {
        char    *font_file;
        char    *tex_name;
        char    *ps_name;
        char    *vec_name;
        int is_encoding;
        DviEncoding *enc;

        lineno++;
        SKIPSP(ptr);
        
        /* we skip what dvips does */
        if(*ptr <= ' ' || *ptr == '*' || *ptr == '#' || 
           *ptr == ';' || *ptr == '%')
            continue;
            
        font_file   = NULL;
        tex_name    = NULL;
        ps_name     = NULL;
        vec_name    = NULL;
        is_encoding = 0;

        if(ent == NULL) {
            ent = xalloc(DviFontMapEnt);
            ent->encoding = NULL;
            ent->slant = 0;
            ent->extend = 0;
        }
        while(*ptr) {
            char    *hdr_name = NULL;
            
            while(*ptr && *ptr <= ' ')
                ptr++;
            if(*ptr == 0)
                break;
            if(*ptr == '"') {
                char    *str;
                
                str = getstring(ptr, " \t", &ptr);
                if(*ptr) *ptr++ = 0;
                parse_spec(ent, str);
                continue;
            } else if(*ptr == '<') {
                ptr++;
                if(*ptr == '<')
                    ptr++;
                else if(*ptr == '[') {
                    is_encoding = 1;
                    ptr++;
                }
                SKIPSP(ptr);
                hdr_name = ptr;
            } else if(!tex_name)
                tex_name = ptr;
            else if(!ps_name)
                ps_name = ptr;
            else
                hdr_name = ptr;

            /* get next word */
            getword(ptr, " \t", &ptr);
            if(*ptr) *ptr++ = 0;

            if(hdr_name) {
                const char *ext = file_extension(hdr_name);
                
                if(is_encoding || (ext && STRCEQ(ext, "enc")))
                    vec_name = hdr_name;
                else
                    font_file = hdr_name;
            }
        }

        if(tex_name == NULL)
            continue;
        ent->fontname = mdvi_strdup(tex_name);
        ent->psname   = ps_name   ? mdvi_strdup(ps_name)   : NULL;
        ent->fontfile = font_file ? mdvi_strdup(font_file) : NULL;
        ent->encfile  = vec_name  ? mdvi_strdup(vec_name)  : NULL;
        ent->fullfile = NULL;
        enc = NULL; /* we don't have this yet */

        /* if we have an encoding file, register it */
        if(ent->encfile) {
            /* register_encoding is smart enough not to load the 
             * same file twice */
            if(!last_encfile || !STREQ(last_encfile, ent->encfile)) {
                last_encfile  = ent->encfile;
                last_encoding = register_encoding(ent->encfile, 1);
            }
            enc = last_encoding;
        }
        if(ent->encfile && enc){        
            if(ent->encoding && !STREQ(ent->encoding, enc->name)) {
                mdvi_warning(
    _("%s: %d: [%s] requested encoding `%s' does not match vector `%s'\n"),
                    file, lineno, ent->encfile,
                    ent->encoding, enc->name);
            } else if(!ent->encoding)
                ent->encoding = mdvi_strdup(enc->name);
        }
        
        /* add it to the list */
        /*print_ent(ent);*/
        listh_append(&list, LIST(ent));
        ent = NULL;
    }
    dstring_reset(&input);  
    fclose(in);
    
    return (DviFontMapEnt *)list.head;
}

static void free_ent(DviFontMapEnt *ent)
{
    ASSERT(ent->fontname != NULL);
    mdvi_free(ent->fontname);
    if(ent->psname)
        mdvi_free(ent->psname);
    if(ent->fontfile)
        mdvi_free(ent->fontfile);
    if(ent->encoding)
        mdvi_free(ent->encoding);
    if(ent->encfile)
        mdvi_free(ent->encfile);
    if(ent->fullfile)
        mdvi_free(ent->fullfile);
    mdvi_free(ent);
}

void    mdvi_install_fontmap(DviFontMapEnt *head)
{
    DviFontMapEnt *ent, *next;

    for(ent = head; ent; ent = next) {
        /* add all the entries, overriding old ones */
        DviFontMapEnt *old;
        
        old = (DviFontMapEnt *)
            mdvi_hash_remove(&maptable, MDVI_KEY(ent->fontname));
        if(old != NULL) {
            DEBUG((DBG_FMAP, "%s: overriding fontmap entry\n",
                old->fontname));
            listh_remove(&fontmaps, LIST(old));
            free_ent(old);
        }
        next = ent->next;
        mdvi_hash_add(&maptable, MDVI_KEY(ent->fontname), 
            ent, MDVI_HASH_UNCHECKED);
        listh_append(&fontmaps, LIST(ent));
    }
}

static void init_static_encoding()
{
    DviEncoding *encoding;
    int i;

    DEBUG((DBG_FMAP, "installing static TeX text encoding\n")); 
    encoding = xalloc(DviEncoding);
    encoding->private  = "";
    encoding->filename = "";
    encoding->name     = "TeXTextEncoding";
    encoding->vector   = tex_text_vector;
    encoding->links    = 1;
    encoding->offset   = 0;
    mdvi_hash_create(&encoding->nametab, ENCNAME_HASH_SIZE);
    for(i = 0; i < 256; i++) {
        if(encoding->vector[i]) {
            mdvi_hash_add(&encoding->nametab,
                MDVI_KEY(encoding->vector[i]),
                (DviHashKey)Int2Ptr(i),
                MDVI_HASH_UNCHECKED);
        }
    }
    ASSERT_VALUE(encodings.count, 0);
    mdvi_hash_create(&enctable, ENC_HASH_SIZE);
    mdvi_hash_create(&enctable_file, ENC_HASH_SIZE);
    enctable_file.hash_free = file_hash_free;
    mdvi_hash_add(&enctable, MDVI_KEY(encoding->name), 
        encoding, MDVI_HASH_UNCHECKED);
    listh_prepend(&encodings, LIST(encoding));
    tex_text_encoding = encoding;
    default_encoding = tex_text_encoding;
}

static int  mdvi_set_default_encoding(const char *name)
{
    DviEncoding *enc, *old;

    enc = find_encoding(name);
    if(enc == NULL)
        return -1;
    if(enc == default_encoding)
        return 0;
    /* this will read it from file if necessary,
     * but it can fail if the file is corrupted */
    enc = mdvi_request_encoding(name);
    if(enc == NULL)
        return -1;
    old = default_encoding;
    default_encoding = enc;
    if(old != tex_text_encoding)
        mdvi_release_encoding(old, 1);
    return 0;
}

static int  mdvi_init_fontmaps(void)
{
    char    *file;
    char    *line;
    FILE    *in;
    Dstring input;
    int count = 0;
    char    *config;

    if(fontmaps_loaded)
        return 0;
    /* we will only try this once */
    fontmaps_loaded = 1;

    DEBUG((DBG_FMAP, "reading fontmaps\n"));

    /* make sure the static encoding is there */
    init_static_encoding();

    /* create the fontmap hash table */
    mdvi_hash_create(&maptable, MAP_HASH_SIZE);
            
    /* get the name of our configuration file */
    config = kpse_cnf_get("mdvi-config");
    if(config == NULL)
        config = MDVI_DEFAULT_CONFIG;
    /* let's ask kpathsea for the file first */
    file = kpse_find_file(config, kpse_program_text_format, 0);
    if(file == NULL)
        in = fopen(config, "rb");
    else {
        in = fopen(file, "rb");
        mdvi_free(file);
    }
    if(in == NULL)
        return -1;
    dstring_init(&input);
    while((line = dgets(&input, in)) != NULL) {
        char    *arg, *map_file;
        
        SKIPSP(line);
        if(*line < ' ' || *line == '#' || *line == '%')
            continue;
        if(STRNEQ(line, "fontmap", 7)) {
            DviFontMapEnt *ent;
            
            arg = getstring(line + 7, " \t", &line); *line = 0;
            DEBUG((DBG_FMAP, "%s: loading fontmap\n", arg));
            ent = mdvi_load_fontmap(arg);
            if(ent == NULL) {
                map_file = kpse_find_file(arg, kpse_fontmap_format, 0);
                if (map_file)
                    ent = mdvi_load_fontmap(map_file);
            }
            if(ent == NULL)
                mdvi_warning(_("%s: could not load fontmap\n"), arg);
            else {
                DEBUG((DBG_FMAP, 
                    "%s: installing fontmap\n", arg));
                mdvi_install_fontmap(ent);
                count++;
            }
        } else if(STRNEQ(line, "encoding", 8)) {
            arg = getstring(line + 8, " \t", &line); *line = 0;
            if(arg && *arg)
                register_encoding(arg, 1);
        } else if(STRNEQ(line, "default-encoding", 16)) {
            arg = getstring(line + 16, " \t", &line); *line = 0;
            if(mdvi_set_default_encoding(arg) < 0)
                mdvi_warning(_("%s: could not set as default encoding\n"),
                         arg);
        } else if(STRNEQ(line, "psfontpath", 10)) {
            arg = getstring(line + 11, " \t", &line); *line = 0;
            if(!psinitialized)
                ps_init_default_paths();
            if(psfontdir)
                mdvi_free(psfontdir);
            psfontdir = kpse_path_expand(arg);
        } else if(STRNEQ(line, "pslibpath", 9)) {
            arg = getstring(line + 10, " \t", &line); *line = 0;
            if(!psinitialized)
                ps_init_default_paths();
            if(pslibdir)
                mdvi_free(pslibdir);
            pslibdir = kpse_path_expand(arg);
        } else if(STRNEQ(line, "psfontmap", 9)) {
            arg = getstring(line + 9, " \t", &line); *line = 0;
            if(mdvi_ps_read_fontmap(arg) < 0)
                mdvi_warning("%s: %s: could not read PS fontmap\n",
                         config, arg);
        }
    }
    fclose(in);
    dstring_reset(&input);
    fontmaps_loaded = 1;
    DEBUG((DBG_FMAP, "%d files installed, %d fontmaps\n",
        count, fontmaps.count));
    return count;
}

int mdvi_query_fontmap(DviFontMapInfo *info, const char *fontname)
{
    DviFontMapEnt *ent;

    if(!fontmaps_loaded && mdvi_init_fontmaps() < 0)
        return -1;      
    ent = (DviFontMapEnt *)mdvi_hash_lookup(&maptable, MDVI_KEY(fontname));

    if(ent == NULL)
        return -1;
    info->psname   = ent->psname;
    info->encoding = ent->encoding;
    info->fontfile = ent->fontfile;
    info->extend   = ent->extend;
    info->slant    = ent->slant;
    info->fullfile = ent->fullfile;
    
    return 0;   
}

int mdvi_add_fontmap_file(const char *name, const char *fullpath)
{
    DviFontMapEnt *ent;
    
    if(!fontmaps_loaded && mdvi_init_fontmaps() < 0)
        return -1;
    ent = (DviFontMapEnt *)mdvi_hash_lookup(&maptable, MDVI_KEY(name));
    if(ent == NULL)
        return -1;
    if(ent->fullfile)
        mdvi_free(ent->fullfile);
    ent->fullfile = mdvi_strdup(fullpath);
    return 0;
}


void    mdvi_flush_encodings(void)
{
    DviEncoding *enc;

    if(enctable.nbucks == 0)
        return;

    DEBUG((DBG_FMAP, "flushing %d encodings\n", encodings.count));
    /* asked to remove all encodings */
    for(; (enc = (DviEncoding *)encodings.head); ) {
        encodings.head = LIST(enc->next);
        if((enc != tex_text_encoding && enc->links) || enc->links > 1) {
            mdvi_warning(_("encoding vector `%s' is in use\n"),
                     enc->name);
        }
        destroy_encoding(enc);
    }
    /* destroy the static encoding */
    if(tex_text_encoding->nametab.buckets)
        mdvi_hash_reset(&tex_text_encoding->nametab, 0);
    mdvi_hash_reset(&enctable, 0);
    mdvi_hash_reset(&enctable_file, 0); 
}

void    mdvi_flush_fontmaps(void)
{
    DviFontMapEnt *ent;
    
    if(!fontmaps_loaded)
        return;

    DEBUG((DBG_FMAP, "flushing %d fontmaps\n", fontmaps.count));
    for(; (ent = (DviFontMapEnt *)fontmaps.head); ) {
        fontmaps.head = LIST(ent->next);
        free_ent(ent);
    }
    mdvi_hash_reset(&maptable, 0);
    fontmaps_loaded = 0;
}

/* reading of PS fontmaps */

void    ps_init_default_paths(void)
{
    char    *kppath;
    char    *kfpath;

    ASSERT(psinitialized == 0);

    kppath = getenv("GS_LIB");
    kfpath = getenv("GS_FONTPATH"); 

    if(kppath != NULL)
        pslibdir = kpse_path_expand(kppath);
    if(kfpath != NULL)
        psfontdir = kpse_path_expand(kfpath);

    listh_init(&psfonts);
    mdvi_hash_create(&pstable, PSMAP_HASH_SIZE);
    psinitialized = 1;
}

int mdvi_ps_read_fontmap(const char *name)
{
    char    *fullname;
    FILE    *in;
    Dstring dstr;
    char    *line;
    int count = 0;
    
    if(!psinitialized)
        ps_init_default_paths();
    if(pslibdir)
        fullname = kpse_path_search(pslibdir, name, 1);
    else
        fullname = (char *)name;
    in = fopen(fullname, "rb");
    if(in == NULL) {
        if(fullname != name)
            mdvi_free(fullname);
        return -1;
    }
    dstring_init(&dstr);
    
    while((line = dgets(&dstr, in)) != NULL) {
        char    *name;
        char    *mapname;
        const char *ext;
        PSFontMap *ps;
        
        SKIPSP(line);
        /* we're looking for lines of the form
         *  /FONT-NAME    (fontfile)
         *  /FONT-NAME    /FONT-ALIAS 
         */
        if(*line != '/')
            continue;
        name = getword(line + 1, " \t", &line);
        if(*line) *line++ = 0;
        mapname = getword(line, " \t", &line);
        if(*line) *line++ = 0;
        
        if(!name || !mapname || !*name)
            continue;
        if(*mapname == '(') {
            char    *end;
            
            mapname++;
            for(end = mapname; *end && *end != ')'; end++);
            *end = 0;
        }
        if(!*mapname)
            continue;
        /* dont add `.gsf' fonts, which require a full blown
         * PostScript interpreter */
        ext = file_extension(mapname);
        if(ext && STREQ(ext, "gsf")) {
            DEBUG((DBG_FMAP, "(ps) %s: font `%s' ignored\n",
                name, mapname));
            continue;
        }
        ps = (PSFontMap *)mdvi_hash_lookup(&pstable, MDVI_KEY(name));
        if(ps != NULL) {
            if(STREQ(ps->mapname, mapname))
                continue;
            DEBUG((DBG_FMAP, 
                "(ps) replacing font `%s' (%s) by `%s'\n",
                name, ps->mapname, mapname));
            mdvi_free(ps->mapname);
            ps->mapname = mdvi_strdup(mapname);
            if(ps->fullname) {
                mdvi_free(ps->fullname);
                ps->fullname = NULL;
            }
        } else {
            DEBUG((DBG_FMAP, "(ps) adding font `%s' as `%s'\n",
                name, mapname));
            ps = xalloc(PSFontMap);
            ps->psname   = mdvi_strdup(name);
            ps->mapname  = mdvi_strdup(mapname);
            ps->fullname = NULL;
            listh_append(&psfonts, LIST(ps));
            mdvi_hash_add(&pstable, MDVI_KEY(ps->psname),
                ps, MDVI_HASH_UNCHECKED);
            count++;
        }
    }
    fclose(in);
    dstring_reset(&dstr);
    
    DEBUG((DBG_FMAP, "(ps) %s: %d PostScript fonts registered\n",
        fullname, count));
    return 0;
}

void    mdvi_ps_flush_fonts(void)
{
    PSFontMap *map;
    
    if(!psinitialized)
        return;
    DEBUG((DBG_FMAP, "(ps) flushing PS font map (%d) entries\n",
        psfonts.count));
    mdvi_hash_reset(&pstable, 0);
    for(; (map = (PSFontMap *)psfonts.head); ) {
        psfonts.head = LIST(map->next);
        mdvi_free(map->psname);
        mdvi_free(map->mapname);
        if(map->fullname)
            mdvi_free(map->fullname);
        mdvi_free(map);
    }
    listh_init(&psfonts);
    if(pslibdir) {
        mdvi_free(pslibdir);
        pslibdir = NULL;
    }
    if(psfontdir) {
        mdvi_free(psfontdir);
        psfontdir = NULL;
    }
    psinitialized = 0;
}

char    *mdvi_ps_find_font(const char *psname)
{
    PSFontMap *map, *smap;
    char    *filename;
    int recursion_limit = 32;

    DEBUG((DBG_FMAP, "(ps) resolving PS font `%s'\n", psname));
    if(!psinitialized)
        return NULL;
    map = (PSFontMap *)mdvi_hash_lookup(&pstable, MDVI_KEY(psname));
    if(map == NULL)
        return NULL;
    if(map->fullname)
        return mdvi_strdup(map->fullname);

    /* is it an alias? */
    smap = map;
    while(recursion_limit-- > 0 && smap && *smap->mapname == '/')
        smap = (PSFontMap *)mdvi_hash_lookup(&pstable, 
            MDVI_KEY(smap->mapname + 1));
    if(smap == NULL) {
        if(recursion_limit == 0)
            DEBUG((DBG_FMAP, 
                "(ps) %s: possible loop in PS font map\n",
                psname));
        return NULL;
    }

    if(psfontdir)
        filename = kpse_path_search(psfontdir, smap->mapname, 1);
    else if(file_exists(map->mapname))
        filename = mdvi_strdup(map->mapname);
    else
        filename = NULL;
    if(filename)
        map->fullname = mdvi_strdup(filename);
        
    return filename;
}

/*
 * To get metric info for a font, we proceed as follows:
 *  - We try to find NAME.<tfm,ofm,afm>.
 *  - We query the fontmap for NAME.
 *  - We get back a PSNAME, and use to find the file in the PS font map.
 *  - We get the PSFONT file name, replace its extension by "afm" and
 *  lookup the file in GS's font search path.
 *  - We finally read the data, transform it as specified in our font map,
 *  and return it to the caller. The new data is left in the font metrics
 *  cache, so the next time it will be found at the first step (when we look
 *  up NAME.afm).
 *
 * The name `_ps_' in this function is not meant to imply that it can be 
 * used for Type1 fonts only. It should be usable for TrueType fonts as well.
 *
 * The returned metric info is subjected to the same caching mechanism as
 * all the other metric data, as returned by get_font_metrics(). One should
 * not modify the returned data at all, and it should be disposed with
 * free_font_metrics().
 */
TFMInfo *mdvi_ps_get_metrics(const char *fontname)
{
    TFMInfo *info;
    DviFontMapInfo map;
    char    buffer[64]; /* to avoid mallocs */
    char    *psfont;
    char    *basefile;
    char    *afmfile;
    char    *ext;
    int baselen;
    int nc;
    TFMChar *ch;
    double  efactor;
    double  sfactor;

    DEBUG((DBG_FMAP, "(ps) %s: looking for metric data\n", fontname));  
    info = get_font_metrics(fontname, DviFontAny, NULL);
    if(info != NULL)
        return info;

    /* query the fontmap */
    if(mdvi_query_fontmap(&map, fontname) < 0 || !map.psname)
        return NULL;
    
    /* get the PS font */
    psfont = mdvi_ps_find_font(map.psname);
    if(psfont == NULL)
        return NULL;
    DEBUG((DBG_FMAP, "(ps) %s: found as PS font `%s'\n",
        fontname, psfont));
    /* replace its extension */
    basefile = strrchr(psfont, '/');
    if(basefile == NULL)
        basefile = psfont;
    baselen = strlen(basefile);
    ext = strrchr(basefile, '.');
    if(ext != NULL)
        *ext = 0;
    if(baselen + 4 < 64)
        afmfile = &buffer[0];
    else
        afmfile = mdvi_malloc(baselen + 5);
    strcpy(afmfile, basefile);
    strcpy(afmfile + baselen, ".afm");
    /* we don't need this anymore */
    mdvi_free(psfont);
    DEBUG((DBG_FMAP, "(ps) %s: looking for `%s'\n",
        fontname, afmfile));
    /* lookup the file */
    psfont = kpse_path_search(psfontdir, afmfile, 1);
    /* don't need this anymore */
    if(afmfile != &buffer[0])
        mdvi_free(afmfile);
    if(psfont != NULL) {
        info = get_font_metrics(fontname, DviFontAFM, psfont);
        mdvi_free(psfont);
    } else
        info = NULL;
    if(info == NULL || (!map.extend && !map.slant))
        return info;

    /* 
     * transform the data as prescribed -- keep in mind that `info' 
     * points to CACHED data, so we're modifying the metric cache 
     * in place.
     */

#define DROUND(x)   ((x) >= 0 ? floor((x) + 0.5) : ceil((x) - 0.5))
#define TRANSFORM(x,y)  DROUND(efactor * (x) + sfactor * (y))

    efactor = (double)map.extend / 10000.0;
    sfactor = (double)map.slant / 10000.0;
    DEBUG((DBG_FMAP, "(ps) %s: applying extend=%f, slant=%f\n",
        efactor, sfactor));

    nc = info->hic - info->loc + 1;
    for(ch = info->chars; ch < info->chars + nc; ch++) {
        /* the AFM bounding box is:
         *    wx = ch->advance
         *   llx = ch->left
         *   lly = -ch->depth
         *   urx = ch->right
         *   ury = ch->height
         * what we do here is transform wx, llx, and urx by
         *         newX = efactor * oldX + sfactor * oldY
         * where for `wx' oldY = 0. Also, these numbers are all in
         * TFM units (i.e. TFM's fix-words, which is just the actual
         * number times 2^20, no need to do anything to it).
         */
        if(ch->present) {
            ch->advance = TRANSFORM(ch->advance, 0);
            ch->left    = TRANSFORM(ch->left, -ch->depth);
            ch->right   = TRANSFORM(ch->right, ch->height);
        }
    }
    
    return info;
}