minor spacing tweak

perf/perf-draw.hh

@@ -35,7 +35,7 @@ _ft_line_to (const FT_Vector* to HB_UNUSED, void* user HB_UNUSED) {}
 
 static void
 _ft_conic_to (const FT_Vector* control HB_UNUSED, const FT_Vector* to HB_UNUSED,
-              void* user HB_UNUSED) {}
+	      void* user HB_UNUSED) {}
 
 static void
 _ft_cubic_to (const FT_Vector* control1 HB_UNUSED, const FT_Vector* control2 HB_UNUSED,

src/hb-ot-cmap-table.hh

@@ -57,14 +57,14 @@ struct CmapSubtableFormat0
   }
 
   void collect_mapping (hb_set_t *unicodes, /* OUT */
-                        hb_map_t *mapping /* OUT */) const
+			hb_map_t *mapping /* OUT */) const
   {
     for (unsigned i = 0; i < 256; i++)
       if (glyphIdArray[i])
       {
-        hb_codepoint_t glyph = glyphIdArray[i];
+	hb_codepoint_t glyph = glyphIdArray[i];
-        unicodes->add (i);
+	unicodes->add (i);
-        mapping->set (i, glyph);
+	mapping->set (i, glyph);
       }
   }
 
@@ -389,41 +389,41 @@ struct CmapSubtableFormat4
     }
 
     void collect_mapping (hb_set_t *unicodes, /* OUT */
-                          hb_map_t *mapping /* OUT */) const
+			  hb_map_t *mapping /* OUT */) const
     {
       unsigned count = this->segCount;
       if (count && this->startCount[count - 1] == 0xFFFFu)
-        count--; /* Skip sentinel segment. */
+	count--; /* Skip sentinel segment. */
       for (unsigned i = 0; i < count; i++)
       {
-        hb_codepoint_t start = this->startCount[i];
+	hb_codepoint_t start = this->startCount[i];
-        hb_codepoint_t end = this->endCount[i];
+	hb_codepoint_t end = this->endCount[i];
-        unsigned rangeOffset = this->idRangeOffset[i];
+	unsigned rangeOffset = this->idRangeOffset[i];
-        if (rangeOffset == 0)
+	if (rangeOffset == 0)
-        {
+	{
-          for (hb_codepoint_t codepoint = start; codepoint <= end; codepoint++)
+	  for (hb_codepoint_t codepoint = start; codepoint <= end; codepoint++)
-          {
+	  {
-            hb_codepoint_t gid = (codepoint + this->idDelta[i]) & 0xFFFFu;
+	    hb_codepoint_t gid = (codepoint + this->idDelta[i]) & 0xFFFFu;
-            if (unlikely (!gid))
+	    if (unlikely (!gid))
-              continue;
+	      continue;
-            unicodes->add (codepoint);
+	    unicodes->add (codepoint);
-            mapping->set (codepoint, gid);
+	    mapping->set (codepoint, gid);
-          }
+	  }
-        }
+	}
-        else
+	else
-        {
+	{
-          for (hb_codepoint_t codepoint = start; codepoint <= end; codepoint++)
+	  for (hb_codepoint_t codepoint = start; codepoint <= end; codepoint++)
-          {
+	  {
-            unsigned index = rangeOffset / 2 + (codepoint - this->startCount[i]) + i - this->segCount;
+	    unsigned index = rangeOffset / 2 + (codepoint - this->startCount[i]) + i - this->segCount;
-            if (unlikely (index >= this->glyphIdArrayLength))
+	    if (unlikely (index >= this->glyphIdArrayLength))
-              break;
+	      break;
-            hb_codepoint_t gid = this->glyphIdArray[index];
+	    hb_codepoint_t gid = this->glyphIdArray[index];
-            if (unlikely (!gid))
+	    if (unlikely (!gid))
-              continue;
+	      continue;
-            unicodes->add (codepoint);
+	    unicodes->add (codepoint);
-            mapping->set (codepoint, gid);
+	    mapping->set (codepoint, gid);
-          }
+	  }
-        }
+	}
       }
     }
 
@@ -448,7 +448,7 @@ struct CmapSubtableFormat4
   }
 
   void collect_mapping (hb_set_t *unicodes, /* OUT */
-                        hb_map_t *mapping /* OUT */) const
+			hb_map_t *mapping /* OUT */) const
   {
     accelerator_t accel (this);
     accel.collect_mapping (unicodes, mapping);
@@ -557,17 +557,17 @@ struct CmapSubtableTrimmed
   }
 
   void collect_mapping (hb_set_t *unicodes, /* OUT */
-                        hb_map_t *mapping /* OUT */) const
+			hb_map_t *mapping /* OUT */) const
   {
     hb_codepoint_t start_cp = startCharCode;
     unsigned count = glyphIdArray.len;
     for (unsigned i = 0; i < count; i++)
       if (glyphIdArray[i])
       {
-        hb_codepoint_t unicode = start_cp + i;
+	hb_codepoint_t unicode = start_cp + i;
-        hb_codepoint_t glyphid = glyphIdArray[i];
+	hb_codepoint_t glyphid = glyphIdArray[i];
-        unicodes->add (unicode);
+	unicodes->add (unicode);
-        mapping->set (unicode, glyphid);
+	mapping->set (unicode, glyphid);
       }
   }
 
@@ -630,31 +630,31 @@ struct CmapSubtableLongSegmented
   }
 
   void collect_mapping (hb_set_t *unicodes, /* OUT */
-                        hb_map_t *mapping, /* OUT */
+			hb_map_t *mapping, /* OUT */
-                        unsigned num_glyphs) const
+			unsigned num_glyphs) const
   {
     for (unsigned i = 0; i < this->groups.len; i++)
     {
       hb_codepoint_t start = this->groups[i].startCharCode;
       hb_codepoint_t end = hb_min ((hb_codepoint_t) this->groups[i].endCharCode,
-                                   (hb_codepoint_t) HB_UNICODE_MAX);
+				   (hb_codepoint_t) HB_UNICODE_MAX);
       hb_codepoint_t gid = this->groups[i].glyphID;
       if (!gid)
       {
-        /* Intention is: if (hb_is_same (T, CmapSubtableFormat13)) continue; */
+	/* Intention is: if (hb_is_same (T, CmapSubtableFormat13)) continue; */
-        if (! T::group_get_glyph (this->groups[i], end)) continue;
+	if (! T::group_get_glyph (this->groups[i], end)) continue;
-        start++;
+	start++;
-        gid++;
+	gid++;
       }
       if (unlikely ((unsigned int) gid >= num_glyphs)) continue;
       if (unlikely ((unsigned int) (gid + end - start) >= num_glyphs))
-        end = start + (hb_codepoint_t) num_glyphs - gid;
+	end = start + (hb_codepoint_t) num_glyphs - gid;
 
       for (unsigned cp = start; cp <= end; cp++)
       {
-        unicodes->add (cp);
+	unicodes->add (cp);
-        mapping->set (cp, gid);
+	mapping->set (cp, gid);
-        gid++;
+	gid++;
       }
     }
   }
@@ -1363,38 +1363,38 @@ struct cmap
       unsigned format = (base+_.subtable).u.format;
       if (!plan->glyphs_requested->is_empty ())
       {
-        hb_set_t unicodes_set;
+	hb_set_t unicodes_set;
-        hb_map_t cp_glyphid_map;
+	hb_map_t cp_glyphid_map;
-        (base+_.subtable).collect_mapping (&unicodes_set, &cp_glyphid_map);
+	(base+_.subtable).collect_mapping (&unicodes_set, &cp_glyphid_map);
 
-        auto table_iter =
+	auto table_iter =
-        + hb_zip (unicodes_set.iter(), unicodes_set.iter() | hb_map(cp_glyphid_map))
+	+ hb_zip (unicodes_set.iter(), unicodes_set.iter() | hb_map(cp_glyphid_map))
-        | hb_filter (plan->_glyphset, hb_second)
+	| hb_filter (plan->_glyphset, hb_second)
-        | hb_filter ([plan] (const hb_pair_t<hb_codepoint_t, hb_codepoint_t>& p)
+	| hb_filter ([plan] (const hb_pair_t<hb_codepoint_t, hb_codepoint_t>& p)
-                     {
+		     {
-                       return plan->unicodes->has (p.first) ||
+		       return plan->unicodes->has (p.first) ||
-                              plan->glyphs_requested->has (p.second);
+			      plan->glyphs_requested->has (p.second);
-                     })
+		     })
-        | hb_map ([plan] (const hb_pair_t<hb_codepoint_t, hb_codepoint_t>& p_org)
+	| hb_map ([plan] (const hb_pair_t<hb_codepoint_t, hb_codepoint_t>& p_org)
-                  {
+		  {
-                    return hb_pair_t<hb_codepoint_t, hb_codepoint_t> (p_org.first, plan->glyph_map->get(p_org.second));
+		    return hb_pair_t<hb_codepoint_t, hb_codepoint_t> (p_org.first, plan->glyph_map->get(p_org.second));
-                  })
+		  })
-        ;
+	;
 
-        if (format == 4) c->copy (_, table_iter, 4u, base, plan, &format4objidx);
+	if (format == 4) c->copy (_, table_iter, 4u, base, plan, &format4objidx);
-        else if (format == 12) c->copy (_, table_iter, 12u, base, plan, &format12objidx);
+	else if (format == 12) c->copy (_, table_iter, 12u, base, plan, &format12objidx);
-        else if (format == 14) c->copy (_, table_iter, 14u, base, plan, &format14objidx);
+	else if (format == 14) c->copy (_, table_iter, 14u, base, plan, &format14objidx);
       }
       /* when --gids option is not used, we iterate input unicodes instead of
        * all codepoints in each subtable, which is more efficient */
       else
       {
-        hb_set_t unicodes_set;
+	hb_set_t unicodes_set;
-        (base+_.subtable).collect_unicodes (&unicodes_set);
+	(base+_.subtable).collect_unicodes (&unicodes_set);
 
-        if (format == 4) c->copy (_, + it | hb_filter (unicodes_set, hb_first), 4u, base, plan, &format4objidx);
+	if (format == 4) c->copy (_, + it | hb_filter (unicodes_set, hb_first), 4u, base, plan, &format4objidx);
-        else if (format == 12) c->copy (_, + it | hb_filter (unicodes_set, hb_first), 12u, base, plan, &format12objidx);
+	else if (format == 12) c->copy (_, + it | hb_filter (unicodes_set, hb_first), 12u, base, plan, &format12objidx);
-        else if (format == 14) c->copy (_, it, 14u, base, plan, &format14objidx);
+	else if (format == 14) c->copy (_, it, 14u, base, plan, &format14objidx);
       }
     }
 

src/hb-ot-layout-common.hh

@@ -963,7 +963,7 @@ struct Feature
 
     out->lookupIndex.serialize (c->serializer, l, it);
     return_trace (bool (it) || subset_featureParams
-                  || (tag && *tag == HB_TAG ('p', 'r', 'e', 'f')));
+		  || (tag && *tag == HB_TAG ('p', 'r', 'e', 'f')));
   }
 
   bool sanitize (hb_sanitize_context_t *c,
@@ -2527,9 +2527,9 @@ struct VariationStore
 
       if (major >= inner_maps.length)
       {
-        for (unsigned i = 0; i < inner_maps.length; i++)
+	for (unsigned i = 0; i < inner_maps.length; i++)
-          inner_maps[i].fini ();
+	  inner_maps[i].fini ();
-        return_trace (false);
+	return_trace (false);
       }
       inner_maps[major].add (minor);
     }

src/hb-ot-layout-gdef-table.hh

@@ -205,7 +205,7 @@ struct CaretValueFormat3
     if (unlikely (!out)) return_trace (false);
 
     return_trace (out->deviceTable.serialize_copy (c->serializer, deviceTable, this, c->serializer->to_bias (out),
-                                                   hb_serialize_context_t::Head, c->plan->layout_variation_idx_map));
+						   hb_serialize_context_t::Head, c->plan->layout_variation_idx_map));
   }
 
   void collect_variation_indices (hb_set_t *layout_variation_indices) const
@@ -626,8 +626,8 @@ struct GDEF
       if (major >= (this+varStore).get_sub_table_count ()) break;
       if (major != last_major)
       {
-        new_minor = 0;
+	new_minor = 0;
-        ++new_major;
+	++new_major;
       }
 
       unsigned new_idx = (new_major << 16) + new_minor;
@@ -653,8 +653,8 @@ struct GDEF
     {
       subset_markglyphsetsdef = out->markGlyphSetsDef.serialize_subset (c, markGlyphSetsDef, this);
       if (!subset_markglyphsetsdef &&
-          version.to_int () == 0x00010002u)
+	  version.to_int () == 0x00010002u)
-        out->version.minor = 0;
+	out->version.minor = 0;
     }
 
     bool subset_varstore = true;
@@ -662,13 +662,13 @@ struct GDEF
     {
       subset_varstore = out->varStore.serialize_subset (c, varStore, this);
       if (!subset_varstore && version.to_int () == 0x00010003u)
-        out->version.minor = 2;
+	out->version.minor = 2;
     }
 
     return_trace (subset_glyphclassdef || subset_attachlist ||
-                  subset_ligcaretlist || subset_markattachclassdef ||
+		  subset_ligcaretlist || subset_markattachclassdef ||
-                  (out->version.to_int () >= 0x00010002u && subset_markglyphsetsdef) ||
+		  (out->version.to_int () >= 0x00010002u && subset_markglyphsetsdef) ||
-                  (out->version.to_int () >= 0x00010003u && subset_varstore));
+		  (out->version.to_int () >= 0x00010003u && subset_varstore));
   }
 
   bool sanitize (hb_sanitize_context_t *c) const

src/hb-ot-layout-gpos-table.hh

@@ -161,7 +161,7 @@ struct ValueFormat : HBUINT16
   }
 
   void serialize_copy (hb_serialize_context_t *c, const void *base,
-                       const Value *values, const hb_map_t *layout_variation_idx_map) const
+		       const Value *values, const hb_map_t *layout_variation_idx_map) const
   {
     unsigned int format = *this;
     if (!format) return;
@@ -178,8 +178,8 @@ struct ValueFormat : HBUINT16
   }
 
   void collect_variation_indices (hb_collect_variation_indices_context_t *c,
-                                  const void *base,
+				  const void *base,
-                                  const hb_array_t<const Value>& values) const
+				  const hb_array_t<const Value>& values) const
   {
     unsigned format = *this;
     unsigned i = 0;
@@ -243,7 +243,7 @@ struct ValueFormat : HBUINT16
   }
 
   bool copy_device (hb_serialize_context_t *c, const void *base,
-                    const Value *src_value, const hb_map_t *layout_variation_idx_map) const
+		    const Value *src_value, const hb_map_t *layout_variation_idx_map) const
   {
     Value	*dst_value = c->copy (*src_value);
 
@@ -324,7 +324,7 @@ static void SinglePos_serialize (hb_serialize_context_t *c,
 				 const void *src,
 				 Iterator it,
 				 ValueFormat valFormat,
-                                 const hb_map_t *layout_variation_idx_map);
+				 const hb_map_t *layout_variation_idx_map);
 
 
 struct AnchorFormat1
@@ -545,7 +545,7 @@ struct AnchorMatrix
   bool serialize (hb_serialize_context_t *c,
 		  unsigned                num_rows,
 		  AnchorMatrix const     *offset_matrix,
-                  const hb_map_t         *layout_variation_idx_map,
+		  const hb_map_t         *layout_variation_idx_map,
 		  Iterator                index_iter)
   {
     TRACE_SERIALIZE (this);
@@ -558,9 +558,9 @@ struct AnchorMatrix
       auto *offset = c->embed (offset_matrix->matrixZ[i]);
       if (!offset) return_trace (false);
       offset->serialize_copy (c, offset_matrix->matrixZ[i],
-                              offset_matrix, c->to_bias (this),
+			      offset_matrix, c->to_bias (this),
-                              hb_serialize_context_t::Head,
+			      hb_serialize_context_t::Head,
-                              layout_variation_idx_map);
+			      layout_variation_idx_map);
     }
 
     return_trace (true);
@@ -668,7 +668,7 @@ struct MarkArray : ArrayOf<MarkRecord>	/* Array of MarkRecords--in Coverage orde
 	   hb_requires (hb_is_source_of (Iterator, MarkRecord))>
   bool serialize (hb_serialize_context_t *c,
 		  const hb_map_t         *klass_mapping,
-                  const hb_map_t         *layout_variation_idx_map,
+		  const hb_map_t         *layout_variation_idx_map,
 		  const void             *base,
 		  Iterator                it)
   {
@@ -732,7 +732,7 @@ struct SinglePosFormat1
 		  const void *src,
 		  Iterator it,
 		  ValueFormat valFormat,
-                  const hb_map_t *layout_variation_idx_map)
+		  const hb_map_t *layout_variation_idx_map)
   {
     auto out = c->extend_min (*this);
     if (unlikely (!out)) return;
@@ -813,7 +813,7 @@ struct SinglePosFormat2
     const hb_array_t<const Value> values_array = values.as_array (valueCount * sub_length);
 
     for (unsigned i : + it
-                      | hb_map (hb_second))
+		      | hb_map (hb_second))
       valueFormat.collect_variation_indices (c, this, values_array.sub_array (i * sub_length, sub_length));
 
   }
@@ -846,7 +846,7 @@ struct SinglePosFormat2
 		  const void *src,
 		  Iterator it,
 		  ValueFormat valFormat,
-                  const hb_map_t *layout_variation_idx_map)
+		  const hb_map_t *layout_variation_idx_map)
   {
     auto out = c->extend_min (*this);
     if (unlikely (!out)) return;
@@ -937,7 +937,7 @@ struct SinglePos
 		  const void *src,
 		  Iterator glyph_val_iter_pairs,
 		  ValueFormat valFormat,
-                  const hb_map_t *layout_variation_idx_map)
+		  const hb_map_t *layout_variation_idx_map)
   {
     if (unlikely (!c->extend_min (u.format))) return;
     unsigned format = 2;
@@ -980,7 +980,7 @@ SinglePos_serialize (hb_serialize_context_t *c,
 		     const void *src,
 		     Iterator it,
 		     ValueFormat valFormat,
-                     const hb_map_t *layout_variation_idx_map)
+		     const hb_map_t *layout_variation_idx_map)
 { c->start_embed<SinglePos> ()->serialize (c, src, it, valFormat, layout_variation_idx_map); }
 
 
@@ -1016,8 +1016,8 @@ struct PairValueRecord
   }
 
   void collect_variation_indices (hb_collect_variation_indices_context_t *c,
-                                  const ValueFormat *valueFormats,
+				  const ValueFormat *valueFormats,
-                                  const void *base) const
+				  const void *base) const
   {
     unsigned record1_len = valueFormats[0].get_len ();
     unsigned record2_len = valueFormats[1].get_len ();
@@ -1074,7 +1074,7 @@ struct PairSet
   }
 
   void collect_variation_indices (hb_collect_variation_indices_context_t *c,
-                                  const ValueFormat *valueFormats) const
+				  const ValueFormat *valueFormats) const
   {
     unsigned len1 = valueFormats[0].get_len ();
     unsigned len2 = valueFormats[1].get_len ();
@@ -1355,12 +1355,12 @@ struct PairPosFormat2
     {
       for (const unsigned class2_idx : class2_set.iter ())
       {
-        unsigned start_offset = (class1_idx * (unsigned) class2Count + class2_idx) * (len1 + len2);
+	unsigned start_offset = (class1_idx * (unsigned) class2Count + class2_idx) * (len1 + len2);
-        if (valueFormat1.has_device ())
+	if (valueFormat1.has_device ())
-          valueFormat1.collect_variation_indices (c, this, values_array.sub_array (start_offset, len1));
+	  valueFormat1.collect_variation_indices (c, this, values_array.sub_array (start_offset, len1));
 
-        if (valueFormat2.has_device ())
+	if (valueFormat2.has_device ())
-          valueFormat2.collect_variation_indices (c, this, values_array.sub_array (start_offset+len1, len2));
+	  valueFormat2.collect_variation_indices (c, this, values_array.sub_array (start_offset+len1, len2));
       }
     }
   }
@@ -1428,17 +1428,17 @@ struct PairPosFormat2
     + hb_range ((unsigned) class1Count)
     | hb_filter (klass1_map)
     | hb_apply ([&] (const unsigned class1_idx)
-                {
+		{
-                  + hb_range ((unsigned) class2Count)
+		  + hb_range ((unsigned) class2Count)
-                  | hb_filter (klass2_map)
+		  | hb_filter (klass2_map)
-                  | hb_apply ([&] (const unsigned class2_idx)
+		  | hb_apply ([&] (const unsigned class2_idx)
-                              {
+			      {
-                                unsigned idx = (class1_idx * (unsigned) class2Count + class2_idx) * (len1 + len2);
+				unsigned idx = (class1_idx * (unsigned) class2Count + class2_idx) * (len1 + len2);
-                                valueFormat1.serialize_copy (c->serializer, this, &values[idx], c->plan->layout_variation_idx_map);
+				valueFormat1.serialize_copy (c->serializer, this, &values[idx], c->plan->layout_variation_idx_map);
-                                valueFormat2.serialize_copy (c->serializer, this, &values[idx + len1], c->plan->layout_variation_idx_map);
+				valueFormat2.serialize_copy (c->serializer, this, &values[idx + len1], c->plan->layout_variation_idx_map);
-                              })
+			      })
-                  ;
+		  ;
-                })
+		})
     ;
 
     const hb_set_t &glyphset = *c->plan->_glyphset_gsub;
@@ -1547,7 +1547,7 @@ struct EntryExitRecord
   EntryExitRecord* copy (hb_serialize_context_t *c,
 			 const void *src_base,
 			 const void *dst_base,
-                         const hb_map_t *layout_variation_idx_map) const
+			 const hb_map_t *layout_variation_idx_map) const
   {
     TRACE_SERIALIZE (this);
     auto *out = c->embed (this);
@@ -1707,7 +1707,7 @@ struct CursivePosFormat1
   void serialize (hb_serialize_context_t *c,
 		  Iterator it,
 		  const void *src_base,
-                  const hb_map_t *layout_variation_idx_map)
+		  const hb_map_t *layout_variation_idx_map)
   {
     if (unlikely (!c->extend_min ((*this)))) return;
     this->format = 1;
@@ -2065,11 +2065,11 @@ struct MarkLigPosFormat1
       unsigned row_count = lig_array[i].rows;
       for (unsigned row : + hb_range (row_count))
       {
-        + hb_range ((unsigned) classCount)
+	+ hb_range ((unsigned) classCount)
-        | hb_filter (klass_mapping)
+	| hb_filter (klass_mapping)
-        | hb_map ([&] (const unsigned col) { return row * (unsigned) classCount + col; })
+	| hb_map ([&] (const unsigned col) { return row * (unsigned) classCount + col; })
-        | hb_sink (lig_indexes)
+	| hb_sink (lig_indexes)
-        ;
+	;
       }
 
       lig_array[i].collect_variation_indices (c, lig_indexes.iter ());

src/hb-ot-layout-gsub-table.hh

@@ -1575,8 +1575,8 @@ struct GSUB : GSUBGPOS
 				   hb_face_t *face) const;
 
   void closure_lookups (hb_face_t      *face,
-                        const hb_set_t *glyphs,
+			const hb_set_t *glyphs,
-                        hb_set_t       *lookup_indexes /* IN/OUT */) const
+			hb_set_t       *lookup_indexes /* IN/OUT */) const
   { GSUBGPOS::closure_lookups<SubstLookup> (face, glyphs, lookup_indexes); }
 
   typedef GSUBGPOS::accelerator_t<GSUB> accelerator_t;

src/hb-ot-layout-gsubgpos.hh

@@ -1446,7 +1446,7 @@ struct Rule
     }
 
     const UnsizedArrayOf<LookupRecord> &lookupRecord = StructAfter<UnsizedArrayOf<LookupRecord>>
-                                                       (inputZ.as_array ((inputCount ? inputCount - 1 : 0)));
+						       (inputZ.as_array ((inputCount ? inputCount - 1 : 0)));
     for (unsigned i = 0; i < (unsigned) lookupCount; i++)
       c->copy (lookupRecord[i], lookup_map);
 
@@ -1582,8 +1582,8 @@ struct RuleSet
       auto o_snap = c->serializer->snapshot ();
       if (!o->serialize_subset (c, _, this, lookup_map, klass_map))
       {
-        out->rule.pop ();
+	out->rule.pop ();
-        c->serializer->revert (o_snap);
+	c->serializer->revert (o_snap);
       }
     }
 
@@ -1715,7 +1715,7 @@ struct ContextFormat1
     ;
 
     out->coverage.serialize (c->serializer, out)
-                 .serialize (c->serializer, new_coverage.iter ());
+		 .serialize (c->serializer, new_coverage.iter ());
     return_trace (bool (new_coverage));
   }
 
@@ -1863,12 +1863,12 @@ struct ContextFormat2
       auto *o = out->ruleSet.serialize_append (c->serializer);
       if (unlikely (!o))
       {
-        ret = false;
+	ret = false;
-        break;
+	break;
       }
 
       if (o->serialize_subset (c, _.second, this, lookup_map, &klass_map))
-        non_zero_index = index;
+	non_zero_index = index;
 
       index++;
     }
@@ -2803,7 +2803,7 @@ struct ChainContextFormat2
 			       &backtrack_klass_map,
 			       &input_klass_map,
 			       &lookahead_klass_map))
-        non_zero_index = index;
+	non_zero_index = index;
 
       index++;
     }
@@ -3259,7 +3259,7 @@ struct GSUBGPOS
   template <typename TLookup>
   void closure_lookups (hb_face_t      *face,
 			const hb_set_t *glyphs,
-                        hb_set_t       *lookup_indexes /* IN/OUT */) const
+			hb_set_t       *lookup_indexes /* IN/OUT */) const
   {
     hb_set_t visited_lookups, inactive_lookups;
     OT::hb_closure_lookups_context_t c (face, glyphs, &visited_lookups, &inactive_lookups);
@@ -3319,7 +3319,7 @@ struct GSUBGPOS
     {
       const Feature& f = get_feature (i);
       if ((!f.featureParams.is_null ()) || f.intersects_lookup_indexes (lookup_indexes))
-        feature_indexes->add (i);
+	feature_indexes->add (i);
     }
 #ifndef HB_NO_VAR
     if (version.to_int () >= 0x00010001u)

src/hb-subset-plan.cc

@@ -146,7 +146,7 @@ static inline void
     gpos->collect_variation_indices (&c);
 
   gdef->remap_layout_variation_indices (layout_variation_indices, layout_variation_idx_map);
-  
+
   gdef.destroy ();
   gpos.destroy ();
 }
@@ -181,7 +181,7 @@ _populate_gids_to_retain (hb_subset_plan_t* plan,
 			  const hb_set_t *input_glyphs_to_retain,
 			  bool close_over_gsub,
 			  bool close_over_gpos,
-                          bool close_over_gdef)
+	                  bool close_over_gdef)
 {
   OT::cmap::accelerator_t cmap;
   OT::glyf::accelerator_t glyf;
@@ -315,9 +315,8 @@ hb_subset_plan_create (hb_face_t         *face,
 		       hb_subset_input_t *input)
 {
   hb_subset_plan_t *plan;
-  if (unlikely (!(plan = hb_object_create<hb_subset_plan_t> ()))) {
+  if (unlikely (!(plan = hb_object_create<hb_subset_plan_t> ())))
     return const_cast<hb_subset_plan_t *> (&Null (hb_subset_plan_t));
-  }
 
   plan->successful = true;
   plan->drop_hints = input->drop_hints;

src/hb-subset-plan.hh

@@ -90,10 +90,7 @@ struct hb_subset_plan_t
 
  public:
 
-  bool in_error () const
+  bool in_error () const { return !successful; }
-  {
-    return !successful;
-  }
 
   /*
    * The set of input glyph ids which will be retained in the subset.

util/options-subset.cc

@@ -53,7 +53,7 @@ parse_gids (const char *name G_GNUC_UNUSED,
     {
       hb_set_destroy (gids);
       g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
-                   "Failed parsing gids values at: '%s'", s);
+		   "Failed parsing gids values at: '%s'", s);
       return false;
     }