Skip site navigation (1)Skip section navigation (2)
Date:      Wed, 30 Apr 2014 10:36:59 GMT
From:      Shambler <shambler@gmx.us>
To:        freebsd-gnats-submit@FreeBSD.org
Subject:   misc/189134: ctpp2 fixed compilation on freebsd 10
Message-ID:  <201404301036.s3UAax3q092054@cgiserv.freebsd.org>
Resent-Message-ID: <201404301040.s3UAe0QL044912@freefall.freebsd.org>

next in thread | raw e-mail | index | archive | help

>Number:         189134
>Category:       misc
>Synopsis:       ctpp2 fixed compilation on freebsd 10
>Confidential:   no
>Severity:       non-critical
>Priority:       low
>Responsible:    freebsd-bugs
>State:          open
>Quarter:        
>Keywords:       
>Date-Required:
>Class:          sw-bug
>Submitter-Id:   current-users
>Arrival-Date:   Wed Apr 30 10:40:00 UTC 2014
>Closed-Date:
>Last-Modified:
>Originator:     Shambler
>Release:        FreeBSD 10.0-RELEASE
>Organization:
Home
>Environment:
FreeBSD 10.0-RELEASE FreeBSD 10.0-RELEASE #0 r260789: Thu Jan 16 22:34:59 UTC 2014     root@snap.freebsd.org:/usr/obj/usr/src/sys/GENERIC  amd64
>Description:
ctpp2 not be compiled on 10 Freebsd using clang 3.3.
Few errors and all connected with the peculiarities ctpp2
>How-To-Repeat:
cd /usr/ports/textproc/ctpp2
sudo make install clean
:)
>Fix:
Attached patch.

Patch attached with submission follows:

--- ../../ctpp2.orig/include/CDT.hpp	2012-11-11 01:45:43.000000000 +0400
+++ ../include/CDT.hpp	2014-04-30 14:08:29.000000000 +0400
@@ -48,13 +48,16 @@
 
 #define C_MAX_SPRINTF_LENGTH 128
 
+class CTPP2DECL CDTConstIterator;
+class CTPP2DECL CDTIterator;
+
 /**
   @class CDT CDT.hpp <CDT.hpp>
   @brief Common Data Type
 */
 class CTPP2DECL CDT
 {
-private:
+public:
 	/**
 	  @var typedef STLW::string<CDT> String
 	  @brief internal string definition
@@ -72,7 +75,7 @@
 	  @brief internal hash definition
 	*/
 	typedef STLW::map<String, CDT>  Map;
-public:
+
 	/**
 	  @enum eValType CDT.hpp <CDT.hpp>
 	  @brief Describes type of stored value
@@ -1768,172 +1771,39 @@
 		virtual ~SortingComparator() throw();
 	};
 
-	// FWD
-	class CTPP2DECL ConstIterator;
-
-	/**
-	  @class Iterator CDT.hpp <CDT.hpp>
-	  @brief CDT[HASH] forward iterator
-	*/
-	class CTPP2DECL Iterator
-	{
-	private:
-		friend class CDT;
-		friend class ConstIterator;
-
-		/** Hash iterator */
-		CDT::Map::iterator itMap;
-
-		/**
-		  @brief Constructor
-		  @param itIMap - map iterator
-		*/
-		Iterator(CDT::Map::iterator itIMap);
-	public:
-		/**
-		  @brief Copy constructor
-		  @param oRhs - object to copy
-		*/
-		Iterator(const Iterator & oRhs);
-
-		/**
-		  @brief Operator =
-		  @param oRhs - object to copy
-		*/
-		Iterator & operator=(const Iterator & oRhs);
-
-		/**
-		  @brief Pre-increment operator ++
-		*/
-		Iterator & operator++();
-
-		/**
-		  @brief Post-increment operator ++
-		*/
-		Iterator operator++(int);
-
-		/**
-		  @brief Access operator
-		  @return Pair of key => value
-		*/
-		STLW::pair<const STLW::string, CDT> * operator->();
-
-		/**
-		  @brief Comparison operator
-		  @param oRhs - object to compare
-		  @return true if objects are equal
-		*/
-		bool operator ==(const Iterator & oRhs);
-
-		/**
-		  @brief Comparison operator
-		  @param oRhs - object to compare
-		  @return true if objects are NOT equal
-		*/
-		bool operator !=(const Iterator & oRhs);
-	};
-
 	/**
 	  @brief Get iterator pointed to start of hash
 	*/
-	Iterator Begin();
+	CDTIterator Begin();
 
 	/**
 	  @brief Get iterator pointed to end of hash
 	*/
-	Iterator End();
+	CDTIterator End();
 
 	/**
 	  @brief Find element in hash
 	  @param sKey - element name
 	  @return Iterator pointed to element or to end of hash if nothing found
 	*/
-	Iterator Find(const STLW::string & sKey);
-
-	/**
-	  @class ConstIterator CDT.hpp <CDT.hpp>
-	  @brief CDT[HASH] forward constant iterator
-	*/
-	class CTPP2DECL ConstIterator
-	{
-	private:
-		friend class CDT;
-
-		/** Hash iterator */
-		CDT::Map::const_iterator itMap;
-
-	public:
-		/**
-		  @brief Copy constructor
-		  @param oRhs - object to copy
-		*/
-		ConstIterator(const ConstIterator & oRhs);
-
-		/**
-		  @brief Type cast constructor
-		  @param oRhs - object to copy
-		*/
-		ConstIterator(const Iterator & oRhs);
-
-		/**
-		  @brief Operator =
-		  @param oRhs - object to copy
-		*/
-		ConstIterator & operator=(const ConstIterator & oRhs);
-
-		/**
-		  @brief Operator =
-		  @param oRhs - object to copy
-		*/
-		ConstIterator & operator=(const Iterator & oRhs);
-
-		/**
-		  @brief Pre-increment operator ++
-		*/
-		ConstIterator & operator++();
-
-		/**
-		  @brief Post-increment operator ++
-		*/
-		ConstIterator operator++(int);
-
-		/**
-		  @brief Access operator
-		  @return Pair of key => value
-		*/
-		const STLW::pair<const STLW::string, CDT> * operator->() const;
-
-		/**
-		  @brief Comparison operator
-		  @param oRhs - object to compare
-		  @return true if objects are equal
-		*/
-		bool operator ==(const ConstIterator & oRhs) const;
-
-		/**
-		  @brief Comparison operator
-		  @param oRhs - object to compare
-		  @return true if objects are NOT equal
-		*/
-		bool operator !=(const ConstIterator & oRhs) const;
-	};
+	CDTIterator Find(const STLW::string & sKey);
 
 	/**
 	  @brief Get constant iterator pointed to start of hash
 	*/
-	ConstIterator Begin() const;
+	CDTConstIterator Begin() const;
 
 	/**
 	  @brief Get constant iterator pointed to end of hash
 	*/
-	ConstIterator End() const;
+	CDTConstIterator End() const;
 
 	/**
 	  @brief Find element in hash
 	  @param sKey - element name
 	  @return Iterator pointed to element or to end of hash if nothing found
 	*/
-	ConstIterator Find(const STLW::string & sKey) const;
+	CDTConstIterator Find(const STLW::string & sKey) const;
 
 	/**
 	  @brief Try to cast value to integer or to IEEE floating point value
@@ -2009,6 +1879,139 @@
 
 };
 
+
+/**
+  @class CDTIterator CDT.hpp <CDT.hpp>
+  @brief CDT[HASH] forward iterator
+*/
+class CTPP2DECL CDTIterator
+{
+private:
+	friend class CDT;
+	friend class CDTConstIterator;
+
+	/** Hash iterator */
+	CDT::Map::iterator itMap;
+
+	/**
+	  @brief Constructor
+	  @param itIMap - map iterator
+	*/
+	CDTIterator(CDT::Map::iterator itIMap);
+public:
+	/**
+	  @brief Copy constructor
+	  @param oRhs - object to copy
+	*/
+	CDTIterator(const CDTIterator & oRhs);
+
+	/**
+	  @brief Operator =
+	  @param oRhs - object to copy
+	*/
+	CDTIterator & operator=(const CDTIterator & oRhs);
+
+	/**
+	  @brief Pre-increment operator ++
+	*/
+	CDTIterator & operator++();
+
+	/**
+	  @brief Post-increment operator ++
+	*/
+	CDTIterator operator++(int);
+
+	/**
+	  @brief Access operator
+	  @return Pair of key => value
+	*/
+	STLW::pair<const STLW::string, CDT> * operator->();
+
+	/**
+	  @brief Comparison operator
+	  @param oRhs - object to compare
+	  @return true if objects are equal
+	*/
+	bool operator ==(const CDTIterator & oRhs);
+
+	/**
+	  @brief Comparison operator
+	  @param oRhs - object to compare
+	  @return true if objects are NOT equal
+	*/
+	bool operator !=(const CDTIterator & oRhs);
+};
+
+
+/**
+  @class CDTConstIterator CDT.hpp <CDT.hpp>
+  @brief CDT[HASH] forward constant iterator
+*/
+class CTPP2DECL CDTConstIterator
+{
+private:
+	friend class CDT;
+
+	/** Hash iterator */
+	CDT::Map::const_iterator itMap;
+
+public:
+	/**
+	  @brief Copy constructor
+	  @param oRhs - object to copy
+	*/
+	CDTConstIterator(const CDTConstIterator & oRhs);
+
+	/**
+	  @brief Type cast constructor
+	  @param oRhs - object to copy
+	*/
+	CDTConstIterator(const CDTIterator & oRhs);
+
+	/**
+	  @brief Operator =
+	  @param oRhs - object to copy
+	*/
+	CDTConstIterator & operator=(const CDTConstIterator & oRhs);
+
+	/**
+	  @brief Operator =
+	  @param oRhs - object to copy
+	*/
+	CDTConstIterator & operator=(const CDTIterator & oRhs);
+
+	/**
+	  @brief Pre-increment operator ++
+	*/
+	CDTConstIterator & operator++();
+
+	/**
+	  @brief Post-increment operator ++
+	*/
+	CDTConstIterator operator++(int);
+
+	/**
+	  @brief Access operator
+	  @return Pair of key => value
+	*/
+	const STLW::pair<const STLW::string, CDT> * operator->() const;
+
+	/**
+	  @brief Comparison operator
+	  @param oRhs - object to compare
+	  @return true if objects are equal
+	*/
+	bool operator ==(const CDTConstIterator & oRhs) const;
+
+	/**
+	  @brief Comparison operator
+	  @param oRhs - object to compare
+	  @return true if objects are NOT equal
+	*/
+	bool operator !=(const CDTConstIterator & oRhs) const;
+};
+
+
 // ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //
 // Realization

--- ../../ctpp2.orig/src/CDT.cpp	2012-11-10 23:38:03.000000000 +0400
+++ ../src/CDT.cpp	2014-04-30 14:18:22.000000000 +0400
@@ -108,17 +108,17 @@
 //
 // Constructor
 //
-CDT::Iterator::Iterator(CDT::Map::iterator itIMap): itMap(itIMap) { ;; }
+CDTIterator::CDTIterator(CDT::Map::iterator itIMap): itMap(itIMap) { ;; }
 
 //
 // Copy constructor
 //
-CDT::Iterator::Iterator(const CDT::Iterator & oRhs): itMap(oRhs.itMap) { ;; }
+CDTIterator::CDTIterator(const CDTIterator & oRhs): itMap(oRhs.itMap) { ;; }
 
 //
 // Operator =
 //
-CDT::Iterator & CDT::Iterator::operator=(const CDT::Iterator & oRhs)
+CDTIterator & CDTIterator::operator=(const CDTIterator & oRhs)
 {
 	if (this != &oRhs) { itMap = oRhs.itMap; }
 
@@ -128,7 +128,7 @@
 //
 // Pre-increment operator ++
 //
-CDT::Iterator & CDT::Iterator::operator++()
+CDTIterator & CDTIterator::operator++()
 {
 	++itMap;
 
@@ -138,9 +138,9 @@
 //
 // Post-increment operator ++
 //
-CDT::Iterator CDT::Iterator::operator++(int)
+CDTIterator CDTIterator::operator++(int)
 {
-	Iterator oTMP = *this;
+	CDTIterator oTMP = *this;
 
 	++itMap;
 
@@ -150,46 +150,46 @@
 //
 // Access operator
 //
-STLW::pair<const STLW::string, CDT> * CDT::Iterator::operator->() { return &(*itMap); }
+STLW::pair<const STLW::string, CDT> * CDTIterator::operator->() { return &(*itMap); }
 
 //
 // Comparison operator
 //
-bool CDT::Iterator::operator ==(const CDT::Iterator & oRhs) { return (itMap == oRhs.itMap); }
+bool CDTIterator::operator ==(const CDTIterator & oRhs) { return (itMap == oRhs.itMap); }
 
 //
 // Comparison operator
 //
-bool CDT::Iterator::operator !=(const CDT::Iterator & oRhs) { return (itMap != oRhs.itMap); }
+bool CDTIterator::operator !=(const CDTIterator & oRhs) { return (itMap != oRhs.itMap); }
 
 //
 // Get iterator pointed to start of hash
 //
-CDT::Iterator CDT::Begin()
+CDTIterator CDT::Begin()
 {
 	if (eValueType != HASH_VAL) { throw CDTAccessException(); }
 
-return Iterator(u.p_data -> u.m_data -> begin());
+return CDTIterator(u.p_data -> u.m_data -> begin());
 }
 
 //
 // Get iterator pointed to end of hash
 //
-CDT::Iterator CDT::End()
+CDTIterator CDT::End()
 {
 	if (eValueType != HASH_VAL) { throw CDTAccessException(); }
 
-	return Iterator(u.p_data -> u.m_data -> end());
+	return CDTIterator(u.p_data -> u.m_data -> end());
 }
 
 //
 // Find element in hash
 //
-CDT::Iterator CDT::Find(const STLW::string & sKey)
+CDTIterator CDT::Find(const STLW::string & sKey)
 {
 	if (eValueType != HASH_VAL) { throw CDTAccessException(); }
 
-return Iterator(u.p_data -> u.m_data -> find(sKey));
+return CDTIterator(u.p_data -> u.m_data -> find(sKey));
 }
 
 // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -200,17 +200,17 @@
 //
 // Copy constructor
 //
-CDT::ConstIterator::ConstIterator(const CDT::ConstIterator & oRhs): itMap(oRhs.itMap) { ;; }
+CDTConstIterator::CDTConstIterator(const CDTConstIterator & oRhs): itMap(oRhs.itMap) { ;; }
 
 //
 // Type cast constructor
 //
-CDT::ConstIterator::ConstIterator(const CDT::Iterator & oRhs): itMap(oRhs.itMap) { ;; }
+CDTConstIterator::CDTConstIterator(const CDTIterator & oRhs): itMap(oRhs.itMap) { ;; }
 
 //
 // Operator =
 //
-CDT::ConstIterator & CDT::ConstIterator::operator=(const ConstIterator & oRhs)
+CDTConstIterator & CDTConstIterator::operator=(const CDTConstIterator & oRhs)
 {
 	if (this != &oRhs) { itMap = oRhs.itMap; }
 
@@ -220,7 +220,7 @@
 //
 // Operator =
 //
-CDT::ConstIterator & CDT::ConstIterator::operator=(const CDT::Iterator & oRhs)
+CDTConstIterator & CDTConstIterator::operator=(const CDTIterator & oRhs)
 {
 	itMap = oRhs.itMap;
 
@@ -230,7 +230,7 @@
 //
 // Pre-increment operator ++
 //
-CDT::ConstIterator & CDT::ConstIterator::operator++()
+CDTConstIterator & CDTConstIterator::operator++()
 {
 	++itMap;
 
@@ -240,9 +240,9 @@
 //
 // Post-increment operator ++
 //
-CDT::ConstIterator CDT::ConstIterator::operator++(int)
+CDTConstIterator CDTConstIterator::operator++(int)
 {
-	ConstIterator oTMP = *this;
+	CDTConstIterator oTMP = *this;
 
 	++itMap;
 
@@ -252,46 +252,46 @@
 //
 // Access operator
 //
-const STLW::pair<const STLW::string, CDT> * CDT::ConstIterator::operator->() const { return &(*itMap); }
+const STLW::pair<const STLW::string, CDT> * CDTConstIterator::operator->() const { return &(*itMap); }
 
 //
 // Comparison operator
 //
-bool CDT::ConstIterator::operator ==(const CDT::ConstIterator & oRhs) const { return (itMap == oRhs.itMap); }
+bool CDTConstIterator::operator ==(const CDTConstIterator & oRhs) const { return (itMap == oRhs.itMap); }
 
 //
 // Comparison operator
 //
-bool CDT::ConstIterator::operator !=(const CDT::ConstIterator & oRhs) const { return (itMap != oRhs.itMap); }
+bool CDTConstIterator::operator !=(const CDTConstIterator & oRhs) const { return (itMap != oRhs.itMap); }
 
 //
 // Get constant iterator pointed to start of hash
 //
-CDT::ConstIterator CDT::Begin() const
+CDTConstIterator CDT::Begin() const
 {
 	if (eValueType != HASH_VAL) { throw CDTAccessException(); }
 
-return ConstIterator(u.p_data -> u.m_data -> begin());
+return CDTConstIterator(u.p_data -> u.m_data -> begin());
 }
 
 //
 // Get constant iterator pointed to end of hash
 //
-CDT::ConstIterator CDT::End() const
+CDTConstIterator CDT::End() const
 {
 	if (eValueType != HASH_VAL) { throw CDTAccessException(); }
 
-return ConstIterator(u.p_data -> u.m_data -> end());
+return CDTConstIterator(u.p_data -> u.m_data -> end());
 }
 
 //
 // Find element in hash
 //
-CDT::ConstIterator CDT::Find(const STLW::string & sKey) const
+CDTConstIterator CDT::Find(const STLW::string & sKey) const
 {
 	if (eValueType != HASH_VAL) { throw CDTAccessException(); }
 
-return ConstIterator(u.p_data -> u.m_data -> find(sKey));
+return CDTConstIterator(u.p_data -> u.m_data -> find(sKey));
 }
 
 // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -4138,7 +4138,7 @@
 
 		case HASH_VAL:
 			{
-				ConstIterator itHash = oData.Begin();
+				CDTConstIterator itHash = oData.Begin();
 				if (itHash == oData.End())
 				{
 					if (!bGlobalScope) { sResult += "{ }"; }

--- ../../ctpp2.orig/src/CTPP2FileSourceLoader.cpp	2012-08-02 11:22:44.000000000 +0400
+++ ../src/CTPP2FileSourceLoader.cpp	2014-04-30 14:21:03.000000000 +0400
@@ -38,6 +38,7 @@
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <unistd.h>
 
 #ifdef WIN32
     #include <direct.h> /* getcwd */

--- ../../ctpp2.orig/src/CTPP2Util.cpp	2012-08-02 11:22:44.000000000 +0400
+++ ../src/CTPP2Util.cpp	2014-04-30 14:24:32.000000000 +0400
@@ -751,7 +751,7 @@
 		case CDT::HASH_VAL:
 			{
 				oResult.Write("{", 1);
-				CDT::ConstIterator itCDTCArray = oCDT.Begin();
+				CDTConstIterator itCDTCArray = oCDT.Begin();
 				while (itCDTCArray != oCDT.End())
 				{
 					oResult.Write("\"", 1);

--- ../../ctpp2.orig/src/CTPP2VM.cpp	2012-08-02 11:22:44.000000000 +0400
+++ ../src/CTPP2VM.cpp	2014-04-30 14:25:49.000000000 +0400
@@ -1440,7 +1440,7 @@
 
                                             if (oRegs[iSrcReg].GetType() == CDT::HASH_VAL)
                                             {
-                                                CDT::Iterator it = oRegs[iSrcReg].Begin();
+                                                CDTIterator it = oRegs[iSrcReg].Begin();
                                                 for (INT_32 iI = 0; iI < iIdx; ++iI) { ++it; }
 #ifdef _DEBUG
 fprintf(stderr, "(`%s`): %s\n", it->first.c_str(), it->second.GetString().c_str());

--- ../../ctpp2.orig/tests/CDTTest.cpp	2012-08-02 11:22:44.000000000 +0400
+++ ../tests/CDTTest.cpp	2014-04-30 14:27:19.000000000 +0400
@@ -590,7 +590,7 @@
 
 	fprintf(stderr, "Get HASH values: %s\n", oCDT_array.GetHashValues().Dump().c_str());
 
-	CDT::Iterator itCDTArray = oCDT_array.Begin();
+	CDTIterator itCDTArray = oCDT_array.Begin();
 	while (itCDTArray != oCDT_array.End())
 	{
 		fprintf(stderr, "oCDT_array[\"%s\"] => %s\n", itCDTArray -> first.c_str(), itCDTArray -> second.GetString().c_str());
@@ -598,7 +598,7 @@
 		++itCDTArray;
 	}
 
-	CDT::ConstIterator itCDTCArray = oCDT_array.Begin();
+	CDTConstIterator itCDTCArray = oCDT_array.Begin();
 	while (itCDTCArray != oCDT_array.End())
 	{
 		fprintf(stderr, "oCDT_array[\"%s\"] => %s\n", itCDTCArray -> first.c_str(), itCDTCArray -> second.GetString().c_str());


>Release-Note:
>Audit-Trail:
>Unformatted:



Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?201404301036.s3UAax3q092054>