OTS: Adds more layout common table supports....

src/gdef.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gdef.h"
 
 #include <vector>
 
 #include "layout.h"
 #include "maxp.h"
@@ skipping 188 matching lines @@
   uint16_t mark_set_count = 0;
   if (!subtable.ReadU16(&format) ||
       !subtable.ReadU16(&mark_set_count)) {
     return OTS_FAILURE();
   }
   if (format != 1) {
     OTS_WARNING("bad mark glyph set table format: %u", format);
     return OTS_FAILURE();
   }
 
   const unsigned mark_sets_end = static_cast<unsigned>(4) + 2*mark_set_count;

[Yusuke Sato, 2011/02/04 06:12:52]

since file->gdef->num_mark_glyph_sets is 16bit unsigned, it might be better to
check integer overflow here. If you agree, please add

if (mark_sets_end > std::numeric_limits<uint16_t>::max()) {
  return OTS_FAILURE();
}

or something similar.

[bashi, 2011/02/07 01:17:07]

Done.

   for (unsigned i = 0; i < mark_set_count; ++i) {
     uint32_t offset_coverage = 0;
     if (!subtable.ReadU32(&offset_coverage)) {
       return OTS_FAILURE();
     }
     if (offset_coverage >= length ||
         offset_coverage < mark_sets_end) {
       return OTS_FAILURE();
     }
     if (!ots::ParseCoverageTable(data + offset_coverage,
                                  length - offset_coverage, num_glyphs)) {
       return OTS_FAILURE();
     }
   }
+  file->gdef->num_mark_glyph_sets = mark_set_count;
   return true;
 }
 
 }  // namespace
 
 #define DROP_THIS_TABLE \
   do { delete file->gdef; file->gdef = 0; } while (0)
 
 namespace ots {
 
@@ skipping 88 matching lines @@
         offset_mark_attach_class_def < gdef_header_end) {
       return OTS_FAILURE();
     }
     if (!ParseMarkAttachClassDefTable(file,
                                       data + offset_mark_attach_class_def,
                                       length - offset_mark_attach_class_def,
                                       num_glyphs)) {
       DROP_THIS_TABLE;
       return true;
     }
+    gdef->has_mark_attachment_class_def = true;
   }
 
   if (offset_mark_glyph_sets_def) {
     if (offset_mark_glyph_sets_def >= length ||
         offset_mark_glyph_sets_def < gdef_header_end) {
       return OTS_FAILURE();
     }
     if (!ParseMarkGlyphSetsDefTable(file,
                                     data + offset_mark_glyph_sets_def,
                                     length - offset_mark_glyph_sets_def,
                                     num_glyphs)) {
       DROP_THIS_TABLE;
       return true;
     }
+    gdef->has_mark_glyph_sets_def = true;
   }
   gdef->data = data;
   gdef->length = length;
   return true;
 }
 
 bool ots_gdef_should_serialise(OpenTypeFile *file) {
   return file->gdef != NULL;
 }
 
 bool ots_gdef_serialise(OTSStream *out, OpenTypeFile *file) {
   if (!out->Write(file->gdef->data, file->gdef->length)) {
     return OTS_FAILURE();
   }
 
   return true;
 }
 
 void ots_gdef_free(OpenTypeFile *file) {
   delete file->gdef;
 }
 
 }  // namespace ots