/* otfdump.c -- Dump OpenType Layout Tables.

Copyright (C) 2003, 2004, 2008, 2009, 2010

  National Institute of Advanced Industrial Science and Technology (AIST)

  Registration Number H15PRO167

This file is part of libotf.

Libotf is free software; you can redistribute it and/or modify it

under the terms of the GNU Lesser General Public License as published

by the Free Software Foundation; either version 2.1 of the License, or

(at your option) any later version.

Libotf 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 Lesser General Public

License for more details.

You should have received a copy of the GNU Lesser General Public

License along with this library, in a file named COPYING; if not,

write to the Free Software Foundation, Inc., 59 Temple Place, Suite

330, Boston, MA 02111-1307, USA.  */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <libgen.h>

#include <otf.h>

/* Indented print.  */

#define IPRINT printf("\n%*s", indent * 2, ""), printf

static void

dump_tag (OTF_Tag tag)

{

  printf ("(tag \"");

  putchar (tag >> 24);

  putchar ((tag >> 16) & 0xFF);

  putchar ((tag >> 8) & 0xFF);

  putchar (tag & 0xFF);

  printf ("\" #x%04X)", tag);

}

/* HEAD */

static void

dump_offset_table (int indent, OTF_OffsetTable *table)

{

  IPRINT ("(OffsetTable");

  indent++;

  IPRINT ("(sfnt-version %d.%d)", 

	  table->sfnt_version.high, table->sfnt_version.low);

  IPRINT ("(numTables %d)", table->numTables);

  IPRINT ("(searchRange %d)", table->searchRange);

  IPRINT ("(enterSelector %d)", table->enterSelector);

  IPRINT ("(rangeShift %d))", table->rangeShift);  

}

static void

dump_table_directory (int indent, OTF_TableDirectory *table, int idx)

{

  IPRINT ("(Table %d ", idx);

  dump_tag (table->tag);

  indent++;

  IPRINT ("(checkSum %08X) (offset #x%08X) (length: #x%08X))",

	  table->checkSum, table->offset, table->length);

}

/* head */

static void

dump_head_table (int indent, OTF_head *head)

{

  IPRINT ("(head");

  indent++;

  IPRINT ("(TableVersionNumber %d.%d)",

	  head->TableVersionNumber.high, head->TableVersionNumber.low);

  IPRINT ("(fontRevision %d.%d)",

	  head->fontRevision.high, head->fontRevision.low);

  IPRINT ("(checkSumAdjustment #x%04X)", head->checkSumAdjustment);

  IPRINT ("(magicNumber #x%04X)", head->magicNumber);

  IPRINT ("(flags #x%04X)", head->flags);

  IPRINT ("(unitsPerEm %d)", head->unitsPerEm);

  printf (")");

}

/* COMMON */

static void

dump_glyph_ids (int indent, char *title, OTF_GlyphID *ids, unsigned count)

{

  IPRINT ("(%s (count %d)", title, count);

  while (count-- > 0)

    {

      printf (" #x%04X", *ids);

      ids++;

    }

  printf (")");

}

static int *

dump_coverage (int indent, char *title, OTF_Coverage *coverage)

{

  int i;

  int *char_list;

  IPRINT ("(%sCoverage (CoverageFormat %d)",

	  (title ? title : ""), coverage->CoverageFormat);

  indent++;

  if (coverage->CoverageFormat == 1)

    {

      dump_glyph_ids (indent, "GlyphArray", coverage->table.GlyphArray,

		      coverage->Count);

      char_list = malloc (sizeof (int) * (coverage->Count + 1));

      for (i = 0; i < coverage->Count; i++)

	char_list[i] = coverage->table.GlyphArray[i];

      char_list[i] = -1;

    }

  else

    {

      int n, c;

      IPRINT ("(RangeCount %d)", coverage->Count);

      indent++;

      for (i = n = 0; i < coverage->Count; i++)

	{

	  IPRINT ("(Range (%d) (Start #x%04X) (End #x%04X)", i,

		  coverage->table.RangeRecord[i].Start,

		  coverage->table.RangeRecord[i].End);

	  indent++;

	  IPRINT ("(StartCoverageIndex %d))",

		  coverage->table.RangeRecord[i].StartCoverageIndex);

	  indent--;

	  n += (coverage->table.RangeRecord[i].End

		- coverage->table.RangeRecord[i].Start + 1);

	}

      char_list = malloc (sizeof (int) * (n + 1));

      for (i = n = 0; i < coverage->Count; i++)

	for (c = coverage->table.RangeRecord[i].Start;

	     c <= coverage->table.RangeRecord[i].End;

	     c++)

	  char_list[n++] = c;

      char_list[n] = -1;

    }

  printf (")");

  return char_list;

}

static void

dump_coverage_list (int indent, char *title,

		    OTF_Coverage *coverage, unsigned num)

{

  int i;

  IPRINT ("(%s %d)", title, num);

  for (i = 0; i < num; i++)

    free (dump_coverage (indent, NULL, coverage + i));

}

static void

dump_language_system (int indent, int index, OTF_Tag tag, OTF_Offset offset,

		      OTF_LangSys *langsys)

{

  int i;

  IPRINT ("(LangSys ");

  if (index >= 0)

    printf ("(%d) ", index);

  if (tag)

    dump_tag (tag);

  else

    printf ("DefaultLangSys");

  printf (" (Offset #x%04X)", offset);

  indent++;

  IPRINT ("(LookupOrder #x%04X)", langsys->LookupOrder);

  IPRINT ("(ReqFeatureIndex %d)", langsys->ReqFeatureIndex);

  IPRINT ("(FeatureCount %d)", langsys->FeatureCount);

  if (langsys->FeatureCount)

    {

      IPRINT ("(FeatureIndex");

      for (i = 0; i < langsys->FeatureCount; i++)

	printf (" %d", langsys->FeatureIndex[i]);

      printf (")");

    }

  printf (")");

}

static void

dump_script_list (int indent, OTF_ScriptList *list)

{

  int i, j;

  IPRINT ("(ScriptList (count %d)", list->ScriptCount);

  indent++;

  for (i = 0; i < list->ScriptCount; i++)

    {

      OTF_Script *script = list->Script + i;

      IPRINT ("(Script (%d) ", i);

      dump_tag (list->Script[i].ScriptTag);

      printf (" (Offset #x%04X)", list->Script[i].offset);

      indent++;

      IPRINT ("(DefaultLangSysOffset #x%04X)",

	      script->DefaultLangSysOffset);

      if (script->DefaultLangSysOffset)

	dump_language_system (indent, -1, 0,

			      script->DefaultLangSysOffset,

			      &script->DefaultLangSys);

      IPRINT ("(LangSysCount %d)", script->LangSysCount);

      for (j = 0; j < script->LangSysCount; j++)

	dump_language_system (indent, j,

			      script->LangSysRecord[j].LangSysTag,

			      script->LangSysRecord[j].LangSys,

			      script->LangSys + j);

      printf (")");

      indent--;

    }

  printf (")");

}

static void

dump_feature_list (int indent, OTF_FeatureList *list)

{

  int i, j;

  IPRINT ("(FeatureList (count %d)", list->FeatureCount);

  indent++;

  for (i = 0; i < list->FeatureCount; i++)

    {

      OTF_Feature *feature = list->Feature + i;

      IPRINT ("(Feature (%d) ", i);

      dump_tag (list->Feature[i].FeatureTag);

      printf (" (Offset #x%04X)", list->Feature[i].offset);

      printf (" (LookupCount %d)", feature->LookupCount);

      if (feature->LookupCount)

	{

	  indent++;

	  IPRINT ("(LookupListIndex");

	  for (j = 0; j < feature->LookupCount; j++)

	    printf (" %d", feature->LookupListIndex[j]);

	  printf (")");

	  indent--;

	}

      printf (")");

    }

  printf (")");

}

static void

dump_class_def (int indent, char *title, OTF_ClassDef *class)

{

  IPRINT ("(%s (offset #x%04X) (ClassFormat %d)",

	  (title ? title : "ClassDef"),

	  class->offset, class->ClassFormat);

  if (class->offset)

    {

      indent++;

      if (class->ClassFormat == 1)

	{

	  IPRINT ("(StartGlyph #x%04X)", class->f.f1.StartGlyph);

	  dump_glyph_ids (indent, "ClassValueArray",

			  (OTF_GlyphID *) class->f.f1.ClassValueArray,

			  class->f.f1.GlyphCount);

	}

      else if (class->ClassFormat == 2)

	{

	  int i;

	  IPRINT ("(ClassRangeCount %d)", class->f.f2.ClassRangeCount);

	  IPRINT ("(ClassRangeRecord");

	  indent++;

	  for (i = 0; i < class->f.f2.ClassRangeCount; i++)

	    IPRINT ("((Start #x%04X) (End #x%04X) (class %d))",

		    class->f.f2.ClassRangeRecord[i].Start,

		    class->f.f2.ClassRangeRecord[i].End,

		    class->f.f2.ClassRangeRecord[i].Class);

	  printf (")");

	}

      else

	printf (" UnknownClassFormat");

    }

  printf (")");

}

static void

dump_device_table (int indent, char *title, OTF_DeviceTable *table)

{

  int i;

  if (! table->offset)

    return;

  IPRINT ("(%s (offset #x%04X)", title, table->offset);

  indent++;

  IPRINT ("(StartSize %d) (EndSize %d) (DeltaFormat %d)",

	  table->StartSize, table->EndSize, table->DeltaFormat);

  if (table->DeltaValue)

    {

      IPRINT ("(DeltaValue");

      for (i = 0; i < table->EndSize - table->StartSize + 1; i++)

	printf (" %d", table->DeltaValue[i]);

      printf (")");

    }

  printf (")");

}

static void

dump_value_record (int indent, char *title, OTF_ValueRecord *rec)

{

  IPRINT ("(%s %d %d %d %d", title,

	  rec->XPlacement, rec->YPlacement, rec->XAdvance, rec->YAdvance);

  indent++;

  if (rec->XPlaDevice.offset)

    dump_device_table (indent, "XPlaDevice", &rec->XPlaDevice);

  if (rec->YPlaDevice.offset)

    dump_device_table (indent, "YPlaDevice", &rec->YPlaDevice);

  if (rec->XAdvDevice.offset)

    dump_device_table (indent, "XAdvDevice", &rec->XAdvDevice);

  if (rec->YAdvDevice.offset)

    dump_device_table (indent, "YAdvDevice", &rec->YAdvDevice);

  printf (")");

}

static void

dump_sequence_list (int indent, OTF_Sequence *sequence, unsigned num)

{

  int i;

  IPRINT ("(SequenceCount %d)", num);

  for (i = 0; i < num; i++)

    {

      IPRINT ("(Sequence (%d) (offset #x%04X)",

	      i, sequence[i].offset);

      dump_glyph_ids (indent + 1, "Substitute", sequence[i].Substitute,

		      sequence[i].GlyphCount);

      printf (")");

    }

}

static void

dump_alternate_set_list (int indent, OTF_AlternateSet *altset, unsigned num)

{

  int i;

  IPRINT ("(AlternateSetCount %d)", num);

  for (i = 0; i < num; i++)

    {

      IPRINT ("(AlternateSet (%d) (offset #x%04X)",

	      i, altset[i].offset);

      dump_glyph_ids (indent + 1, "Alternate", altset[i].Alternate,

		      altset[i].GlyphCount);

      printf (")");

    }

}

static void

dump_ligature_set_list (int indent, int *char_list,

			OTF_LigatureSet *ligset, unsigned num)

{

  int i, j, k;

  IPRINT ("(LigSetCount %d)", num);

  for (i = 0; i < num; i++)

    {

      IPRINT ("(LigatureSet (%d) (offset #x%04X) (count %d)",

	      i, ligset[i].offset, ligset[i].LigatureCount);

      indent++;

      for (j = 0; j < ligset[i].LigatureCount; j++)

	{

	  IPRINT ("(Ligature (%d) (offset #x%04X)",

		  j, ligset[i].Ligature[j].offset);

	  indent++;

	  IPRINT ("(LigGlyph #x%04X)",

		  ligset[i].Ligature[j].LigGlyph);

	  dump_glyph_ids (indent, "Component", ligset[i].Ligature[j].Component,

			  ligset[i].Ligature[j].CompCount - 1);

	  IPRINT ("(i.e. #x%04X", char_list[i]);

	  for (k = 0; k < ligset[i].Ligature[j].CompCount - 1; k++)

	    printf (" #x%04X", ligset[i].Ligature[j].Component[k]);

	  printf (" = #x%04X)", ligset[i].Ligature[j].LigGlyph);

	  printf (")");

	  indent--;

	}

      indent--;

      printf (")");

    }

}

static void

dump_pair_set_list (int indent, unsigned count, OTF_PairSet *set)

{

  int i, j;

  for (i = 0; i < count; i++)

    {

      IPRINT ("(PairSet (%d)", i);

      indent++;

      for (j = 0; j < set[i].PairValueCount; j++)

	{

	  IPRINT ("(PairValueRecord (%d)", j);

	  indent++;

	  IPRINT ("(SecondGlyph #x%04X)",

		  set[i].PairValueRecord[j].SecondGlyph);

	  dump_value_record (indent, "Value1",

			     &set[i].PairValueRecord[j].Value1);

	  dump_value_record (indent, "Value2",

			     &set[i].PairValueRecord[j].Value2);

	  printf (")");

	  indent--;

	}

      printf (")");

      indent--;

    }

}

static void

dump_class1_record_list (int indent,

			 unsigned Class1Count, unsigned Class2Count,

			 OTF_Class1Record *rec)

{

  int i, j;

  for (i = 0; i < Class1Count; i++)

    {

      IPRINT ("(Class1Record (%d)", i);

      indent++;

      for (j = 0; j < Class2Count; j++)

	{

	  IPRINT ("(Class2Record (%d)", j);

	  indent++;

	  dump_value_record (indent, "Value1", &rec[i].Class2Record[j].Value1);

	  dump_value_record (indent, "Value2", &rec[i].Class2Record[j].Value2);

	  printf (")");

	  indent--;

	}

      printf (")");

      indent--;

    }

}

static void

dump_anchor (int indent, OTF_Anchor *anchor)

{

  if (anchor->offset == 0)

    return;

  IPRINT ("(Anchor (offset #x%04X) (AnchorFormat %d)",

	  anchor->offset, anchor->AnchorFormat);

  indent++;

  IPRINT ("(XCoordinate %d) (YCoordinate %d)",

	  anchor->XCoordinate, anchor->YCoordinate);

  if (anchor->AnchorFormat == 1)

    ;

  else if (anchor->AnchorFormat == 2)

    IPRINT ("(AnchorPoint %d)", anchor->f.f1.AnchorPoint);

  else

    {

      dump_device_table (indent, "XDeviceTable", &anchor->f.f2.XDeviceTable);

      dump_device_table (indent, "YDeviceTable", &anchor->f.f2.YDeviceTable);

    }

  printf (")");

}

static void

dump_entry_exit_list (int indent, unsigned count, OTF_EntryExitRecord *rec)

{

  int i;

  for (i = 0; i < count; i++)

    {

      IPRINT ("(EntryExitRecord (%d)", i);

      indent++;

      dump_anchor (indent, &rec[i].EntryAnchor);

      dump_anchor (indent, &rec[i].EntryAnchor);

      printf (")");

      indent--;

    }

}

static void

dump_mark_array (int indent, OTF_MarkArray *array)

{

  int i;

  IPRINT ("(MarkArray (MarkCount %d)", array->MarkCount);

  indent++;

  for (i = 0; i < array->MarkCount; i++)

    {

      IPRINT ("(MarkRecord (%d) (Class %d)", i, array->MarkRecord[i].Class);

      dump_anchor (indent + 1, &array->MarkRecord[i].MarkAnchor);

      printf (")");

    }

  printf (")");

}

static void

dump_anchor_array (int indent, unsigned ClassCount, OTF_AnchorArray *array)

{

  int i, j;

  IPRINT ("(AnchorArray (Count %d)", array->Count);

  indent++;

  for (i = 0; i < array->Count; i++)

    {

      IPRINT ("(AnchorRecord (%d) ", i);

      for (j = 0; j < ClassCount; j++)

	dump_anchor (indent + 1, array->AnchorRecord[i].Anchor + j);

      printf (")");

    }

  printf (")");

}

static void

dump_lookup_record_list (int indent, OTF_LookupRecord *rec, unsigned num)

{

  int i;

  IPRINT ("(LookupCount %d)", num);

  for (i = 0; i < num; i++)

    {

      IPRINT ("(LookupRecord (%d)", i);

      indent++;

      IPRINT ("(SequenceIndex %d)", rec[i].SequenceIndex);

      IPRINT ("(LookupListIndex %d))", rec[i].LookupListIndex);

      indent--;

    }

}

static void dump_lookup_subtable_gsub (int indent, int index, unsigned type,

				       OTF_LookupSubTableGSUB *subtable);

static void dump_lookup_subtable_gpos (int indent, int index, unsigned type,

				       OTF_LookupSubTableGPOS *subtable);

static void

dump_lookup_list (int indent, OTF_LookupList *list, int gsub)

{

  int i, j;

  IPRINT ("(LookupList (count %d)", list->LookupCount);

  indent++;

  for (i = 0; i < list->LookupCount; i++)

    {

      OTF_Lookup *lookup = list->Lookup + i;

      IPRINT ("(Lookup (%d) (Offset #x%04X)",

	      i, lookup->offset);

      printf (" (Type %d) (Flag #x%04X) (SubTableCount %d)",

	      lookup->LookupType, lookup->LookupFlag, lookup->SubTableCount);

      if (gsub)

	for (j = 0; j < lookup->SubTableCount; j++)

	  dump_lookup_subtable_gsub (indent + 1, j,

				     lookup->LookupType,

				     lookup->SubTable.gsub + j);

      else

	for (j = 0; j < lookup->SubTableCount; j++)

	  dump_lookup_subtable_gpos (indent + 1, j,

				     lookup->LookupType,

				     lookup->SubTable.gpos + j);

      printf (")");

    }

  printf (")");

}

static void

dump_rule_list (int indent, OTF_Rule *rule, int count)

{

  int i;

  IPRINT ("(RuleCount %d)", count);

  for (i = 0; i < count; i++)

    {

      IPRINT ("(Rule (%d)", i);

      indent++;

      IPRINT ("(GlyphCount %d)", rule[i].GlyphCount);

      IPRINT ("(LookupCount %d)", rule[i].LookupCount);

      dump_glyph_ids (indent, "Input", rule[i].Input, rule[i].GlyphCount - 1);

      dump_lookup_record_list (indent, rule[i].LookupRecord,

			       rule[i].LookupCount);

      printf (")");

      indent--;

    }

}

static void

dump_rule_set_list (int indent, OTF_RuleSet *set, int count)

{

  int i;

  IPRINT ("(RuleSetCount %d)", count);

  for (i = 0; i < count; i++)

    {

      IPRINT ("(RuleSet (%d)", i);

      dump_rule_list (indent + 1, set[i].Rule, set[i].RuleCount);

      printf (")");

    }

}

static void

dump_class_rule_list (int indent, OTF_ClassRule *rule, int count)

{

  int i, j;

  IPRINT ("(ClassRuleCnt %d)", count);

  for (i = 0; i < count; i++)

    {

      IPRINT ("(ClassRule (%d)", i);

      indent++;

      IPRINT ("(GlyphCount %d)", rule[i].GlyphCount);

      IPRINT ("(LookupCount %d)", rule[i].LookupCount);

      IPRINT ("(Class");

      for (j = 0; j < rule[i].GlyphCount - 1; j++)

	printf (" %d", rule[i].Class[j]);

      printf (")");

      dump_lookup_record_list (indent, rule[i].LookupRecord,

			       rule[i].LookupCount);

      printf (")");

      indent--;

    }

}

static void

dump_class_set_list (int indent, OTF_ClassSet *set, int count)

{

  int i;

  IPRINT ("(ClassSetCount %d)", count);

  for (i = 0; i < count; i++)

    if (set[i].offset)

      {

	IPRINT ("(ClassSet (%d)", i);

	dump_class_rule_list (indent + 1, set[i].ClassRule,

			      set[i].ClassRuleCnt);

	printf (")");

      }

}

static void

dump_chain_rule_list (int indent, OTF_ChainRule *rule, int count)

{

  int i;

  IPRINT ("(ChainRuleCount %d)", count);

  for (i = 0; i < count; i++)

    {

      IPRINT ("(ChainRule (%d)", i);

      dump_glyph_ids (indent + 1, "Backtrack",

		      rule[i].Backtrack, rule[i].BacktrackGlyphCount);

      dump_glyph_ids (indent + 1, "Input",

		      rule[i].Input, rule[i].InputGlyphCount - 1);

      dump_glyph_ids (indent + 1, "LookAhead",

		      rule[i].LookAhead, rule[i].LookaheadGlyphCount);

      dump_lookup_record_list (indent + 1, rule[i].LookupRecord,

			       rule[i].LookupCount);

      printf (")");

    }

}

static void

dump_chain_rule_set_list (int indent, OTF_ChainRuleSet *set, int count)

{

  int i;

  IPRINT ("(ChainRuleSetCount %d)", count);

  for (i = 0; i < count; i++)

    {

      IPRINT ("(ChainRuleSet (%d)", i);

      dump_chain_rule_list (indent + 1,

			    set[i].ChainRule, set[i].ChainRuleCount);

      printf (")");

    }

}

static void

dump_chain_class_rule_list (int indent, OTF_ChainClassRule *rule, int count)

{

  int i;

  IPRINT ("(ChainClassRuleCount %d)", count);

  for (i = 0; i < count; i++)

    {

      IPRINT ("(ChainClassRule (%d)", i);

      dump_glyph_ids (indent + 1, "Backtrack",

		      rule[i].Backtrack, rule[i].BacktrackGlyphCount);

      dump_glyph_ids (indent + 1, "Input",

		      rule[i].Input, rule[i].InputGlyphCount - 1);

      dump_glyph_ids (indent + 1, "LookAhead",

		      rule[i].LookAhead, rule[i].LookaheadGlyphCount);

      dump_lookup_record_list (indent + 1, rule[i].LookupRecord,

			       rule[i].LookupCount);

      printf (")");

    }

}

static void

dump_chain_class_set_list (int indent, OTF_ChainClassSet *set, int count)

{

  int i;

  IPRINT ("(ChainClassSetCount %d)", count);

  for (i = 0; i < count; i++)

    if (set[i].offset)

      {

	IPRINT ("(ChainClassSet (%d)", i);

	dump_chain_class_rule_list (indent + 1,

				    set[i].ChainClassRule,

				    set[i].ChainClassRuleCnt);

	printf (")");

      }

}

/* GSUB */

static void

dump_lookup_subtable_gsub (int indent, int index, unsigned type,

			   OTF_LookupSubTableGSUB *subtable)

{

  IPRINT ("(SubTable (%d) (Format %d)", index, subtable->Format);

  indent++;

  switch (type)

    {

    case 1:

      if (subtable->Format == 1)

	{

	  free (dump_coverage (indent, NULL, &subtable->Coverage));

	  IPRINT ("(DeltaGlyhpID #x%04X)",

		  subtable->u.single1.DeltaGlyphID);

	}

      else if (subtable->Format == 2)

	{

	  free (dump_coverage (indent, NULL, &subtable->Coverage));

	  dump_glyph_ids (indent, "Substitute", subtable->u.single2.Substitute,

			  subtable->u.single2.GlyphCount);

	}

      else

	printf (" invalid");

      break;

    case 2:

      if (subtable->Format == 1)

	{

	  free (dump_coverage (indent, NULL, &subtable->Coverage));

	  dump_sequence_list (indent,

			      subtable->u.multiple1.Sequence,

			      subtable->u.multiple1.SequenceCount);

	}

      else

	printf (" invalid");

      break;

    case 3:

      if (subtable->Format == 1)

	{

	  free (dump_coverage (indent, NULL, &subtable->Coverage));

	  dump_alternate_set_list (indent, subtable->u.alternate1.AlternateSet,

				   subtable->u.alternate1.AlternateSetCount);

	}

      else

	printf (" invalid");

      break;

    case 4:

      if (subtable->Format == 1)

	{

	  int *char_list = dump_coverage (indent, NULL, &subtable->Coverage);

	  dump_ligature_set_list (indent, char_list,

				  subtable->u.ligature1.LigatureSet,

				  subtable->u.ligature1.LigSetCount);

	  free (char_list);

	}

      else

	printf (" invalid");

      break;

    case 5:

      if (subtable->Format == 1)

	{

	  free (dump_coverage (indent, NULL, &subtable->Coverage));

	  dump_rule_set_list (indent, subtable->u.context1.RuleSet,

			      subtable->u.context1.RuleSetCount); 

	}

      else if (subtable->Format == 2)

	{

	  free (dump_coverage (indent, NULL, &subtable->Coverage));

	  dump_class_def (indent, NULL, &subtable->u.context2.ClassDef);

	  dump_class_set_list (indent, subtable->u.context2.ClassSet,

			       subtable->u.context2.ClassSetCnt);

	}

      else if (subtable->Format == 3)

	{

	  dump_coverage_list (indent, "Coverage",

			      subtable->u.context3.Coverage,

			      subtable->u.context3.GlyphCount);

	  dump_lookup_record_list (indent,

				   subtable->u.context3.LookupRecord,

				   subtable->u.context3.LookupCount);

	}

      else

	printf (" invalid");

      break;

    case 6:

      if (subtable->Format == 1)

	{

	  free (dump_coverage (indent, NULL, &subtable->Coverage));

	  dump_chain_rule_set_list

	    (indent,

	     subtable->u.chain_context1.ChainRuleSet,

	     subtable->u.chain_context1.ChainRuleSetCount);

	}

      else if (subtable->Format == 2)

	{

	  free (dump_coverage (indent, NULL, &subtable->Coverage));

	  dump_class_def (indent, "BacktrackClassDef",

			  &subtable->u.chain_context2.BacktrackClassDef);

	  dump_class_def (indent, "InputClassDef",

			  &subtable->u.chain_context2.InputClassDef);

	  dump_class_def (indent, "LookaheadClassDef",

			  &subtable->u.chain_context2.LookaheadClassDef);

	  dump_chain_class_set_list

	    (indent,

	     subtable->u.chain_context2.ChainClassSet,

	     subtable->u.chain_context2.ChainClassSetCnt);

	}

      else if (subtable->Format == 3)

	{

	  dump_coverage_list

	    (indent, "BackTrackGlyphCount",

	     subtable->u.chain_context3.Backtrack,

	     subtable->u.chain_context3.BacktrackGlyphCount);

	  dump_coverage_list

	    (indent, "InputGlyphCount",

	     subtable->u.chain_context3.Input,

	     subtable->u.chain_context3.InputGlyphCount);

	  dump_coverage_list

	    (indent, "LookaheadGlyphCount",

	     subtable->u.chain_context3.LookAhead,

	     subtable->u.chain_context3.LookaheadGlyphCount);

	  dump_lookup_record_list

	    (indent,

	     subtable->u.chain_context3.LookupRecord,

	     subtable->u.chain_context3.LookupCount);

	}

      else

	printf (" invalid");

      break;

    case 7:

      IPRINT ("(ExtensionLookupType %d)",

	      subtable->u.extension1.ExtensionLookupType);

      IPRINT ("(ExtensionOffset %d)",

	      subtable->u.extension1.ExtensionOffset);

      dump_lookup_subtable_gsub (indent, index, 

				 subtable->u.extension1.ExtensionLookupType,

				 subtable->u.extension1.ExtensionSubtable);

      break;

    case 8:

      printf (" not-yet-supported");

      break;

    default: