summaryrefslogtreecommitdiff
path: root/Build/source/texk/lcdf-typetools/lcdf-typetools-2.98/otftotfm/dvipsencoding.hh
blob: a80631c3038435aa0c4a2c44346413979f4b8c23 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
#ifndef OTFTOTFM_DVIPSENCODING_HH
#define OTFTOTFM_DVIPSENCODING_HH
#include <efont/otfcmap.hh>
#include <efont/cff.hh>
#include <lcdf/hashmap.hh>
class Metrics;
class Secondary;
class FontInfo;

class DvipsEncoding { public:

    DvipsEncoding();

    static void add_glyphlist(String);

    operator bool() const			{ return _e.size() > 0; }
    const String &name() const			{ return _name; }
    const String &filename() const		{ return _filename; }
    int boundary_char() const			{ return _boundary_char; }
    const String &coding_scheme() const		{ return _coding_scheme; }
    void set_coding_scheme(const String &s)	{ _coding_scheme = s; }
    void set_warn_missing(bool wm)		{ _warn_missing = wm; }

    void encode(int, PermString);
    inline int encoding_of(PermString) const;
    int encoding_of(PermString, bool encode);
    inline bool encoded(int e) const;
    inline PermString encoding(int e) const;
    int encoding_size() const			{ return _e.size(); }

    int parse(String filename, bool ignore_ligkern, bool ignore_other, ErrorHandler *);
    int parse_ligkern(const String &ligkern_text, int override, ErrorHandler *);
    int parse_position(const String &ligkern_text, int override, ErrorHandler *);
    int parse_unicoding(const String &unicoding_text, int override, ErrorHandler *);

    bool file_had_ligkern() const		{ return _file_had_ligkern; }

    // also modifies 'this':
    void make_metrics(Metrics &, const FontInfo &, Secondary *, bool literal, ErrorHandler *);
    void make_base_mappings(Vector<int> &mappings, const FontInfo &);

    void apply_ligkern_lig(Metrics &, ErrorHandler *) const;
    void apply_ligkern_kern(Metrics &, ErrorHandler *) const;
    void apply_position(Metrics &, ErrorHandler *) const;

    enum { JT_KERN = 32, JT_LIG = 64, JT_ADDLIG = 128, JT_LIGALL = 199,
	   JL_LIG = JT_LIG | JT_ADDLIG, JL_CLIG = JL_LIG | 1,
	   JL_CLIG_S = JL_LIG | 2, JL_LIGC = JL_LIG | 3,
	   JL_LIGC_S = JL_LIG | 4, JL_CLIGC = JL_LIG | 5,
	   JL_CLIGC_S = JL_LIG | 6, JL_CLIGC_SS = JL_LIG | 7,
	   JT_NOLIGKERN = JT_KERN | JT_LIG,
	   J_ALL = 0x7FFFFFFF }; // also see nokern_names in dvipsencoding.cc

  private:

    struct Ligature {
	int c1, c2, join, k, d;
    };

    Vector<PermString> _e;
    Vector<bool> _encoding_required;
    int _boundary_char;
    int _altselector_char;

    Vector<Ligature> _lig;
    Vector<Ligature> _pos;
    HashMap<PermString, int> _unicoding_map;
    Vector<uint32_t> _unicoding;

    mutable Vector<uint32_t> _unicodes;

    String _name;
    String _filename;
    String _printable_filename;
    String _coding_scheme;
    String _initial_comment;
    String _final_text;
    bool _file_had_ligkern;
    bool _warn_missing;

    struct WordType {
	const char *name;
	int (DvipsEncoding::*parsefunc)(Vector<String>&, int, ErrorHandler*);
    };
    static const WordType word_types[];
    enum { WT_LIGKERN = 0, WT_POSITION, WT_UNICODING };

    void add_ligkern(const Ligature &, int override);
    enum { EPARSE = 90000 };
    int parse_ligkern_words(Vector<String> &, int override, ErrorHandler *);
    int parse_position_words(Vector<String> &, int override, ErrorHandler *);
    int parse_unicoding_words(Vector<String> &, int override, ErrorHandler *);
    void parse_word_group(Vector<String> &, int override, int wt, ErrorHandler *);
    int parse_words(const String &, int override, int wt, ErrorHandler *);
    void bad_codepoint(int, Metrics &, HashMap<PermString, int> &bad_unicodes);
    bool x_unicodes(PermString chname, Vector<uint32_t> &unicodes) const;
    String landmark(int line) const;

    static PermString dot_notdef;

    static bool glyphname_unicode(String, Vector<uint32_t> &);

    friend inline bool operator==(const Ligature&, const Ligature&);

};

inline bool
DvipsEncoding::encoded(int e) const
{
    return e >= 0 && e < _e.size() && _e[e] != dot_notdef;
}

inline PermString
DvipsEncoding::encoding(int e) const
{
    if (encoded(e))
	return _e[e];
    else
	return PermString();
}

inline int
DvipsEncoding::encoding_of(PermString what) const
{
    return const_cast<DvipsEncoding *>(this)->encoding_of(what, false);
}

#endif