Attachment #209746 for bug #292530

Lines 347-353 pango_glyph_string_get_logical_widths (P Link Here

(-)./pango/glyphstring.c.dist (-1 / +1 lines)
347	NULL}};	347	NULL}};
348	PangoGlyphItem glyph_item = {&item, glyphs};	348	PangoGlyphItem glyph_item = {&item, glyphs};
349		349
350	return pango_glyph_item_get_logical_widths (&glyph_item, text, logical_widths);	350	pango_glyph_item_get_logical_widths (&glyph_item, text, logical_widths);
351	}	351	}
352		352
353	/* The initial implementation here is script independent,	353	/* The initial implementation here is script independent,

Lines 27-40 Link Here

(-)./pango/opentype/hb-common.h.dist (-1 / +19 lines)
27	#ifndef HB_COMMON_H	27	#ifndef HB_COMMON_H
28	#define HB_COMMON_H	28	#define HB_COMMON_H
29		29
30	#include <stdint.h>	30	# ifndef __sgi
		31	# ifdef HAVE_STDINT_H
		32	# include <stdint.h>
		33	# else
		34	# ifdef HAVE_INTTYPES_H
		35	# include <inttypes.h>
		36	# else
		37	# ifdef HAVE_SYS_TYPES_H
		38	# include <sys/types.h>
		39	# endif
		40	# endif
		41	# endif
		42	# endif
31		43
32	# ifdef __cplusplus	44	# ifdef __cplusplus
33	# define HB_BEGIN_DECLS extern "C" {	45	# define HB_BEGIN_DECLS extern "C" {
34	# define HB_END_DECLS }	46	# define HB_END_DECLS }
		47	# ifdef __sgi
		48	# include <inttypes.h>
		49	# endif
35	# else /* !__cplusplus */	50	# else /* !__cplusplus */
36	# define HB_BEGIN_DECLS	51	# define HB_BEGIN_DECLS
37	# define HB_END_DECLS	52	# define HB_END_DECLS
		53	# ifdef __sgi
		54	# include <stdint.h>
		55	# endif
38	# endif /* !__cplusplus */	56	# endif /* !__cplusplus */
39		57
40	typedef int hb_bool_t;	58	typedef int hb_bool_t;

Lines 556-562 struct GenericArrayOf Link Here

(-)./pango/opentype/hb-open-type-private.hh.dist (-2 / +2 lines)
556	}	556	}
557		557
558	LenType len;	558	LenType len;
559	Type array[];	559	Type *array;
560	};	560	};
561		561
562	/* An array with a USHORT number of elements. */	562	/* An array with a USHORT number of elements. */
Lines 629-635 struct HeadlessArrayOf Link Here
629	}	629	}
630		630
631	USHORT len;	631	USHORT len;
632	Type array[];	632	Type *array;
633	};	633	};
634		634
635		635

Lines 122-128 typedef struct OffsetTable Link Here

(-)./pango/opentype/hb-open-file-private.hh.dist (-1 / +1 lines)
122	USHORT searchRange; /* (Maximum power of 2 <= numTables) x 16 */	122	USHORT searchRange; /* (Maximum power of 2 <= numTables) x 16 */
123	USHORT entrySelector; /* Log2(maximum power of 2 <= numTables). */	123	USHORT entrySelector; /* Log2(maximum power of 2 <= numTables). */
124	USHORT rangeShift; /* NumTables x 16-searchRange. */	124	USHORT rangeShift; /* NumTables x 16-searchRange. */
125	TableDirectory tableDir[]; /* TableDirectory entries. numTables items */	125	TableDirectory tableDir; / TableDirectory entries. numTables items */
126	} OpenTypeFontFace;	126	} OpenTypeFontFace;
127	ASSERT_SIZE (OffsetTable, 12);	127	ASSERT_SIZE (OffsetTable, 12);
128		128




  private:
  union {
  USHORT		format;		/* Format identifier */
  CaretValueFormat1	*format1;
  CaretValueFormat2	*format2;
  CaretValueFormat3	*format3;
  } u;
};
ASSERT_SIZE (CaretValue, 2);

  private:
  union {
  USHORT		format;		/* Format identifier */
  MarkGlyphSetsFormat1	*format1;
  } u;
};
ASSERT_SIZE (MarkGlyphSets, 2);

					 * mark attachment type--from beginning
					 * of GDEF header (may be Null) */
  OffsetTo<MarkGlyphSets>
		*markGlyphSetsDef;	/* Offset to the table of mark set
					 * definitions--from beginning of GDEF
					 * header (may be NULL).  Introduced
					 * in version 00010002. */




#define HB_STMT_START do
#define HB_STMT_END   while (0)

#ifndef __sgi
# define _ASSERT_STATIC1(_line, _cond) typedef int _static_assert_on_line_##_line##_failed[(_cond)?1:-1]
# define _ASSERT_STATIC0(_line, _cond) _ASSERT_STATIC1 (_line, (_cond))
# define ASSERT_STATIC(_cond) _ASSERT_STATIC0 (__LINE__, (_cond))

# define ASSERT_SIZE(_type, _size) ASSERT_STATIC (sizeof (_type) == (_size))
#else /* __sgi */
# define ASSERT_STATIC(_cond)

# define ASSERT_SIZE(_type, _size)
#endif


#if defined(__GNUC__) && (__GNUC__ > 2) && defined(__OPTIMIZE__)





typedef SHORT Value;

typedef Value *ValueRecord;
ASSERT_SIZE (ValueRecord, 0);

struct ValueFormat : USHORT

  private:
  union {
  USHORT		format;		/* Format identifier */
  AnchorFormat1		*format1;
  AnchorFormat2		*format2;
  AnchorFormat3		*format3;
  } u;
};
ASSERT_SIZE (Anchor, 2);

  USHORT	rows;			/* Number of rows */
  private:
  OffsetTo<Anchor>
		*matrix;		/* Matrix of offsets to Anchor tables--
					 * from beginning of AnchorMatrix table */
};
ASSERT_SIZE (AnchorMatrix, 2);

  private:
  union {
  USHORT		format;		/* Format identifier */
  SinglePosFormat1	*format1;
  SinglePosFormat2	*format2;
  } u;
};
ASSERT_SIZE (SinglePos, 2);

  private:
  USHORT	len;			/* Number of PairValueRecords */
  PairValueRecord
		*array;		/* Array of PairValueRecords--ordered
					 * by GlyphID of the second glyph */
};
ASSERT_SIZE (PairSet, 2);

  private:
  union {
  USHORT		format;		/* Format identifier */
  PairPosFormat1	*format1;
  PairPosFormat2	*format2;
  } u;
};
ASSERT_SIZE (PairPos, 2);

  private:
  union {
  USHORT		format;		/* Format identifier */
  CursivePosFormat1	*format1;
  } u;
};
ASSERT_SIZE (CursivePos, 2);

  private:
  union {
  USHORT		format;		/* Format identifier */
  MarkBasePosFormat1	*format1;
  } u;
};
ASSERT_SIZE (MarkBasePos, 2);

  private:
  union {
  USHORT		format;		/* Format identifier */
  MarkLigPosFormat1	*format1;
  } u;
};
ASSERT_SIZE (MarkLigPos, 2);

  private:
  union {
  USHORT		format;		/* Format identifier */
  MarkMarkPosFormat1	*format1;
  } u;
};
ASSERT_SIZE (MarkMarkPos, 2);

  private:
  union {
  USHORT		format;
  SinglePos		*single;
  PairPos		*pair;
  CursivePos		*cursive;
  MarkBasePos		*markBase;
  MarkLigPos		*markLig;
  MarkMarkPos		*markMark;
  ContextPos		*context;
  ChainContextPos	*chainContext;
  ExtensionPos		*extension;
  } u;
};
ASSERT_SIZE (PosLookupSubTable, 2);




  private:
  union {
  USHORT		format;		/* Format identifier */
  SingleSubstFormat1	*format1;
  SingleSubstFormat2	*format2;
  } u;
};
ASSERT_SIZE (SingleSubst, 2);

  private:
  union {
  USHORT		format;		/* Format identifier */
  MultipleSubstFormat1	*format1;
  } u;
};
ASSERT_SIZE (MultipleSubst, 2);

  private:
  union {
  USHORT		format;		/* Format identifier */
  AlternateSubstFormat1	*format1;
  } u;
};
ASSERT_SIZE (AlternateSubst, 2);

  private:
  union {
  USHORT		format;		/* Format identifier */
  LigatureSubstFormat1	*format1;
  } u;
};
ASSERT_SIZE (LigatureSubst, 2);

  private:
  union {
  USHORT				format;		/* Format identifier */
  ReverseChainSingleSubstFormat1	*format1;
  } u;
};
ASSERT_SIZE (ReverseChainSingleSubst, 2);

  private:
  union {
  USHORT			format;
  SingleSubst			*single;
  MultipleSubst			*multiple;
  AlternateSubst		*alternate;
  LigatureSubst			*ligature;
  ContextSubst			*context;
  ChainContextSubst		*chainContext;
  ExtensionSubst		*extension;
  ReverseChainSingleSubst	*reverseChainContextSingle;
  } u;
};
ASSERT_SIZE (SubstLookupSubTable, 2);




					 * glyph sequence--includes the  first
					 * glyph */
  USHORT	lookupCount;		/* Number of LookupRecords */
  USHORT	*input;		/* Array of match inputs--start with
					 * second glyph */
  LookupRecord	*lookupRecordX;	/* Array of LookupRecords--in
					 * design order */
};
ASSERT_SIZE (Rule, 4);

					 * sequence */
  USHORT	lookupCount;		/* Number of LookupRecords */
  OffsetTo<Coverage>
		*coverage;		/* Array of offsets to Coverage
					 * table in glyph sequence order */
  LookupRecord	*lookupRecordX;	/* Array of LookupRecords--in
					 * design order */
};
ASSERT_SIZE (ContextFormat3, 6);

  private:
  union {
  USHORT		format;		/* Format identifier */
  ContextFormat1	*format1;
  ContextFormat2	*format2;
  ContextFormat3	*format3;
  } u;
};
ASSERT_SIZE (Context, 2);

  private:
  union {
  USHORT		format;	/* Format identifier */
  ChainContextFormat1	*format1;
  ChainContextFormat2	*format2;
  ChainContextFormat3	*format3;
  } u;
};
ASSERT_SIZE (ChainContext, 2);

  private:
  union {
  USHORT		format;		/* Format identifier */
  ExtensionFormat1	*format1;
  } u;
};
ASSERT_SIZE (Extension, 2);




  USHORT	lookupFlag;		/* Lookup qualifiers */
  OffsetArrayOf<LookupSubTable>
		subTable;		/* Array of SubTables */
  USHORT	*markFilteringSetX;	/* Index (base 0) into GDEF mark glyph sets
					 * structure. This field is only present if bit
					 * UseMarkFilteringSet of lookup flags is set. */
};

  private:
  union {
  USHORT		format;		/* Format identifier */
  CoverageFormat1	*format1;
  CoverageFormat2	*format2;
  } u;
};
ASSERT_SIZE (Coverage, 2);

  private:
  union {
  USHORT		format;		/* Format identifier */
  ClassDefFormat1	*format1;
  ClassDefFormat2	*format2;
  } u;
};
ASSERT_SIZE (ClassDef, 2);

  USHORT	startSize;	/* Smallest size to correct--in ppem */
  USHORT	endSize;	/* Largest size to correct--in ppem */
  USHORT	deltaFormat;	/* Format of DeltaValue array data: 1, 2, or 3 */
  USHORT	*deltaValue;	/* Array of compressed data */
};
ASSERT_SIZE (Device, 6);


Return to bug 292530

Lines 177-185 struct CaretValue Link Here

(-)./pango/opentype/hb-ot-layout-gdef-private.hh.dist (-5 / +5 lines)
177	private:	177	private:
178	union {	178	union {
179	USHORT format; /* Format identifier */	179	USHORT format; /* Format identifier */
180	CaretValueFormat1 format1[];	180	CaretValueFormat1 *format1;
181	CaretValueFormat2 format2[];	181	CaretValueFormat2 *format2;
182	CaretValueFormat3 format3[];	182	CaretValueFormat3 *format3;
183	} u;	183	} u;
184	};	184	};
185	ASSERT_SIZE (CaretValue, 2);	185	ASSERT_SIZE (CaretValue, 2);
Lines 286-292 struct MarkGlyphSets Link Here
286	private:	286	private:
287	union {	287	union {
288	USHORT format; /* Format identifier */	288	USHORT format; /* Format identifier */
289	MarkGlyphSetsFormat1 format1[];	289	MarkGlyphSetsFormat1 *format1;
290	} u;	290	} u;
291	};	291	};
292	ASSERT_SIZE (MarkGlyphSets, 2);	292	ASSERT_SIZE (MarkGlyphSets, 2);
Lines 364-370 struct GDEF Link Here
364	* mark attachment type--from beginning	364	* mark attachment type--from beginning
365	* of GDEF header (may be Null) */	365	* of GDEF header (may be Null) */
366	OffsetTo<MarkGlyphSets>	366	OffsetTo<MarkGlyphSets>
367	markGlyphSetsDef[0]; /* Offset to the table of mark set	367	markGlyphSetsDef; / Offset to the table of mark set
368	* definitions--from beginning of GDEF	368	* definitions--from beginning of GDEF
369	* header (may be NULL). Introduced	369	* header (may be NULL). Introduced
370	* in version 00010002. */	370	* in version 00010002. */

Lines 35-41 Link Here

(-)./pango/opentype/hb-ot-layout-gpos-private.hh.dist (-23 / +23 lines)
35		35
36	typedef SHORT Value;	36	typedef SHORT Value;
37		37
38	typedef Value ValueRecord[0];	38	typedef Value *ValueRecord;
39	ASSERT_SIZE (ValueRecord, 0);	39	ASSERT_SIZE (ValueRecord, 0);
40		40
41	struct ValueFormat : USHORT	41	struct ValueFormat : USHORT
Lines 259-267 struct Anchor Link Here
259	private:	259	private:
260	union {	260	union {
261	USHORT format; /* Format identifier */	261	USHORT format; /* Format identifier */
262	AnchorFormat1 format1[];	262	AnchorFormat1 *format1;
263	AnchorFormat2 format2[];	263	AnchorFormat2 *format2;
264	AnchorFormat3 format3[];	264	AnchorFormat3 *format3;
265	} u;	265	} u;
266	};	266	};
267	ASSERT_SIZE (Anchor, 2);	267	ASSERT_SIZE (Anchor, 2);
Lines 287-293 struct AnchorMatrix Link Here
287	USHORT rows; /* Number of rows */	287	USHORT rows; /* Number of rows */
288	private:	288	private:
289	OffsetTo<Anchor>	289	OffsetTo<Anchor>
290	matrix[]; /* Matrix of offsets to Anchor tables--	290	matrix; / Matrix of offsets to Anchor tables--
291	* from beginning of AnchorMatrix table */	291	* from beginning of AnchorMatrix table */
292	};	292	};
293	ASSERT_SIZE (AnchorMatrix, 2);	293	ASSERT_SIZE (AnchorMatrix, 2);
Lines 461-468 struct SinglePos Link Here
461	private:	461	private:
462	union {	462	union {
463	USHORT format; /* Format identifier */	463	USHORT format; /* Format identifier */
464	SinglePosFormat1 format1[];	464	SinglePosFormat1 *format1;
465	SinglePosFormat2 format2[];	465	SinglePosFormat2 *format2;
466	} u;	466	} u;
467	};	467	};
468	ASSERT_SIZE (SinglePos, 2);	468	ASSERT_SIZE (SinglePos, 2);
Lines 495-501 struct PairSet Link Here
495	private:	495	private:
496	USHORT len; /* Number of PairValueRecords */	496	USHORT len; /* Number of PairValueRecords */
497	PairValueRecord	497	PairValueRecord
498	array[]; /* Array of PairValueRecords--ordered	498	array; / Array of PairValueRecords--ordered
499	* by GlyphID of the second glyph */	499	* by GlyphID of the second glyph */
500	};	500	};
501	ASSERT_SIZE (PairSet, 2);	501	ASSERT_SIZE (PairSet, 2);
Lines 684-691 struct PairPos Link Here
684	private:	684	private:
685	union {	685	union {
686	USHORT format; /* Format identifier */	686	USHORT format; /* Format identifier */
687	PairPosFormat1 format1[];	687	PairPosFormat1 *format1;
688	PairPosFormat2 format2[];	688	PairPosFormat2 *format2;
689	} u;	689	} u;
690	};	690	};
691	ASSERT_SIZE (PairPos, 2);	691	ASSERT_SIZE (PairPos, 2);
Lines 931-937 struct CursivePos Link Here
931	private:	931	private:
932	union {	932	union {
933	USHORT format; /* Format identifier */	933	USHORT format; /* Format identifier */
934	CursivePosFormat1 format1[];	934	CursivePosFormat1 *format1;
935	} u;	935	} u;
936	};	936	};
937	ASSERT_SIZE (CursivePos, 2);	937	ASSERT_SIZE (CursivePos, 2);
Lines 1027-1033 struct MarkBasePos Link Here
1027	private:	1027	private:
1028	union {	1028	union {
1029	USHORT format; /* Format identifier */	1029	USHORT format; /* Format identifier */
1030	MarkBasePosFormat1 format1[];	1030	MarkBasePosFormat1 *format1;
1031	} u;	1031	} u;
1032	};	1032	};
1033	ASSERT_SIZE (MarkBasePos, 2);	1033	ASSERT_SIZE (MarkBasePos, 2);
Lines 1152-1158 struct MarkLigPos Link Here
1152	private:	1152	private:
1153	union {	1153	union {
1154	USHORT format; /* Format identifier */	1154	USHORT format; /* Format identifier */
1155	MarkLigPosFormat1 format1[];	1155	MarkLigPosFormat1 *format1;
1156	} u;	1156	} u;
1157	};	1157	};
1158	ASSERT_SIZE (MarkLigPos, 2);	1158	ASSERT_SIZE (MarkLigPos, 2);
Lines 1253-1259 struct MarkMarkPos Link Here
1253	private:	1253	private:
1254	union {	1254	union {
1255	USHORT format; /* Format identifier */	1255	USHORT format; /* Format identifier */
1256	MarkMarkPosFormat1 format1[];	1256	MarkMarkPosFormat1 *format1;
1257	} u;	1257	} u;
1258	};	1258	};
1259	ASSERT_SIZE (MarkMarkPos, 2);	1259	ASSERT_SIZE (MarkMarkPos, 2);
Lines 1362-1376 struct PosLookupSubTable Link Here
1362	private:	1362	private:
1363	union {	1363	union {
1364	USHORT format;	1364	USHORT format;
1365	SinglePos single[];	1365	SinglePos *single;
1366	PairPos pair[];	1366	PairPos *pair;
1367	CursivePos cursive[];	1367	CursivePos *cursive;
1368	MarkBasePos markBase[];	1368	MarkBasePos *markBase;
1369	MarkLigPos markLig[];	1369	MarkLigPos *markLig;
1370	MarkMarkPos markMark[];	1370	MarkMarkPos *markMark;
1371	ContextPos context[];	1371	ContextPos *context;
1372	ChainContextPos chainContext[];	1372	ChainContextPos *chainContext;
1373	ExtensionPos extension[];	1373	ExtensionPos *extension;
1374	} u;	1374	} u;
1375	};	1375	};
1376	ASSERT_SIZE (PosLookupSubTable, 2);	1376	ASSERT_SIZE (PosLookupSubTable, 2);

Lines 141-148 struct SingleSubst Link Here

(-)./pango/opentype/hb-ot-layout-gsub-private.hh.dist (-14 / +14 lines)
141	private:	141	private:
142	union {	142	union {
143	USHORT format; /* Format identifier */	143	USHORT format; /* Format identifier */
144	SingleSubstFormat1 format1[];	144	SingleSubstFormat1 *format1;
145	SingleSubstFormat2 format2[];	145	SingleSubstFormat2 *format2;
146	} u;	146	} u;
147	};	147	};
148	ASSERT_SIZE (SingleSubst, 2);	148	ASSERT_SIZE (SingleSubst, 2);
Lines 249-255 struct MultipleSubst Link Here
249	private:	249	private:
250	union {	250	union {
251	USHORT format; /* Format identifier */	251	USHORT format; /* Format identifier */
252	MultipleSubstFormat1 format1[];	252	MultipleSubstFormat1 *format1;
253	} u;	253	} u;
254	};	254	};
255	ASSERT_SIZE (MultipleSubst, 2);	255	ASSERT_SIZE (MultipleSubst, 2);
Lines 345-351 struct AlternateSubst Link Here
345	private:	345	private:
346	union {	346	union {
347	USHORT format; /* Format identifier */	347	USHORT format; /* Format identifier */
348	AlternateSubstFormat1 format1[];	348	AlternateSubstFormat1 *format1;
349	} u;	349	} u;
350	};	350	};
351	ASSERT_SIZE (AlternateSubst, 2);	351	ASSERT_SIZE (AlternateSubst, 2);
Lines 531-537 struct LigatureSubst Link Here
531	private:	531	private:
532	union {	532	union {
533	USHORT format; /* Format identifier */	533	USHORT format; /* Format identifier */
534	LigatureSubstFormat1 format1[];	534	LigatureSubstFormat1 *format1;
535	} u;	535	} u;
536	};	536	};
537	ASSERT_SIZE (LigatureSubst, 2);	537	ASSERT_SIZE (LigatureSubst, 2);
Lines 672-678 struct ReverseChainSingleSubst Link Here
672	private:	672	private:
673	union {	673	union {
674	USHORT format; /* Format identifier */	674	USHORT format; /* Format identifier */
675	ReverseChainSingleSubstFormat1 format1[];	675	ReverseChainSingleSubstFormat1 *format1;
676	} u;	676	} u;
677	};	677	};
678	ASSERT_SIZE (ReverseChainSingleSubst, 2);	678	ASSERT_SIZE (ReverseChainSingleSubst, 2);
Lines 733-746 struct SubstLookupSubTable Link Here
733	private:	733	private:
734	union {	734	union {
735	USHORT format;	735	USHORT format;
736	SingleSubst single[];	736	SingleSubst *single;
737	MultipleSubst multiple[];	737	MultipleSubst *multiple;
738	AlternateSubst alternate[];	738	AlternateSubst *alternate;
739	LigatureSubst ligature[];	739	LigatureSubst *ligature;
740	ContextSubst context[];	740	ContextSubst *context;
741	ChainContextSubst chainContext[];	741	ChainContextSubst *chainContext;
742	ExtensionSubst extension[];	742	ExtensionSubst *extension;
743	ReverseChainSingleSubst reverseChainContextSingle[];	743	ReverseChainSingleSubst *reverseChainContextSingle;
744	} u;	744	} u;
745	};	745	};
746	ASSERT_SIZE (SubstLookupSubTable, 2);	746	ASSERT_SIZE (SubstLookupSubTable, 2);

Lines 318-326 struct Rule Link Here

(-)./pango/opentype/hb-ot-layout-gsubgpos-private.hh.dist (-11 / +11 lines)
318	* glyph sequence--includes the first	318	* glyph sequence--includes the first
319	* glyph */	319	* glyph */
320	USHORT lookupCount; /* Number of LookupRecords */	320	USHORT lookupCount; /* Number of LookupRecords */
321	USHORT input[]; /* Array of match inputs--start with	321	USHORT input; / Array of match inputs--start with
322	* second glyph */	322	* second glyph */
323	LookupRecord lookupRecordX[]; /* Array of LookupRecords--in	323	LookupRecord lookupRecordX; / Array of LookupRecords--in
324	* design order */	324	* design order */
325	};	325	};
326	ASSERT_SIZE (Rule, 4);	326	ASSERT_SIZE (Rule, 4);
Lines 473-481 struct ContextFormat3 Link Here
473	* sequence */	473	* sequence */
474	USHORT lookupCount; /* Number of LookupRecords */	474	USHORT lookupCount; /* Number of LookupRecords */
475	OffsetTo<Coverage>	475	OffsetTo<Coverage>
476	coverage[]; /* Array of offsets to Coverage	476	coverage; / Array of offsets to Coverage
477	* table in glyph sequence order */	477	* table in glyph sequence order */
478	LookupRecord lookupRecordX[]; /* Array of LookupRecords--in	478	LookupRecord lookupRecordX; / Array of LookupRecords--in
479	* design order */	479	* design order */
480	};	480	};
481	ASSERT_SIZE (ContextFormat3, 6);	481	ASSERT_SIZE (ContextFormat3, 6);
Lines 508-516 struct Context Link Here
508	private:	508	private:
509	union {	509	union {
510	USHORT format; /* Format identifier */	510	USHORT format; /* Format identifier */
511	ContextFormat1 format1[];	511	ContextFormat1 *format1;
512	ContextFormat2 format2[];	512	ContextFormat2 *format2;
513	ContextFormat3 format3[];	513	ContextFormat3 *format3;
514	} u;	514	} u;
515	};	515	};
516	ASSERT_SIZE (Context, 2);	516	ASSERT_SIZE (Context, 2);
Lines 821-829 struct ChainContext Link Here
821	private:	821	private:
822	union {	822	union {
823	USHORT format; /* Format identifier */	823	USHORT format; /* Format identifier */
824	ChainContextFormat1 format1[];	824	ChainContextFormat1 *format1;
825	ChainContextFormat2 format2[];	825	ChainContextFormat2 *format2;
826	ChainContextFormat3 format3[];	826	ChainContextFormat3 *format3;
827	} u;	827	} u;
828	};	828	};
829	ASSERT_SIZE (ChainContext, 2);	829	ASSERT_SIZE (ChainContext, 2);
Lines 889-895 struct Extension Link Here
889	private:	889	private:
890	union {	890	union {
891	USHORT format; /* Format identifier */	891	USHORT format; /* Format identifier */
892	ExtensionFormat1 format1[];	892	ExtensionFormat1 *format1;
893	} u;	893	} u;
894	};	894	};
895	ASSERT_SIZE (Extension, 2);	895	ASSERT_SIZE (Extension, 2);

Lines 295-301 struct Lookup Link Here

(-)./pango/opentype/hb-ot-layout-common-private.hh.dist (-6 / +6 lines)
295	USHORT lookupFlag; /* Lookup qualifiers */	295	USHORT lookupFlag; /* Lookup qualifiers */
296	OffsetArrayOf<LookupSubTable>	296	OffsetArrayOf<LookupSubTable>
297	subTable; /* Array of SubTables */	297	subTable; /* Array of SubTables */
298	USHORT markFilteringSetX[0]; /* Index (base 0) into GDEF mark glyph sets	298	USHORT markFilteringSetX; / Index (base 0) into GDEF mark glyph sets
299	* structure. This field is only present if bit	299	* structure. This field is only present if bit
300	* UseMarkFilteringSet of lookup flags is set. */	300	* UseMarkFilteringSet of lookup flags is set. */
301	};	301	};
Lines 424-431 struct Coverage Link Here
424	private:	424	private:
425	union {	425	union {
426	USHORT format; /* Format identifier */	426	USHORT format; /* Format identifier */
427	CoverageFormat1 format1[];	427	CoverageFormat1 *format1;
428	CoverageFormat2 format2[];	428	CoverageFormat2 *format2;
429	} u;	429	} u;
430	};	430	};
431	ASSERT_SIZE (Coverage, 2);	431	ASSERT_SIZE (Coverage, 2);
Lines 540-547 struct ClassDef Link Here
540	private:	540	private:
541	union {	541	union {
542	USHORT format; /* Format identifier */	542	USHORT format; /* Format identifier */
543	ClassDefFormat1 format1[];	543	ClassDefFormat1 *format1;
544	ClassDefFormat2 format2[];	544	ClassDefFormat2 *format2;
545	} u;	545	} u;
546	};	546	};
547	ASSERT_SIZE (ClassDef, 2);	547	ASSERT_SIZE (ClassDef, 2);
Lines 594-600 struct Device Link Here
594	USHORT startSize; /* Smallest size to correct--in ppem */	594	USHORT startSize; /* Smallest size to correct--in ppem */
595	USHORT endSize; /* Largest size to correct--in ppem */	595	USHORT endSize; /* Largest size to correct--in ppem */
596	USHORT deltaFormat; /* Format of DeltaValue array data: 1, 2, or 3 */	596	USHORT deltaFormat; /* Format of DeltaValue array data: 1, 2, or 3 */
597	USHORT deltaValue[]; /* Array of compressed data */	597	USHORT deltaValue; / Array of compressed data */
598	};	598	};
599	ASSERT_SIZE (Device, 6);	599	ASSERT_SIZE (Device, 6);
600		600

Lines 124-134 typedef GStaticMutex hb_mutex_t; Link Here

(-)./pango/opentype/hb-private.h.dist (-4 / +10 lines)
124	#define HB_STMT_START do	124	#define HB_STMT_START do
125	#define HB_STMT_END while (0)	125	#define HB_STMT_END while (0)
126		126
127	#define _ASSERT_STATIC1(_line, _cond) typedef int _static_assert_on_line_##_line##_failed[(_cond)?1:-1]	127	#ifndef __sgi
128	#define _ASSERT_STATIC0(_line, _cond) _ASSERT_STATIC1 (_line, (_cond))	128	# define _ASSERT_STATIC1(_line, _cond) typedef int _static_assert_on_line_##_line##_failed[(_cond)?1:-1]
129	#define ASSERT_STATIC(_cond) _ASSERT_STATIC0 (__LINE__, (_cond))	129	# define _ASSERT_STATIC0(_line, _cond) _ASSERT_STATIC1 (_line, (_cond))
		130	# define ASSERT_STATIC(_cond) _ASSERT_STATIC0 (__LINE__, (_cond))
		131
		132	# define ASSERT_SIZE(_type, _size) ASSERT_STATIC (sizeof (_type) == (_size))
		133	#else /* __sgi */
		134	# define ASSERT_STATIC(_cond)
130		135
131	#define ASSERT_SIZE(_type, _size) ASSERT_STATIC (sizeof (_type) == (_size))	136	# define ASSERT_SIZE(_type, _size)
		137	#endif
132		138
133		139
134	#if defined(__GNUC__) && (__GNUC__ > 2) && defined(__OPTIMIZE__)	140	#if defined(__GNUC__) && (__GNUC__ > 2) && defined(__OPTIMIZE__)