From cf872f3053dd5b0af7b3b4f583bcce9d5bb953c2 Mon Sep 17 00:00:00 2001

From: Tim Eves <tim_eves@sil.org>

Date: Wed, 5 Jul 2017 21:27:03 +0700

Subject: [PATCH] Fix stricter gcc warnings

Also get rid of auto_ptr from comparerenderer

---

 src/gr_logging.cpp                        |   2 +-

 tests/comparerenderer/RenderedLine.h | 14 ++++++--------

 tests/comparerenderer/Gr2Renderer.h | 166 ++++++++++++++--------------

diff --git a/src/gr_logging.cpp b/src/gr_logging.cpp

index 3e453ba..b75a394 100644

--- a/src/gr_logging.cpp

+++ b/src/gr_logging.cpp

@@ -214,7 +214,7 @@ json & graphite2::operator << (json & j, const dslot & ds) throw()

     j << "user" << json::flat << json::array;

     for (int n = 0; n!= seg.numAttrs(); ++n)

         j   << s.userAttrs()[n];

-        j   << json::close;

+    j       << json::close;

     if (s.firstChild())

     {

         j   << "children" << json::flat << json::array;

diff --git a/tests/comparerenderer/RenderedLine.h b/tests/comparerenderer/RenderedLine.h

index fb8398d..649fb63 100644

--- a/tests/comparerenderer/RenderedLine.h

+++ b/tests/comparerenderer/RenderedLine.h

@@ -99,9 +99,9 @@ class RenderedLine

 {

     public:

         RenderedLine()

-        : m_text(NULL), m_numGlyphs(0), m_advance(0), m_glyphs(NULL)

+        : m_numGlyphs(0), m_advance(0), m_glyphs(NULL)

         {}

-        RenderedLine(std::string *text, size_t numGlyphs, float adv = 0.0f)

+        RenderedLine(const std::string & text, size_t numGlyphs, float adv = 0.0f)

         : m_text(text), m_numGlyphs(numGlyphs), m_advance(adv), m_glyphs(new GlyphInfo[numGlyphs])

         {

         }

@@ -109,12 +109,11 @@ class RenderedLine

         {

             delete [] m_glyphs;

             m_glyphs = NULL;

-            delete m_text;

         }

         void setAdvance(float newAdv) { m_advance = newAdv; }

         void dump(FILE * f)

         {

-            fprintf(f, "{\"%s\" : [", m_text->c_str());

+            fprintf(f, "{\"%s\" : [", m_text.c_str());

             for (size_t i = 0; i < m_numGlyphs; i++)

             {

                 //fprintf(f, "%2u", (unsigned int)i);

@@ -157,9 +156,8 @@ class RenderedLine

             return true;

         }

     private:

-        size_t m_numGlyphs;

-        float m_advance;

+        size_t      m_numGlyphs;

+        float       m_advance;

         GlyphInfo * m_glyphs;

-        std::string * m_text;

+        std::string m_text;

 };

-

-- 

diff --git a/tests/comparerenderer/Gr2Renderer.h b/tests/comparerenderer/Gr2Renderer.h

index dfce31b..8aaeddc 100644

--- a/tests/comparerenderer/Gr2Renderer.h

+++ b/tests/comparerenderer/Gr2Renderer.h

@@ -22,6 +22,7 @@

 #pragma once

 #include <new>

+#include <iostream>

 #include <memory>

 #include <string>

 #include "Renderer.h"

@@ -30,99 +31,102 @@

 #include <graphite2/Segment.h>

 #include <graphite2/Log.h>

-class Gr2Face : private std::auto_ptr<gr_face>

+

+using gr_face_ptr = std::unique_ptr<gr_face, decltype(&gr_face_destroy)>;

+using gr_font_ptr = std::unique_ptr<gr_font, decltype(&gr_font_destroy)>;

+using gr_feature_val_ptr = std::unique_ptr<gr_feature_val, decltype(&gr_featureval_destroy)>;

+using gr_segment_ptr = std::unique_ptr<gr_segment, decltype(&gr_seg_destroy)>;

+

+class Gr2Face : public gr_face_ptr

 {

 public:

 	Gr2Face(const char * fontFile, const std::string & logPath, const bool demand_load)

-    :  std::auto_ptr<gr_face>(gr_make_file_face(fontFile, !demand_load ? gr_face_preloadGlyphs : gr_face_default))

+	: gr_face_ptr(gr_make_file_face(fontFile,

+			!demand_load ? gr_face_preloadGlyphs : gr_face_default),

+		&gr_face_destroy)

 	{

-        if (!get()) return;

-

-    	if (logPath.size())	gr_start_logging(get(), logPath.c_str());

+		if (*this && logPath.size())	gr_start_logging(get(), logPath.c_str());

 	}

+	Gr2Face(Gr2Face && f): gr_face_ptr(std::move(f)) {}

+

 	~Gr2Face() throw()

 	{

-    	gr_stop_logging(get());

-        gr_face_destroy(get());

-        release();

+		gr_stop_logging(get());

 	}

-

-	operator bool () const		{ return get() != 0; }

-	operator gr_face* () const	{ return get(); }

 };

 class Gr2Renderer : public Renderer

 {

 public:

-    Gr2Renderer(Gr2Face & face, int fontSize, int textDir, FeatureParser * features)

-	: m_rtl(textDir),

-	  m_grFace(face),

-	  m_grFont(0),

-	  m_grFeatures(0)

-    {

-        if (m_grFace)

-        {

-            m_grFont = gr_make_font(static_cast<float>(fontSize), m_grFace);

-            if (features)

-            {

-                m_grFeatures = gr_face_featureval_for_lang(m_grFace, features->langId());

-                for (size_t i = 0; i < features->featureCount(); i++)

-                {

-                    const gr_feature_ref * ref = gr_face_find_fref(m_grFace, features->featureId(i));

-                    if (ref)

-                        gr_fref_set_feature_value(ref, features->featureSValue(i), m_grFeatures);

-                }

-            }

-            else

-            {

-                m_grFeatures = gr_face_featureval_for_lang(m_grFace, 0);

-            }

-        }

-        m_name = "graphite2";

-    }

-    virtual ~Gr2Renderer()

-    {

-        gr_featureval_destroy(m_grFeatures);

-        gr_font_destroy(m_grFont);

-    }

-

-    virtual void renderText(const char * utf8, size_t length, RenderedLine * result, FILE *log)

-    {

-        const void * pError = NULL;

-        if (!m_grFace)

-        {

-            new(result) RenderedLine();

-            return;

-        }

-        size_t numCodePoints = gr_count_unicode_characters(gr_utf8,

-            reinterpret_cast<const void*>(utf8), reinterpret_cast<const void*>(utf8 + length), &pError);

-        if (pError)

-            fprintf(stderr, "Invalid Unicode pos %d\n", static_cast<int>(reinterpret_cast<const char*>(pError) - utf8));

-        gr_segment* pSeg = gr_make_seg(m_grFont, m_grFace, 0u, m_grFeatures, gr_utf8, utf8, numCodePoints, m_rtl ? 1 : 0);

-        if (!pSeg)

-        {

-            fprintf(stderr, "Failed to create segment\n");

-            new(result) RenderedLine(0, .0f);

-            return;

-        }

-        std::string *s = new std::string(utf8, length);

-        RenderedLine * renderedLine = new(result) RenderedLine(s, gr_seg_n_slots(pSeg),

-                                                               gr_seg_advance_X(pSeg));

-        int i = 0;

-        for (const gr_slot* s = gr_seg_first_slot(pSeg); s;

-             s = gr_slot_next_in_segment(s), ++i)

-            (*renderedLine)[i].set(gr_slot_gid(s), gr_slot_origin_X(s),

-                                   gr_slot_origin_Y(s), gr_slot_before(s),

-                                   gr_slot_after(s));

-        gr_seg_destroy(pSeg);

-    }

-    virtual const char * name() const { return m_name; }

-private:

-    int m_rtl;

-    Gr2Face   m_grFace;

-    gr_font * m_grFont;

-    gr_feature_val * m_grFeatures;

-    const char * m_name;

-};

+	Gr2Renderer(Gr2Face & face, int fontSize, bool rtl, FeatureParser * features)

+	: m_rtl(rtl),

+		m_grFace(std::move(face)),

+		m_grFont(nullptr, &gr_font_destroy),

+		m_grFeatures(nullptr, gr_featureval_destroy),

+		m_name("graphite2")

+	{

+		if (!m_grFace)

+			return;

+

+		m_grFont.reset(gr_make_font(static_cast<float>(fontSize), m_grFace.get()));

+		if (features)

+		{

+			m_grFeatures.reset(gr_face_featureval_for_lang(m_grFace.get(), features->langId()));

+			for (size_t i = 0; i < features->featureCount(); i++)

+			{

+				const gr_feature_ref * ref = gr_face_find_fref(m_grFace.get(), features->featureId(i));

+				if (ref)

+				gr_fref_set_feature_value(ref, features->featureSValue(i), m_grFeatures.get());

+			}

+		}

+		else

+		{

+			m_grFeatures.reset(gr_face_featureval_for_lang(m_grFace.get(), 0));

+		}

+	}

+

+	virtual void renderText(const char * utf8, size_t length, RenderedLine * result, FILE *log)

+	{

+		const void * pError = NULL;

+		if (!m_grFace)

+		{

+			new (result) RenderedLine();

+			return;

+		}

+		size_t numCodePoints = gr_count_unicode_characters(gr_utf8, utf8, utf8 + length, &pError);

+		if (pError)

+			std::cerr << "Invalid Unicode pos" << int(static_cast<const char*>(pError) - utf8) << std::endl;

+

+		gr_segment_ptr pSeg = gr_segment_ptr(

+				gr_make_seg(m_grFont.get(), m_grFace.get(), 0u, m_grFeatures.get(),

+										gr_utf8, utf8, numCodePoints, m_rtl),

+				&gr_seg_destroy);

+

+		if (!pSeg)

+		{

+			std::cerr << "Failed to create segment" << std::endl;

+			new (result) RenderedLine(0, .0f);

+			return;

+		}

+

+		RenderedLine * renderedLine = new (result) RenderedLine(std::string(utf8, length), gr_seg_n_slots(pSeg.get()),

+																															 gr_seg_advance_X(pSeg.get()));

+		const gr_slot * s = gr_seg_first_slot(pSeg.get());

+		for (int i = 0; s; ++i)

+		{

+			(*renderedLine)[i].set(gr_slot_gid(s), gr_slot_origin_X(s),

+														gr_slot_origin_Y(s), gr_slot_before(s),

+														gr_slot_after(s));

+			s = gr_slot_next_in_segment(s);

+		}

+	}

+	virtual const char * name() const { return m_name; }

+	private:

+		Gr2Face 						m_grFace;

+		const char * const 	m_name;

+		bool 					 			m_rtl;

+		gr_font_ptr 				m_grFont;

+		gr_feature_val_ptr	m_grFeatures;

+	};

-- 

2.17.0