After DEFINE_SCRIPT_ARRAY

src/hb-types-private.cc

 #include <stdint.h>
+#include <assert.h>
 #include <glib.h>
 
-/*
- *
- * The OpenType Font File
- *
- */
-
-
-
-/*
- * Data Types
- */
-
-
-/* "The following data types are used in the OpenType font file.
- *  All OpenType fonts use Motorola-style byte ordering (Big Endian):" */
 
 
 /* Macros to convert to/from BigEndian */
@@ -28,16 +14,100 @@
 #define hb_be_uint64_t	GUINT64_TO_BE
 #define hb_be_int64_t	GINT64_TO_BE
 
+/*
+ * Int types
+ */
+
 #define DEFINE_INT_TYPE1(NAME, TYPE, BIG_ENDIAN) \
 struct NAME { \
   inline NAME (TYPE i) { v = BIG_ENDIAN(i); } \
-  inline TYPE operator = (TYPE i) { v = BIG_ENDIAN(i); return i; } \
-  inline operator TYPE(void) { return BIG_ENDIAN(v); } \
+  inline NAME& operator = (TYPE i) { v = BIG_ENDIAN(i); return *this; } \
+  inline operator TYPE(void) const { return BIG_ENDIAN(v); } \
+  inline bool operator== (NAME o) const { return v == o.v; } \
   private: TYPE v; \
 }
 #define DEFINE_INT_TYPE0(NAME, type) DEFINE_INT_TYPE1 (NAME, type, hb_be_##type)
 #define DEFINE_INT_TYPE(NAME, u, w)  DEFINE_INT_TYPE0 (NAME, u##int##w##_t)
 
+
+/*
+ * Array types
+ */
+
+/* get_len() is a method returning the number of items in an array-like object */
+#define DEFINE_LEN(Type, array, num) \
+  inline unsigned int get_len(void) const { return num; } \
+
+/* get_size() is a method returning the size in bytes of an array-like object */
+#define DEFINE_SIZE(Type, array, num) \
+  inline unsigned int get_size(void) const { return sizeof (*this) + sizeof (Type) * num; }
+
+#define DEFINE_LEN_AND_SIZE(Type, array, num) \
+  DEFINE_LEN(Type, array, num) \
+  DEFINE_SIZE(Type, array, num)
+
+/* An array type is one that contains a variable number of objects
+ * as its last item.  An array object is extended with len() and size()
+ * methods, as well as overloaded [] operator. */
+#define DEFINE_ARRAY_TYPE(Type, array, num) \
+  DEFINE_INDEX_OPERATOR(const, Type, array, num) \
+  DEFINE_INDEX_OPERATOR(     , Type, array, num) \
+  DEFINE_LEN_AND_SIZE(Type, array, num)
+#define DEFINE_INDEX_OPERATOR(const, Type, array, num) \
+  inline const Type& operator[] (unsigned int i) const { \
+    assert (i < num); \
+    return array[i]; \
+  }
+
+/* An offset array type is like an array type, but it contains a table
+ * of offsets to the objects, relative to the beginning of the current
+ * object. */
+#define DEFINE_OFFSET_ARRAY_TYPE(Type, array, num) \
+  DEFINE_OFFSET_INDEX_OPERATOR(const, Type, array, num) \
+  DEFINE_OFFSET_INDEX_OPERATOR(     , Type, array, num) \
+  DEFINE_LEN_AND_SIZE(Offset, array, num)
+#define DEFINE_OFFSET_INDEX_OPERATOR(const, Type, array, num) \
+  inline const Type& operator[] (unsigned int i) const { \
+    assert (i < num); \
+    assert (array[i]); \
+    return *(const Type *)((const char*)this + array[i]); \
+  }
+
+#define DEFINE_RECORD_ARRAY_TYPE(Type, array, num) \
+  DEFINE_RECORD_ACCESSOR(const, Type, array, num) \
+  DEFINE_RECORD_ACCESSOR(     , Type, array, num) \
+  DEFINE_LEN_AND_SIZE(Record, array, num)
+#define DEFINE_RECORD_ACCESSOR(const, Type, array, num) \
+  inline const Type& operator[] (unsigned int i) const { \
+    assert (i < num); \
+    assert (array[i].offset); \
+    return *(const Type *)((const char*)this + array[i].offset); \
+  } \
+  inline const Tag& get_tag (unsigned int i) const { \
+    assert (i < num); \
+    return array[i].tag; \
+  } \
+  /* TODO: implement find_tag() */
+
+
+
+/*
+ *
+ * The OpenType Font File
+ *
+ */
+
+
+
+/*
+ * Data Types
+ */
+
+
+/* "The following data types are used in the OpenType font file.
+ *  All OpenType fonts use Motorola-style byte ordering (Big Endian):" */
+
+
 DEFINE_INT_TYPE (BYTE,	 u, 8);		/* 8-bit unsigned integer. */
 DEFINE_INT_TYPE (CHAR,	  , 8);		/* 8-bit signed integer. */
 DEFINE_INT_TYPE (USHORT, u, 16);	/* 16-bit unsigned integer. */
@@ -51,9 +121,9 @@ DEFINE_INT_TYPE (LONGDATETIME, , 64);
 
 /* 32-bit signed fixed-point number (16.16) */
 struct Fixed : LONG {
-  inline operator double(void) { return (uint32_t) this / 65536.; }
-  inline int16_t int_part (void) { return (uint32_t) this >> 16; }
-  inline int16_t frac_part (void) { return (uint32_t) this & 0xffff; }
+  inline operator double(void) const { return (uint32_t) this / 65536.; }
+  inline int16_t int_part (void) const { return (uint32_t) this >> 16; }
+  inline int16_t frac_part (void) const { return (uint32_t) this & 0xffff; }
 };
 
 /* Smallest measurable distance in the em space. */
@@ -69,13 +139,16 @@ struct UFWORD : USHORT {
 
 /* 16-bit signed fixed number with the low 14 bits of fraction (2.14). */
 struct F2DOT14 : SHORT {
-  inline operator double() { return (uint32_t) this / 16384.; }
+  inline operator double() const { return (uint32_t) this / 16384.; }
 };
 
 /* Array of four uint8s (length = 32 bits) used to identify a script, language
  * system, feature, or baseline */
-struct Tag : public ULONG {
-  inline Tag (char *c) : ULONG(c ? *(uint32_t*)c : 0) {}
+struct Tag {
+  inline Tag (void) { v[0] = v[1] = v[2] = v[3] = 0; }
+  inline Tag (char *c) { v[0] = c[0]; v[1] = c[1]; v[2] = c[2]; v[3] = c[3]; }
+  inline operator uint32_t(void) const { return (v[0]<<24)+(v[1]<<16) +(v[2]<<8)+v[3]; } \
+  private: char v[4];
 };
 
 /* Glyph index number, same as uint16 (length = 16 bits) */
@@ -99,38 +172,23 @@ struct CheckSum : ULONG {
 };
 
 
-
 /*
  * Version Numbers
  */
 
-
 struct USHORT_Version : USHORT {
 };
 
 struct Fixed_Version : Fixed {
-  inline int16_t major (void) { return this->int_part(); }
-  inline int16_t minor (void) { return this->frac_part(); }
+  inline int16_t major (void) const { return this->int_part(); }
+  inline int16_t minor (void) const { return this->frac_part(); }
 };
 
 
-
 /*
  * Organization of an OpenType Font
  */
 
-
-/* Offset Table */
-struct OffsetTable {
-  Fixed_Version	sfnt_version;	/* 0x00010000 for version 1.0. */
-  USHORT	numTables;	/* Number of tables. */
-  USHORT	searchRange;	/* (Maximum power of 2 <= numTables) x 16 */
-  USHORT	entrySelector;	/* Log2(maximum power of 2 <= numTables). */
-  USHORT	rangeShift;	/* NumTables x 16-searchRange. */
-};
-
-
-/* Table Directory */
 struct TableDirectory {
   Tag		tag;		/* 4-byte identifier. */
   CheckSum	checkSum;	/* CheckSum for this table. */
@@ -139,74 +197,81 @@ struct TableDirectory {
   ULONG		length;		/* Length of this table. */
 };
 
+struct OffsetTable {
+  DEFINE_ARRAY_TYPE (TableDirectory, tableDir, numTables);
+
+  Tag		sfnt_version;	/* '\0\001\0\00' if TrueType / 'OTTO' if CFF */
+  USHORT	numTables;	/* Number of tables. */
+  USHORT	searchRange;	/* (Maximum power of 2 <= numTables) x 16 */
+  USHORT	entrySelector;	/* Log2(maximum power of 2 <= numTables). */
+  USHORT	rangeShift;	/* NumTables x 16-searchRange. */
+  TableDirectory tableDir[];	/* TableDirectory entries. numTables items */
+
+};
 
 
 /*
  * TrueType Collections
  */
 
-
-/* TTC Header Version 1.0 */
 struct TTCHeader {
+  /* This works as an array type because TTCHeader is always located at the
+   * beginning of the file */
+  DEFINE_OFFSET_ARRAY_TYPE (OffsetTable, offsetTable, numFonts);
+
   Tag	TTCTag;		/* TrueType Collection ID string: 'ttcf' */
   ULONG	version;	/* Version of the TTC Header (1.0 or 2.0),
 				 * 0x00010000 or 0x00020000 */
   ULONG	numFonts;	/* Number of fonts in TTC */
-  ULONG	offsetTable[0];	/* Array of offsets to the OffsetTable for each font
+  ULONG	offsetTable[];	/* Array of offsets to the OffsetTable for each font
 			 * from the beginning of the file.
 			 * numFonts entries long. */
-
-  inline int len(void) { return sizeof (TTCHeader)
-			      + sizeof (ULONG) * numFonts; }
-};
-
-
-/* TTC Header Version 2.0 tail
- * Follows after TTCHeader with appropriate size for the offsetTable. */
-struct TTCHeaderVersion2Tail {
-  ULONG	ulDsigTag;	/* Tag indicating that a DSIG table exists,
-			 * 0x44534947 ('DSIG') (null if no signature) */
-  ULONG	ulDsigLength;	/* The length (in bytes) of the DSIG table (null if
-			 * no signature) */
-  ULONG	ulDsigOffset;	/* The offset (in bytes) of the DSIG table from the
-			 * beginning of the TTC file (null if no signature) */
 };
 
 
 
 
 
-
 /*
  *
  * OpenType Layout Common Table Formats
  *
  */
 
+struct Script;
+struct LangSys;
 
-/*
- * Script List Table and Script Record
- */
 
-struct ScriptRecord {
-  Tag		scriptTag;	/* 4-byte ScriptTag identifier */
-  Offset	scriptOffset;	/* Offset to Script table--from beginning of
-				 * ScriptList */
-};
+typedef struct Record {
+  Tag		tag;		/* 4-byte Tag identifier */
+  Offset	offset;		/* Offset from beginning of object holding
+				 * the Record */
+} ScriptRecord, LangSysRecord, FeatureRecord;
+
+struct Script;
 
 struct ScriptList {
+  DEFINE_RECORD_ARRAY_TYPE (Script, scriptRecord, scriptCount);
+
   USHORT	scriptCount;	/* Number of ScriptRecords */
   ScriptRecord	scriptRecord[]; /* Array of ScriptRecords--listed alphabetically
 				 * by ScriptTag. scriptCount entries long */
-
-  inline int len(void) { return sizeof (ScriptList)
-			      + sizeof (ScriptRecord) * scriptCount; }
 };
 
+struct Script {
+  DEFINE_RECORD_ARRAY_TYPE (LangSys, langSysRecord, langSysCount);
 
+  Offset	defaultLangSys;	/* Offset to DefaultLangSys table--from
+				 * beginning of Script table--may be NULL */
+  USHORT	langSysCount;	/* Number of LangSysRecords for this script--
+				 * excluding the DefaultLangSys */
+  LangSysRecord	langSysRecord[];/* Array of LangSysRecords--listed
+				 * alphabetically by LangSysTag */
+};
 
+struct LangSys {
 
-
+};
 
 
 #include <stdio.h>
@@ -214,10 +279,10 @@ struct ScriptList {
 int
 main (void)
 {
-  Tag y("abcd");
-  Tag &x = y;
-  BYTE b(0);
+//  Tag y("abcd");
+//  Tag &x = y;
+//  BYTE b(0);
 
-  printf ("%d %04x %04x\n", sizeof (x), x+0, y+0);
+  printf ("%d\n", sizeof (ScriptList));//, x+0, y+0);
   return 0;
 }