summaryrefslogtreecommitdiff
path: root/Build/source/texk/lcdf-typetools/lcdf-typetools-2.104/include/efont/t1cs.hh
diff options
context:
space:
mode:
Diffstat (limited to 'Build/source/texk/lcdf-typetools/lcdf-typetools-2.104/include/efont/t1cs.hh')
-rw-r--r--Build/source/texk/lcdf-typetools/lcdf-typetools-2.104/include/efont/t1cs.hh343
1 files changed, 343 insertions, 0 deletions
diff --git a/Build/source/texk/lcdf-typetools/lcdf-typetools-2.104/include/efont/t1cs.hh b/Build/source/texk/lcdf-typetools/lcdf-typetools-2.104/include/efont/t1cs.hh
new file mode 100644
index 00000000000..04e17bd6c1d
--- /dev/null
+++ b/Build/source/texk/lcdf-typetools/lcdf-typetools-2.104/include/efont/t1cs.hh
@@ -0,0 +1,343 @@
+// -*- related-file-name: "../../libefont/t1cs.cc" -*-
+#ifndef EFONT_T1CS_HH
+#define EFONT_T1CS_HH
+#include <lcdf/permstr.hh>
+#include <lcdf/string.hh>
+#include <lcdf/vector.hh>
+#include <lcdf/inttypes.h>
+namespace Efont {
+
+// Allow unknown doubles to have some `fuzz' -- so if an unknown double
+// is a bit off from the canonical UNKDOUBLE value, we'll still recognize
+// it as unknown. (Useful for interpolation.)
+#define UNKDOUBLE -9.79797e97
+#define MIN_KNOWN_DOUBLE -9.69696e97
+#define KNOWN(d) ((d) >= MIN_KNOWN_DOUBLE)
+
+class CharstringProgram;
+class CharstringInterp;
+struct CharstringContext;
+class MultipleMasterSpace;
+class Type1Encoding;
+
+class Charstring { public:
+
+ Charstring() { }
+ virtual ~Charstring();
+
+ virtual bool process(CharstringInterp &) const = 0;
+
+ enum Commands {
+ cError = 0,
+ cHstem = 1,
+ cVstem = 3,
+ cVmoveto = 4,
+ cRlineto = 5,
+ cHlineto = 6,
+ cVlineto = 7,
+ cRrcurveto = 8,
+ cClosepath = 9,
+ cCallsubr = 10,
+ cReturn = 11,
+ cEscape = 12,
+ cHsbw = 13,
+ cEndchar = 14,
+ cBlend = 16,
+ cHstemhm = 18,
+ cHintmask = 19,
+ cCntrmask = 20,
+ cRmoveto = 21,
+ cHmoveto = 22,
+ cVstemhm = 23,
+ cRcurveline = 24,
+ cRlinecurve = 25,
+ cVvcurveto = 26,
+ cHhcurveto = 27,
+ cShortint = 28,
+ cCallgsubr = 29,
+ cVhcurveto = 30,
+ cHvcurveto = 31,
+
+ cEscapeDelta = 32,
+ cDotsection = 32 + 0,
+ cVstem3 = 32 + 1,
+ cHstem3 = 32 + 2,
+ cAnd = 32 + 3,
+ cOr = 32 + 4,
+ cNot = 32 + 5,
+ cSeac = 32 + 6,
+ cSbw = 32 + 7,
+ cStore = 32 + 8,
+ cAbs = 32 + 9,
+ cAdd = 32 + 10,
+ cSub = 32 + 11,
+ cDiv = 32 + 12,
+ cLoad = 32 + 13,
+ cNeg = 32 + 14,
+ cEq = 32 + 15,
+ cCallothersubr = 32 + 16,
+ cPop = 32 + 17,
+ cDrop = 32 + 18,
+ cPut = 32 + 20,
+ cGet = 32 + 21,
+ cIfelse = 32 + 22,
+ cRandom = 32 + 23,
+ cMul = 32 + 24,
+ cSqrt = 32 + 26,
+ cDup = 32 + 27,
+ cExch = 32 + 28,
+ cIndex = 32 + 29,
+ cRoll = 32 + 30,
+ cSetcurrentpoint = 32 + 33,
+ cHflex = 32 + 34,
+ cFlex = 32 + 35,
+ cHflex1 = 32 + 36,
+ cFlex1 = 32 + 37,
+
+ cLastCommand = cFlex1
+ };
+
+ enum OthersubrCommands {
+ othcFlexend = 0,
+ othcFlexbegin = 1,
+ othcFlexmiddle = 2,
+ othcReplacehints = 3,
+ othcMM1 = 14,
+ othcMM2 = 15,
+ othcMM3 = 16,
+ othcMM4 = 17,
+ othcMM6 = 18,
+ othcITC_load = 19,
+ othcITC_add = 20,
+ othcITC_sub = 21,
+ othcITC_mul = 22,
+ othcITC_div = 23,
+ othcITC_put = 24,
+ othcITC_get = 25,
+ othcITC_unknown = 26,
+ othcITC_ifelse = 27,
+ othcITC_random = 28
+ };
+
+ static String command_name(int);
+ static const char * const command_names[];
+
+ static const char * const standard_encoding[256];
+
+};
+
+
+class Type1Charstring : public Charstring { public:
+
+ Type1Charstring() { }
+ inline Type1Charstring(const String &); // unencrypted
+ Type1Charstring(int lenIV, const String &); // encrypted
+ // default copy constructor
+ // default destructor
+ // default assignment operator
+
+ inline const uint8_t *data() const;
+ int length() const { return _s.length(); }
+ operator String::unspecified_bool_type() const { return _s; }
+
+ inline const String &data_string() const;
+ inline String substring(int pos, int len) const;
+ int first_caret_after(int pos) const;
+
+ inline void assign(const String &);
+ void prepend(const Type1Charstring &);
+ void assign_substring(int pos, int len, const String &);
+
+ bool process(CharstringInterp &) const;
+
+ private:
+
+ mutable String _s;
+ mutable int _key;
+
+ void decrypt() const;
+
+};
+
+
+class Type2Charstring : public Charstring { public:
+
+ Type2Charstring() { }
+ inline Type2Charstring(const String &);
+ // default copy constructor
+ // default destructor
+ // default assignment operator
+
+ inline const uint8_t *data() const;
+ int length() const { return _s.length(); }
+
+ bool process(CharstringInterp &) const;
+
+ private:
+
+ String _s;
+
+};
+
+
+struct CharstringContext {
+
+ CharstringContext(const CharstringProgram *program_, const Charstring *cs_) : program(program_), cs(cs_) { }
+
+ operator String::unspecified_bool_type() const {
+ return cs != 0 ? &String::length : 0;
+ }
+
+ const CharstringProgram *program;
+ const Charstring *cs;
+
+};
+
+
+class CharstringProgram { public:
+
+ explicit CharstringProgram(unsigned units_per_em);
+ virtual ~CharstringProgram() { }
+
+ virtual PermString font_name() const { return PermString(); }
+ virtual void font_matrix(double[6]) const;
+ unsigned units_per_em() const { return _units_per_em; }
+
+ inline const CharstringProgram *program(int) const;
+ virtual const CharstringProgram *child_program(int) const;
+ bool parent_program() const { return _parent_program; }
+ void set_parent_program(bool pp) { _parent_program = pp; }
+
+ virtual int nsubrs() const { return 0; }
+ virtual Charstring *subr(int) const { return 0; }
+ virtual int subr_bias() const { return 0; }
+
+ virtual int ngsubrs() const { return 0; }
+ virtual Charstring *gsubr(int) const { return 0; }
+ virtual int gsubr_bias() const { return 0; }
+
+ inline int nxsubrs(bool g) const;
+ inline Charstring *xsubr(bool g, int) const;
+ inline int xsubr_bias(bool g) const;
+
+ virtual int nglyphs() const { return 0; }
+ virtual PermString glyph_name(int) const { return PermString(); }
+ virtual void glyph_names(Vector<PermString> &) const;
+ virtual Charstring *glyph(int) const { return 0; }
+ virtual Charstring *glyph(PermString) const { return 0; }
+
+ inline CharstringContext glyph_context(int) const;
+ inline CharstringContext glyph_context(PermString) const;
+
+ virtual bool is_mm() const { return mmspace() != 0; }
+ virtual MultipleMasterSpace *mmspace() const { return 0; }
+ enum VectorType { VEC_WEIGHT = 0, VEC_NORM_DESIGN = 1, VEC_DESIGN = 2 };
+ virtual Vector<double> *mm_vector(VectorType, bool writable) const;
+
+ virtual Type1Encoding *type1_encoding() const { return 0; }
+
+ virtual double global_width_x(bool is_nominal) const;
+
+ private:
+
+ bool _parent_program;
+ uint16_t _units_per_em;
+
+};
+
+
+enum Type1Defs {
+ t1Warmup_ee = 4,
+ t1R_ee = 55665,
+ t1R_cs = 4330,
+ t1C1 = 52845,
+ t1C2 = 22719
+};
+
+
+inline Type1Charstring::Type1Charstring(const String &s)
+ : Charstring(), _s(s), _key(-1)
+{
+}
+
+inline void Type1Charstring::assign(const String &s)
+{
+ _s = s;
+ _key = -1;
+}
+
+inline const uint8_t *Type1Charstring::data() const
+{
+ if (_key >= 0)
+ decrypt();
+ return reinterpret_cast<const uint8_t *>(_s.data());
+}
+
+inline const String &Type1Charstring::data_string() const
+{
+ if (_key >= 0)
+ decrypt();
+ return _s;
+}
+
+inline String Type1Charstring::substring(int pos, int len) const
+{
+ if (_key >= 0)
+ decrypt();
+ return _s.substring(pos, len);
+}
+
+inline bool operator==(const Type1Charstring &a, const Type1Charstring &b)
+{
+ return a.data_string() == b.data_string();
+}
+
+
+inline Type2Charstring::Type2Charstring(const String &s)
+ : _s(s)
+{
+}
+
+inline const uint8_t *Type2Charstring::data() const
+{
+ return reinterpret_cast<const uint8_t *>(_s.data());
+}
+
+
+inline int CharstringProgram::nxsubrs(bool g) const
+{
+ return (g ? ngsubrs() : nsubrs());
+}
+
+inline Charstring *CharstringProgram::xsubr(bool g, int i) const
+{
+ return (g ? gsubr(i) : subr(i));
+}
+
+inline int CharstringProgram::xsubr_bias(bool g) const
+{
+ return (g ? gsubr_bias() : subr_bias());
+}
+
+inline const CharstringProgram *CharstringProgram::program(int gi) const
+{
+ return (_parent_program ? child_program(gi) : this);
+}
+
+inline CharstringContext CharstringProgram::glyph_context(int gi) const
+{
+ if (!_parent_program)
+ return CharstringContext(this, glyph(gi));
+ else if (const CharstringProgram *p = child_program(gi))
+ return CharstringContext(p, p->glyph(gi));
+ else
+ return CharstringContext(0, 0);
+}
+
+inline CharstringContext CharstringProgram::glyph_context(PermString gn) const
+{
+ return CharstringContext(this, glyph(gn));
+}
+
+}
+#endif