Updating to new OTS repo from https://github.com/khaledhosny/ots.git

src/cff.cc

 // Copyright (c) 2012 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 "cff.h"
 
 #include <cstring>
-#include <utility>  // std::pair
+#include <utility>
 #include <vector>
 
+#include "maxp.h"
 #include "cff_type2_charstring.h"
 
 // CFF - PostScript font program (Compact Font Format) table
 // http://www.microsoft.com/typography/otspec/cff.htm
 // http://www.microsoft.com/typography/otspec/cffspec.htm
 
+#define TABLE_NAME "CFF"
+
 namespace {
 
 enum DICT_OPERAND_TYPE {
   DICT_OPERAND_INTEGER,
   DICT_OPERAND_REAL,
   DICT_OPERATOR,
 };
 
 enum DICT_DATA_TYPE {
   DICT_DATA_TOPLEVEL,
@@ skipping 381 matching lines @@
         if (operands.back().second != DICT_OPERAND_INTEGER) {
           return OTS_FAILURE();
         }
         if (operands.back().first >= 1024 * 1024 * 1024) {
           return OTS_FAILURE();
         }
         if (operands.back().first + offset >= table_length) {
           return OTS_FAILURE();
         }
         // parse "16. Local Subrs INDEX"
-        ots::Buffer table(data, table_length);
-        table.set_offset(operands.back().first + offset);
+        ots::Buffer cff_table(data, table_length);
+        cff_table.set_offset(operands.back().first + offset);
         ots::CFFIndex *local_subrs_index = NULL;
         if (type == DICT_DATA_FDARRAY) {
           if (out_cff->local_subrs_per_font.empty()) {
             return OTS_FAILURE();  // not reached.
           }
           local_subrs_index = out_cff->local_subrs_per_font.back();
         } else { // type == DICT_DATA_TOPLEVEL
           if (out_cff->local_subrs) {
             return OTS_FAILURE();  // two or more local_subrs?
           }
           local_subrs_index = new ots::CFFIndex;
           out_cff->local_subrs = local_subrs_index;
         }
-        if (!ParseIndex(&table, local_subrs_index)) {
+        if (!ParseIndex(&cff_table, local_subrs_index)) {
           return OTS_FAILURE();
         }
         break;
       }
 
       // boolean
       case (12U << 8) + 14:  // ForceBold
         if (operands.size() != 1) {
           return OTS_FAILURE();
         }
         if (operands.back().second != DICT_OPERAND_INTEGER) {
           return OTS_FAILURE();
         }
         if (operands.back().first >= 2) {
           return OTS_FAILURE();
         }
         break;
 
       default:
         return OTS_FAILURE();
     }
     operands.clear();
   }
 
   return true;
 }
 
 bool ParseDictData(const uint8_t *data, size_t table_length,
-                   const ots::CFFIndex &index, size_t sid_max,
-                   DICT_DATA_TYPE type, ots::OpenTypeCFF *out_cff) {
+                   const ots::CFFIndex &index, uint16_t glyphs,
+                   size_t sid_max, DICT_DATA_TYPE type,
+                   ots::OpenTypeCFF *out_cff) {
   for (unsigned i = 1; i < index.offsets.size(); ++i) {
     if (type == DICT_DATA_TOPLEVEL) {
       out_cff->char_strings_array.push_back(new ots::CFFIndex);
     }
     size_t dict_length = index.offsets[i] - index.offsets[i - 1];
     ots::Buffer table(data + index.offsets[i - 1], dict_length);
 
     std::vector<std::pair<uint32_t, DICT_OPERAND_TYPE> > operands;
 
     FONT_FORMAT font_format = FORMAT_UNKNOWN;
     bool have_ros = false;
-    uint16_t glyphs = 0;
+    uint16_t charstring_glyphs = 0;
     size_t charset_offset = 0;
 
     while (table.offset() < dict_length) {
       if (!ParseDictDataReadNext(&table, &operands)) {
         return OTS_FAILURE();
       }
       if (operands.empty()) {
         return OTS_FAILURE();
       }
       if (operands.size() > 48) {
@@ skipping 109 matching lines @@
             return OTS_FAILURE();
           }
           if (operands.back().first <= 1) {
             break;  // predefined encoding, "Standard" or "Expert", is used.
           }
           if (!CheckOffset(operands.back(), table_length)) {
             return OTS_FAILURE();
           }
 
           // parse sub dictionary INDEX.
-          ots::Buffer table(data, table_length);
-          table.set_offset(operands.back().first);
+          ots::Buffer cff_table(data, table_length);
+          cff_table.set_offset(operands.back().first);
           uint8_t format = 0;
-          if (!table.ReadU8(&format)) {
+          if (!cff_table.ReadU8(&format)) {
             return OTS_FAILURE();
           }
           if (format & 0x80) {
             // supplemental encoding is not supported at the moment.
             return OTS_FAILURE();
           }
           // TODO(yusukes): support & parse supplemental encoding tables.
           break;
         }
 
         case 17: {  // CharStrings
           if (type != DICT_DATA_TOPLEVEL) {
             return OTS_FAILURE();
           }
           if (operands.size() != 1) {
             return OTS_FAILURE();
           }
           if (!CheckOffset(operands.back(), table_length)) {
             return OTS_FAILURE();
           }
           // parse "14. CharStrings INDEX"
-          ots::Buffer table(data, table_length);
-          table.set_offset(operands.back().first);
+          ots::Buffer cff_table(data, table_length);
+          cff_table.set_offset(operands.back().first);
           ots::CFFIndex *charstring_index = out_cff->char_strings_array.back();
-          if (!ParseIndex(&table, charstring_index)) {
+          if (!ParseIndex(&cff_table, charstring_index)) {
             return OTS_FAILURE();
           }
           if (charstring_index->count < 2) {
             return OTS_FAILURE();
           }
-          if (glyphs) {
+          if (charstring_glyphs) {
             return OTS_FAILURE();  // multiple charstring tables?
           }
-          glyphs = charstring_index->count;
+          charstring_glyphs = charstring_index->count;
+          if (charstring_glyphs != glyphs) {
+            return OTS_FAILURE();  // CFF and maxp have different number of glyphs?
+          }
           break;
         }
 
         case (12U << 8) + 36: {  // FDArray
           if (type != DICT_DATA_TOPLEVEL) {
             return OTS_FAILURE();
           }
           if (operands.size() != 1) {
             return OTS_FAILURE();
           }
           if (!CheckOffset(operands.back(), table_length)) {
             return OTS_FAILURE();
           }
 
           // parse sub dictionary INDEX.
-          ots::Buffer table(data, table_length);
-          table.set_offset(operands.back().first);
+          ots::Buffer cff_table(data, table_length);
+          cff_table.set_offset(operands.back().first);
           ots::CFFIndex sub_dict_index;
-          if (!ParseIndex(&table, &sub_dict_index)) {
+          if (!ParseIndex(&cff_table, &sub_dict_index)) {
             return OTS_FAILURE();
           }
           if (!ParseDictData(data, table_length,
-                             sub_dict_index, sid_max, DICT_DATA_FDARRAY,
+                             sub_dict_index,
+                             glyphs, sid_max, DICT_DATA_FDARRAY,
                              out_cff)) {
             return OTS_FAILURE();
           }
           if (out_cff->font_dict_length != 0) {
             return OTS_FAILURE();  // two or more FDArray found.
           }
           out_cff->font_dict_length = sub_dict_index.count;
           break;
         }
 
         case (12U << 8) + 37: {  // FDSelect
           if (type != DICT_DATA_TOPLEVEL) {
             return OTS_FAILURE();
           }
           if (operands.size() != 1) {
             return OTS_FAILURE();
           }
           if (!CheckOffset(operands.back(), table_length)) {
             return OTS_FAILURE();
           }
 
           // parse FDSelect data structure
-          ots::Buffer table(data, table_length);
-          table.set_offset(operands.back().first);
+          ots::Buffer cff_table(data, table_length);
+          cff_table.set_offset(operands.back().first);
           uint8_t format = 0;
-          if (!table.ReadU8(&format)) {
+          if (!cff_table.ReadU8(&format)) {
             return OTS_FAILURE();
           }
           if (format == 0) {
             for (uint16_t j = 0; j < glyphs; ++j) {
               uint8_t fd_index = 0;
-              if (!table.ReadU8(&fd_index)) {
+              if (!cff_table.ReadU8(&fd_index)) {
                 return OTS_FAILURE();
               }
               (out_cff->fd_select)[j] = fd_index;
             }
           } else if (format == 3) {
             uint16_t n_ranges = 0;
-            if (!table.ReadU16(&n_ranges)) {
+            if (!cff_table.ReadU16(&n_ranges)) {
               return OTS_FAILURE();
             }
             if (n_ranges == 0) {
               return OTS_FAILURE();
             }
 
             uint16_t last_gid = 0;
             uint8_t fd_index = 0;
             for (unsigned j = 0; j < n_ranges; ++j) {
               uint16_t first = 0;  // GID
-              if (!table.ReadU16(&first)) {
+              if (!cff_table.ReadU16(&first)) {
                 return OTS_FAILURE();
               }
 
               // Sanity checks.
               if ((j == 0) && (first != 0)) {
                 return OTS_FAILURE();
               }
               if ((j != 0) && (last_gid >= first)) {
                 return OTS_FAILURE();  // not increasing order.
               }
 
               // Copy the mapping to |out_cff->fd_select|.
               if (j != 0) {
                 for (uint16_t k = last_gid; k < first; ++k) {
                   if (!out_cff->fd_select.insert(
                           std::make_pair(k, fd_index)).second) {
                     return OTS_FAILURE();
                   }
                 }
               }
 
-              if (!table.ReadU8(&fd_index)) {
+              if (!cff_table.ReadU8(&fd_index)) {
                 return OTS_FAILURE();
               }
               last_gid = first;
               // TODO(yusukes): check GID?
             }
             uint16_t sentinel = 0;
-            if (!table.ReadU16(&sentinel)) {
+            if (!cff_table.ReadU16(&sentinel)) {
               return OTS_FAILURE();
             }
             if (last_gid >= sentinel) {
               return OTS_FAILURE();
             }
             for (uint16_t k = last_gid; k < sentinel; ++k) {
               if (!out_cff->fd_select.insert(
                       std::make_pair(k, fd_index)).second) {
                 return OTS_FAILURE();
               }
@@ skipping 66 matching lines @@
       }
       operands.clear();
 
       if (font_format == FORMAT_UNKNOWN) {
         font_format = FORMAT_OTHER;
       }
     }
 
     // parse "13. Charsets"
     if (charset_offset) {
-      ots::Buffer table(data, table_length);
-      table.set_offset(charset_offset);
+      ots::Buffer cff_table(data, table_length);
+      cff_table.set_offset(charset_offset);
       uint8_t format = 0;
-      if (!table.ReadU8(&format)) {
+      if (!cff_table.ReadU8(&format)) {
         return OTS_FAILURE();
       }
       switch (format) {
         case 0:
           for (uint16_t j = 1 /* .notdef is omitted */; j < glyphs; ++j) {
             uint16_t sid = 0;
-            if (!table.ReadU16(&sid)) {
+            if (!cff_table.ReadU16(&sid)) {
               return OTS_FAILURE();
             }
             if (!have_ros && (sid > sid_max)) {
               return OTS_FAILURE();
             }
             // TODO(yusukes): check CIDs when have_ros is true.
           }
           break;
 
         case 1:
         case 2: {
           uint32_t total = 1;  // .notdef is omitted.
           while (total < glyphs) {
             uint16_t sid = 0;
-            if (!table.ReadU16(&sid)) {
+            if (!cff_table.ReadU16(&sid)) {
               return OTS_FAILURE();
             }
             if (!have_ros && (sid > sid_max)) {
               return OTS_FAILURE();
             }
             // TODO(yusukes): check CIDs when have_ros is true.
 
             if (format == 1) {
               uint8_t left = 0;
-              if (!table.ReadU8(&left)) {
+              if (!cff_table.ReadU8(&left)) {
                 return OTS_FAILURE();
               }
               total += (left + 1);
             } else {
               uint16_t left = 0;
-              if (!table.ReadU16(&left)) {
+              if (!cff_table.ReadU16(&left)) {
                 return OTS_FAILURE();
               }
               total += (left + 1);
             }
           }
           break;
         }
 
         default:
           return OTS_FAILURE();
@@ skipping 69 matching lines @@
   // parse "10. String INDEX"
   table.set_offset(top_dict_index.offset_to_next);
   CFFIndex string_index;
   if (!ParseIndex(&table, &string_index)) {
     return OTS_FAILURE();
   }
   if (string_index.count >= 65000 - kNStdString) {
     return OTS_FAILURE();
   }
 
+  const uint16_t num_glyphs = file->maxp->num_glyphs;
   const size_t sid_max = string_index.count + kNStdString;
   // string_index.count == 0 is allowed.
 
   // parse "9. Top DICT Data"
   if (!ParseDictData(data, length, top_dict_index,
-                     sid_max, DICT_DATA_TOPLEVEL, file->cff)) {
+                     num_glyphs, sid_max,
+                     DICT_DATA_TOPLEVEL, file->cff)) {
     return OTS_FAILURE();
   }
 
   // parse "16. Global Subrs INDEX"
   table.set_offset(string_index.offset_to_next);
   CFFIndex global_subrs_index;
   if (!ParseIndex(&table, &global_subrs_index)) {
     return OTS_FAILURE();
   }
 
   // Check if all fd_index in FDSelect are valid.
   std::map<uint16_t, uint8_t>::const_iterator iter;
   std::map<uint16_t, uint8_t>::const_iterator end = file->cff->fd_select.end();
   for (iter = file->cff->fd_select.begin(); iter != end; ++iter) {
     if (iter->second >= file->cff->font_dict_length) {
       return OTS_FAILURE();
     }
   }
 
   // Check if all charstrings (font hinting code for each glyph) are valid.
   for (size_t i = 0; i < file->cff->char_strings_array.size(); ++i) {
-    if (!ValidateType2CharStringIndex(*(file->cff->char_strings_array.at(i)),
+    if (!ValidateType2CharStringIndex(file,
+                                      *(file->cff->char_strings_array.at(i)),
                                       global_subrs_index,
                                       file->cff->fd_select,
                                       file->cff->local_subrs_per_font,
                                       file->cff->local_subrs,
                                       &table)) {
-      return OTS_FAILURE();
+      return OTS_FAILURE_MSG("Failed validating charstring set %d", (int) i);
     }
   }
 
   return true;
 }
 
 bool ots_cff_should_serialise(OpenTypeFile *file) {
   return file->cff != NULL;
 }
 
@@ skipping 13 matching lines @@
     }
     for (size_t i = 0; i < file->cff->local_subrs_per_font.size(); ++i) {
       delete (file->cff->local_subrs_per_font)[i];
     }
     delete file->cff->local_subrs;
     delete file->cff;
   }
 }
 
 }  // namespace ots
+
+#undef TABLE_NAME