ports/63752: Update port: net/xmlrpc-c

KATO Tsuguru tkato at prontomail.com
Thu Mar 4 12:10:12 UTC 2004


>Number:         63752
>Category:       ports
>Synopsis:       Update port: net/xmlrpc-c
>Confidential:   no
>Severity:       non-critical
>Priority:       low
>Responsible:    freebsd-ports-bugs
>State:          open
>Quarter:        
>Keywords:       
>Date-Required:
>Class:          change-request
>Submitter-Id:   current-users
>Arrival-Date:   Thu Mar 04 04:10:11 PST 2004
>Closed-Date:
>Last-Modified:
>Originator:     KATO Tsuguru
>Release:        FreeBSD 4.9-RELEASE-p3 i386
>Organization:
>Environment:
>Description:
- Fix build on -current

New file:
files/patch-examples::interop-client::InteropEchoProxy.cc
files/patch-examples::interop-client::InteropEchoProxy.h
files/patch-examples::interop-client::interop-client.cc
files/patch-examples::meerkat-app-list.cc
files/patch-src::XmlRpcCpp.cc
files/patch-src::XmlRpcCpp.h
files/patch-src::cpptest.cc
files/patch-src::validatee.c
files/patch-src::xmlrpc.h
files/patch-src::xmlrpc_abyss.c
files/patch-src::xmlrpc_data.c
files/patch-src::xmlrpc_support.c
files/patch-tools::xml-rpc-api2cpp::DataType.cc
files/patch-tools::xml-rpc-api2cpp::DataType.h
files/patch-tools::xml-rpc-api2cpp::SystemProxy.cc
files/patch-tools::xml-rpc-api2cpp::SystemProxy.h
files/patch-tools::xml-rpc-api2cpp::XmlRpcClass.cc
files/patch-tools::xml-rpc-api2cpp::XmlRpcClass.h
files/patch-tools::xml-rpc-api2cpp::XmlRpcFucntion.cc
files/patch-tools::xml-rpc-api2cpp::XmlRpcFucntion.h
files/patch-tools::xml-rpc-api2cpp::xml-rpc-api2cpp

Remove file:
files/patch-src-XmlRpcCpp.h

>How-To-Repeat:
>Fix:

diff -urN /usr/ports/net/xmlrpc-c/Makefile net/xmlrpc-c/Makefile
--- /usr/ports/net/xmlrpc-c/Makefile	Sun Feb 29 12:26:37 2004
+++ net/xmlrpc-c/Makefile	Tue Mar  2 22:45:59 2004
@@ -19,26 +19,12 @@
 LIB_DEPENDS=	wwwcore.1:${PORTSDIR}/www/libwww
 RUN_DEPENDS=	${SITE_PERL}/Frontier/Client.pm:${PORTSDIR}/net/p5-Frontier-RPC
 
-USE_REINPLACE=	yes
-USE_LIBTOOL=	yes
 USE_GMAKE=	yes
+USE_LIBTOOL=	yes
 INSTALLS_SHLIB=	yes
 
 MAN1=	meerkat-app-list.1 xml-rpc-api2cpp.1 xmlrpc-c-config.1 \
 	query-meerkat.1 xml-rpc-api2txt.1
 MAN7=	xmlrpc-c.7
 
-.include <bsd.port.pre.mk>
-
-pre-patch:
-	@${REINPLACE_CMD} -e 's,<malloc.h>,<stdlib.h>,' \
-		${WRKSRC}/lib/abyss/src/data.c \
-		${WRKSRC}/tools/turbocharger/mod_gzip.c
-	cd ${WRKSRC}; ${REINPLACE_CMD} -e 's,<strstream.h>,<strstream>,' \
-		examples/meerkat-app-list.cc \
-		tools/xml-rpc-api2cpp/DataType.cc
-
-post-install:
-	@${RM} -f ${PREFIX}/lib/*.la
-
-.include <bsd.port.post.mk>
+.include <bsd.port.mk>
diff -urN /usr/ports/net/xmlrpc-c/files/patch-examples::interop-client::InteropEchoProxy.cc net/xmlrpc-c/files/patch-examples::interop-client::InteropEchoProxy.cc
--- /usr/ports/net/xmlrpc-c/files/patch-examples::interop-client::InteropEchoProxy.cc	Thu Jan  1 09:00:00 1970
+++ net/xmlrpc-c/files/patch-examples::interop-client::InteropEchoProxy.cc	Tue Mar  2 23:41:05 2004
@@ -0,0 +1,29 @@
+--- examples/interop-client/InteropEchoProxy.cc.orig	Wed Apr 25 00:17:25 2001
++++ examples/interop-client/InteropEchoProxy.cc	Tue Mar  2 23:39:39 2004
+@@ -12,7 +12,7 @@
+ public:
+     InteropEchoProxy (const XmlRpcClient& client)
+         : mClient(client) {}
+-    InteropEchoProxy (const string& server_url)
++    InteropEchoProxy (const std::string& server_url)
+         : mClient(XmlRpcClient(server_url)) {}
+     InteropEchoProxy (const InteropEchoProxy& o)
+         : mClient(o.mClient) {}
+@@ -23,7 +23,7 @@
+     }
+ 
+     /* Echo an arbitrary XML-RPC string. */
+-    string echoString (string string1);
++    std::string echoString (std::string string1);
+ 
+     /* Echo an arbitrary XML-RPC integer. */
+     XmlRpcValue::int32 echoInteger (XmlRpcValue::int32 int1);
+@@ -55,7 +55,7 @@
+ #include <XmlRpcCpp.h>
+ #include "InteropEchoProxy.h"
+ 
+-string InteropEchoProxy::echoString (string string1) {
++std::string InteropEchoProxy::echoString (std::string string1) {
+     XmlRpcValue params = XmlRpcValue::makeArray();
+     params.arrayAppendItem(XmlRpcValue::makeString(string1));
+     XmlRpcValue result = this->mClient.call("interopEchoTests.echoString", params);
diff -urN /usr/ports/net/xmlrpc-c/files/patch-examples::interop-client::InteropEchoProxy.h net/xmlrpc-c/files/patch-examples::interop-client::InteropEchoProxy.h
--- /usr/ports/net/xmlrpc-c/files/patch-examples::interop-client::InteropEchoProxy.h	Thu Jan  1 09:00:00 1970
+++ net/xmlrpc-c/files/patch-examples::interop-client::InteropEchoProxy.h	Tue Mar  2 23:41:16 2004
@@ -0,0 +1,20 @@
+--- examples/interop-client/InteropEchoProxy.h.orig	Wed Apr 25 00:17:42 2001
++++ examples/interop-client/InteropEchoProxy.h	Tue Mar  2 23:39:39 2004
+@@ -12,7 +12,7 @@
+ public:
+     InteropEchoProxy (const XmlRpcClient& client)
+         : mClient(client) {}
+-    InteropEchoProxy (const string& server_url)
++    InteropEchoProxy (const std::string& server_url)
+         : mClient(XmlRpcClient(server_url)) {}
+     InteropEchoProxy (const InteropEchoProxy& o)
+         : mClient(o.mClient) {}
+@@ -23,7 +23,7 @@
+     }
+ 
+     /* Echo an arbitrary XML-RPC string. */
+-    string echoString (string string1);
++    std::string echoString (std::string string1);
+ 
+     /* Echo an arbitrary XML-RPC integer. */
+     XmlRpcValue::int32 echoInteger (XmlRpcValue::int32 int1);
diff -urN /usr/ports/net/xmlrpc-c/files/patch-examples::interop-client::interop-client.cc net/xmlrpc-c/files/patch-examples::interop-client::interop-client.cc
--- /usr/ports/net/xmlrpc-c/files/patch-examples::interop-client::interop-client.cc	Thu Jan  1 09:00:00 1970
+++ net/xmlrpc-c/files/patch-examples::interop-client::interop-client.cc	Tue Mar  2 23:41:39 2004
@@ -0,0 +1,108 @@
+--- examples/interop-client/interop-client.cc.orig	Thu Jun 28 11:54:08 2001
++++ examples/interop-client/interop-client.cc	Tue Mar  2 23:39:39 2004
+@@ -1,8 +1,8 @@
+ // Run various interop test cases against a list of servers.
+ // This code is incomplete.
+ 
+-#include <iostream.h>
+-#include <fstream.h>
++#include <iostream>
++#include <fstream>
+ #include <stdexcept>
+ 
+ #include <XmlRpcCpp.h>
+@@ -17,13 +17,13 @@
+ //=========================================================================
+ 
+ class TestResults {
+-    string m_server_name;
+-    string m_server_url;
++    std::string m_server_name;
++    std::string m_server_url;
+     XmlRpcValue m_toolkit_info;
+     XmlRpcValue m_test_results;
+ 
+ public:
+-    TestResults(string server_name, string server_url);
++    TestResults(std::string server_name, std::string server_url);
+     
+ };
+ 
+@@ -33,24 +33,24 @@
+ //=========================================================================
+ 
+ static void
+-run_interop_tests(const string& server_url_file,
+-		  const string& output_html_file)
++run_interop_tests(const std::string& server_url_file,
++		  const std::string& output_html_file)
+ {
+-    ifstream urls(server_url_file.c_str());
+-    ofstream out(output_html_file.c_str());
++    std::ifstream urls(server_url_file.c_str());
++    std::ofstream out(output_html_file.c_str());
+ 
+     while (!urls.eof()) {
+-	string url_info;
++	std::string url_info;
+ 	getline(urls, url_info);
+ 	size_t comma = url_info.find(',');
+-	if (comma == string::npos)
+-	    throw domain_error("Lines of " + server_url_file +
++	if (comma == std::string::npos)
++	    throw std::domain_error("Lines of " + server_url_file +
+ 			       " must be of the form \"name,url\"");
+-	string server_name(url_info, 0, comma);
+-	string server_url(url_info, comma + 1);
++	std::string server_name(url_info, 0, comma);
++	std::string server_url(url_info, comma + 1);
+ 
+-	cout << "Name: " << server_name << endl;
+-	cout << "URL: " << server_url << endl << endl;
++	std::cout << "Name: " << server_name << std::endl;
++	std::cout << "URL: " << server_url << std::endl << std::endl;
+     }
+ }
+ 			      
+@@ -62,8 +62,8 @@
+ // Print out a usage message.
+ static void usage (void)
+ {
+-    cerr << "Usage: interop-client <server-url-file> <output-html-file>";
+-    cerr << endl;
++    std::cerr << "Usage: interop-client <server-url-file> <output-html-file>";
++    std::cerr << std::endl;
+     exit(1);
+ }
+ 
+@@ -73,8 +73,8 @@
+     // Parse our command-line arguments.
+     if (argc != 3)
+ 	usage();
+-    string server_url_file(argv[1]);
+-    string output_html_file(argv[2]);
++    std::string server_url_file(argv[1]);
++    std::string output_html_file(argv[2]);
+ 
+     // Start up our client library.
+     XmlRpcClient::Initialize(NAME, VERSION);
+@@ -83,14 +83,14 @@
+     try {
+ 	run_interop_tests(server_url_file, output_html_file);
+     } catch (XmlRpcFault& fault) {
+-	cerr << argv[0] << ": XML-RPC fault #" << fault.getFaultCode()
+-	     << ": " << fault.getFaultString() << endl;
++	std::cerr << argv[0] << ": XML-RPC fault #" << fault.getFaultCode()
++	     << ": " << fault.getFaultString() << std::endl;
+ 	status = 1;
+-    } catch (logic_error& err) {
+-	cerr << argv[0] << ": " << err.what() << endl;
++    } catch (std::logic_error& err) {
++	std::cerr << argv[0] << ": " << err.what() << std::endl;
+ 	status = 1;
+     } catch (...) {
+-	cerr << argv[0] << ": Unknown exception" << endl;
++	std::cerr << argv[0] << ": Unknown exception" << std::endl;
+ 	status = 1;
+     }
+ 
diff -urN /usr/ports/net/xmlrpc-c/files/patch-examples::meerkat-app-list.cc net/xmlrpc-c/files/patch-examples::meerkat-app-list.cc
--- /usr/ports/net/xmlrpc-c/files/patch-examples::meerkat-app-list.cc	Thu Jan  1 09:00:00 1970
+++ net/xmlrpc-c/files/patch-examples::meerkat-app-list.cc	Tue Mar  2 23:42:04 2004
@@ -0,0 +1,88 @@
+--- examples/meerkat-app-list.cc.orig	Wed Apr 25 04:18:36 2001
++++ examples/meerkat-app-list.cc	Tue Mar  2 23:39:39 2004
+@@ -2,8 +2,8 @@
+ // For more details about O'Reilly's excellent Meerkat news service, see:
+ // http://www.oreillynet.com/pub/a/rss/2000/11/14/meerkat_xmlrpc.html */
+ 
+-#include <iostream.h>
+-#include <strstream.h>
++#include <iostream>
++#include <sstream>
+ 
+ #include <XmlRpcCpp.h>
+ 
+@@ -15,12 +15,9 @@
+ static void list_apps (int hours) {
+ 
+     // Build our time_period parameter.
+-    ostrstream time_period_stream;
+-    time_period_stream << hours << "HOUR" << ends;
+-    string time_period = time_period_stream.str();
+-
+-    // (Ask the ostrstream to reclaim ownership of its buffer.)
+-    time_period_stream.freeze(false);
++    std::ostringstream time_period_stream;
++    time_period_stream << hours << "HOUR" << std::ends;
++    std::string time_period = time_period_stream.str();
+ 
+     // Assemble our meerkat query recipe.
+     XmlRpcValue recipe = XmlRpcValue::makeStruct();
+@@ -45,21 +42,21 @@
+ 	XmlRpcValue app = apps.arrayGetItem(i);
+ 
+ 	// Get some information about our application.
+-	string title       = app.structGetValue("title").getString();
+-	string link        = app.structGetValue("link").getString();
+-	string description = app.structGetValue("description").getString();
++	std::string title       = app.structGetValue("title").getString();
++	std::string link        = app.structGetValue("link").getString();
++	std::string description = app.structGetValue("description").getString();
+ 	
+ 	// Print a separator line if necessary.
+ 	if (first)
+ 	    first = 0;
+ 	else
+-	    cout << endl;
++	    std::cout << std::endl;
+ 
+ 	// Print this application entry.
+ 	if (description.size() > 0) {
+-	    cout << title << endl << description << endl << link << endl;
++	    std::cout << title << std::endl << description << std::endl << link << std::endl;
+ 	} else {
+-	    cout << title << endl << description << endl << link << endl;
++	    std::cout << title << std::endl << description << std::endl << link << std::endl;
+ 	}
+     }
+ }
+@@ -67,8 +64,8 @@
+ // Print out a usage message.
+ static void usage (void)
+ {
+-    cerr << "Usage: meekat-app-list [hours]" << endl;
+-    cerr << "Data from <http://www.oreillynet.com/meerkat/>." << endl;
++    std::cerr << "Usage: meekat-app-list [hours]" << std::endl;
++    std::cerr << "Data from <http://www.oreillynet.com/meerkat/>." << std::endl;
+     exit(1);
+ }
+ 
+@@ -85,7 +82,7 @@
+     if (hours == 0)
+ 	usage();
+     if (hours > 49) {
+-        cerr << "It's not nice to ask for > 49 hours at once." << endl;
++        std::cerr << "It's not nice to ask for > 49 hours at once." << std::endl;
+         exit(1);	
+     }
+ 
+@@ -96,8 +93,8 @@
+     try {
+ 	list_apps(hours);
+     } catch (XmlRpcFault& fault) {
+-	cerr << argv[0] << ": XML-RPC fault #" << fault.getFaultCode()
+-	     << ": " << fault.getFaultString() << endl;
++	std::cerr << argv[0] << ": XML-RPC fault #" << fault.getFaultCode()
++	     << ": " << fault.getFaultString() << std::endl;
+ 	status = 1;
+     }
+ 
diff -urN /usr/ports/net/xmlrpc-c/files/patch-src-XmlRpcCpp.h net/xmlrpc-c/files/patch-src-XmlRpcCpp.h
--- /usr/ports/net/xmlrpc-c/files/patch-src-XmlRpcCpp.h	Thu Nov 14 20:15:42 2002
+++ net/xmlrpc-c/files/patch-src-XmlRpcCpp.h	Thu Jan  1 09:00:00 1970
@@ -1,12 +0,0 @@
---- src/XmlRpcCpp.h.orig	Thu Nov 14 09:17:52 2002
-+++ src/XmlRpcCpp.h	Thu Nov 14 09:18:17 2002
-@@ -45,8 +45,8 @@
- // work with our version of g++). So this header name is technically wrong.
- // Tell me what your compiler does; I can provide some autoconf magic to the
- // Right Thing on most platforms.
-+using namespace std;
- #include <string>
--// using namespace std;
- 
- #include <xmlrpc.h>
- #include <xmlrpc_client.h>
diff -urN /usr/ports/net/xmlrpc-c/files/patch-src::XmlRpcCpp.cc net/xmlrpc-c/files/patch-src::XmlRpcCpp.cc
--- /usr/ports/net/xmlrpc-c/files/patch-src::XmlRpcCpp.cc	Thu Jan  1 09:00:00 1970
+++ net/xmlrpc-c/files/patch-src::XmlRpcCpp.cc	Tue Mar  2 23:42:42 2004
@@ -0,0 +1,103 @@
+--- src/XmlRpcCpp.cc.orig	Sat Apr 14 03:43:55 2001
++++ src/XmlRpcCpp.cc	Tue Mar  2 23:39:39 2004
+@@ -38,7 +38,7 @@
+ 			 fault.mFault.fault_string);
+ }
+ 
+-XmlRpcFault::XmlRpcFault (const int faultCode, const string faultString) {
++XmlRpcFault::XmlRpcFault (const int faultCode, const std::string faultString) {
+     xmlrpc_env_init(&mFault);
+     xmlrpc_env_set_fault(&mFault, faultCode,
+ 			 const_cast<char*>(faultString.c_str()));
+@@ -57,9 +57,9 @@
+     xmlrpc_env_clean(&mFault);
+ }
+ 
+-string XmlRpcFault::getFaultString (void) const {
++std::string XmlRpcFault::getFaultString (void) const {
+     XMLRPC_ASSERT(mFault.fault_occurred);
+-    return string(mFault.fault_string);
++    return std::string(mFault.fault_string);
+ }
+ 
+ 
+@@ -117,7 +117,7 @@
+     return XmlRpcValue(value, CONSUME_REFERENCE);
+ }
+ 
+-XmlRpcValue XmlRpcValue::makeDateTime (const string& dateTime) {
++XmlRpcValue XmlRpcValue::makeDateTime (const std::string& dateTime) {
+     XmlRpcEnv env;
+     xmlrpc_value *value;
+     const char *data = dateTime.c_str(); // Make sure we're not using wchar_t.
+@@ -126,7 +126,7 @@
+     return XmlRpcValue(value, CONSUME_REFERENCE);    
+ }
+ 
+-XmlRpcValue XmlRpcValue::makeString (const string& str) {
++XmlRpcValue XmlRpcValue::makeString (const std::string& str) {
+     XmlRpcEnv env;
+     const char *data = str.data();      // Make sure we're not using wchar_t.
+     size_t size = str.size();
+@@ -196,21 +196,21 @@
+     return result;
+ }
+ 
+-string XmlRpcValue::getRawDateTime (void) const {
++std::string XmlRpcValue::getRawDateTime (void) const {
+     XmlRpcEnv env;
+     char *result;
+     xmlrpc_parse_value(env, mValue, "8", &result);
+     env.throwIfFaultOccurred();
+-    return string(result);
++    return std::string(result);
+ }
+ 
+-string XmlRpcValue::getString (void) const {
++std::string XmlRpcValue::getString (void) const {
+     XmlRpcEnv env;
+     char *result;
+     size_t result_len;
+     xmlrpc_parse_value(env, mValue, "s#", &result, &result_len);
+     env.throwIfFaultOccurred();
+-    return string(result, result_len);
++    return std::string(result, result_len);
+     
+ }
+ 
+@@ -265,7 +265,7 @@
+     return result;
+ }
+ 
+-bool XmlRpcValue::structHasKey (const string& key) {
++bool XmlRpcValue::structHasKey (const std::string& key) {
+     XmlRpcEnv env;
+     const char *keystr = key.data();
+     size_t keylen = key.size();
+@@ -275,7 +275,7 @@
+     return result;
+ }
+ 
+-XmlRpcValue XmlRpcValue::structGetValue (const string& key) {
++XmlRpcValue XmlRpcValue::structGetValue (const std::string& key) {
+     XmlRpcEnv env;
+     const char *keystr = key.data();
+     size_t keylen = key.size();
+@@ -286,7 +286,7 @@
+     return XmlRpcValue(result);
+ }
+ 
+-void XmlRpcValue::structSetValue (const string& key, const XmlRpcValue& value)
++void XmlRpcValue::structSetValue (const std::string& key, const XmlRpcValue& value)
+ {
+     XmlRpcEnv env;
+     const char *keystr = key.data();
+@@ -297,7 +297,7 @@
+ }
+ 
+ void XmlRpcValue::structGetKeyAndValue (const int index,
+-					string& out_key,
++					std::string& out_key,
+ 					XmlRpcValue& out_value)
+ {
+     XmlRpcEnv env;
diff -urN /usr/ports/net/xmlrpc-c/files/patch-src::XmlRpcCpp.h net/xmlrpc-c/files/patch-src::XmlRpcCpp.h
--- /usr/ports/net/xmlrpc-c/files/patch-src::XmlRpcCpp.h	Thu Jan  1 09:00:00 1970
+++ net/xmlrpc-c/files/patch-src::XmlRpcCpp.h	Tue Mar  2 23:42:53 2004
@@ -0,0 +1,97 @@
+--- src/XmlRpcCpp.h.orig	Sat Apr 14 03:46:16 2001
++++ src/XmlRpcCpp.h	Tue Mar  2 23:39:39 2004
+@@ -71,12 +71,12 @@
+ 
+ public:
+                  XmlRpcFault (const XmlRpcFault &fault);
+-                 XmlRpcFault (const int faultCode, const string faultString);
++                 XmlRpcFault (const int faultCode, const std::string faultString);
+                  XmlRpcFault (const xmlrpc_env *env);
+                 ~XmlRpcFault (void);
+ 
+     int          getFaultCode (void) const;
+-    string       getFaultString (void) const;
++    std::string  getFaultString (void) const;
+     xmlrpc_env  *getFaultEnv (void);
+ };
+ 
+@@ -167,8 +167,8 @@
+     static XmlRpcValue makeInt      (const XmlRpcValue::int32 i);
+     static XmlRpcValue makeBool     (const bool b);
+     static XmlRpcValue makeDouble   (const double d);
+-    static XmlRpcValue makeDateTime (const string& dateTime);
+-    static XmlRpcValue makeString   (const string& str);
++    static XmlRpcValue makeDateTime (const std::string& dateTime);
++    static XmlRpcValue makeString   (const std::string& str);
+     static XmlRpcValue makeString   (const char *const str);
+     static XmlRpcValue makeString   (const char *const str, size_t len);
+     static XmlRpcValue makeArray    (void);
+@@ -185,8 +185,8 @@
+     XmlRpcValue::int32 getInt   (void) const;
+     bool         getBool        (void) const;
+     double       getDouble      (void) const;
+-    string       getRawDateTime (void) const;
+-    string       getString      (void) const;
++    std::string  getRawDateTime (void) const;
++    std::string  getString      (void) const;
+     XmlRpcValue  getArray       (void) const;
+     XmlRpcValue  getStruct      (void) const;
+ 
+@@ -209,11 +209,11 @@
+     // Struct functions. These will throw an XmlRpcFault if the value
+     // isn't a struct.
+     size_t       structSize (void);
+-    bool         structHasKey (const string& key);
+-    XmlRpcValue  structGetValue (const string& key);
+-    void         structSetValue (const string& key, const XmlRpcValue& value);
++    bool         structHasKey (const std::string& key);
++    XmlRpcValue  structGetValue (const std::string& key);
++    void         structSetValue (const std::string& key, const XmlRpcValue& value);
+     void         structGetKeyAndValue (const int index,
+-				       string& out_key,
++				       std::string& out_key,
+ 				       XmlRpcValue& out_value);
+ };
+ 
+@@ -265,19 +265,19 @@
+ class XmlRpcClient {
+ 
+ private:
+-    string mServerUrl;
++    std::string mServerUrl;
+ 
+ public:
+-    static void Initialize (string appname, string appversion);
++    static void Initialize (std::string appname, std::string appversion);
+     static void Terminate (void);
+ 
+-    XmlRpcClient (const string& server_url) : mServerUrl(server_url) {}
++    XmlRpcClient (const std::string& server_url) : mServerUrl(server_url) {}
+     ~XmlRpcClient (void) {}
+ 
+     XmlRpcClient (const XmlRpcClient& client);
+     XmlRpcClient& operator= (const XmlRpcClient& client);
+ 
+-    XmlRpcValue call (string method_name, XmlRpcValue param_array);
++    XmlRpcValue call (std::string method_name, XmlRpcValue param_array);
+ };
+ 
+ 
+@@ -299,7 +299,7 @@
+     return *this;
+ }
+ 
+-inline void XmlRpcClient::Initialize (string appname, string appversion) {
++inline void XmlRpcClient::Initialize (std::string appname, std::string appversion) {
+     xmlrpc_client_init(XMLRPC_CLIENT_NO_FLAGS,
+ 		       const_cast<char*>(appname.c_str()),
+ 		       const_cast<char*>(appversion.c_str()));
+@@ -309,7 +309,7 @@
+     xmlrpc_client_cleanup();
+ }
+ 
+-inline XmlRpcValue XmlRpcClient::call (string method_name,
++inline XmlRpcValue XmlRpcClient::call (std::string method_name,
+ 				       XmlRpcValue param_array)
+ {
+     XmlRpcEnv env;
diff -urN /usr/ports/net/xmlrpc-c/files/patch-src::cpptest.cc net/xmlrpc-c/files/patch-src::cpptest.cc
--- /usr/ports/net/xmlrpc-c/files/patch-src::cpptest.cc	Thu Jan  1 09:00:00 1970
+++ net/xmlrpc-c/files/patch-src::cpptest.cc	Tue Mar  2 23:43:04 2004
@@ -0,0 +1,89 @@
+--- src/cpptest.cc.orig	Wed May  2 00:26:13 2001
++++ src/cpptest.cc	Tue Mar  2 23:39:39 2004
+@@ -28,15 +28,15 @@
+ void test_failure (char* file, int line, char* statement)
+ {
+     total_failures++;
+-    cout << endl
+-	 << file << ":" << line << ": expected (" << statement << ")" << endl;
++    std::cout << std::endl
++	 << file << ":" << line << ": expected (" << statement << ")" << std::endl;
+ }
+ 
+ #define TEST(statement) \
+     do { \
+         total_tests++; \
+         if ((statement)) { \
+-            cout << "."; \
++            std::cout << "."; \
+ 	} else { \
+             test_failure(__FILE__, __LINE__, #statement); \
+         } \
+@@ -45,7 +45,7 @@
+ #define TEST_PASSED() \
+     do { \
+         total_tests++; \
+-        cout << "."; \
++        std::cout << "."; \
+     } while (0)
+ 
+ #define TEST_FAILED(reason) \
+@@ -187,7 +187,7 @@
+     TEST(XmlRpcValue::makeString("foo").getString() == "foo");
+     TEST(XmlRpcValue::makeString("bar", 3).getString() == "bar");
+     TEST(XmlRpcValue::makeString("bar", 3).getString() == "bar");
+-    TEST(XmlRpcValue::makeString("a\0b").getString() == string("a\0b"));
++    TEST(XmlRpcValue::makeString("a\0b").getString() == std::string("a\0b"));
+     XmlRpcValue::makeArray().getArray();
+     XmlRpcValue::makeStruct().getStruct();
+ 
+@@ -219,7 +219,7 @@
+     TEST(strct.structHasKey("bar"));
+     TEST(!strct.structHasKey("nosuch"));
+     for (size_t i = 0; i < strct.structSize(); i++) {
+-	string key;
++	std::string key;
+ 	XmlRpcValue value;
+ 	strct.structGetKeyAndValue(i, key, value);
+ 	TEST(key + "val" == value.getString());
+@@ -248,30 +248,30 @@
+ 	test_errors();
+ 
+     } catch (XmlRpcFault& fault) {
+-	cout << "Unexpected XML-RPC fault when running test suites." << endl
++	std::cout << "Unexpected XML-RPC fault when running test suites." << std::endl
+ 	     << "Fault #" << fault.getFaultCode()
+-	     << ": " << fault.getFaultString() << endl
+-	     << "FAILED" << endl;
++	     << ": " << fault.getFaultString() << std::endl
++	     << "FAILED" << std::endl;
+ 	exit(1);
+     } catch (...) {
+-	cout << "Unexpected exception when running test suites." << endl
+-	     << "FAILED" << endl;
++	std::cout << "Unexpected exception when running test suites." << std::endl
++	     << "FAILED" << std::endl;
+ 	exit(1);
+     }
+ 
+     // Summarize our test run.
+-    cout << endl << "Ran " << total_tests << " tests, "
++    std::cout << std::endl << "Ran " << total_tests << " tests, "
+ 	 << total_failures << " failed, "
+-	 << setprecision(4)
++	 << std::setprecision(4)
+ 	 << (100.0 - (100.0 * total_failures) / total_tests)
+-	 << "% passed" << endl;
++	 << "% passed" << std::endl;
+ 
+     // Print the final result.
+     if (total_failures == 0) {
+-	cout << "OK" << endl;
++	std::cout << "OK" << std::endl;
+ 	return 0;
+     }
+ 
+-    cout << "FAILED" << endl;
++    std::cout << "FAILED" << std::endl;
+     return 1;
+ }
diff -urN /usr/ports/net/xmlrpc-c/files/patch-src::validatee.c net/xmlrpc-c/files/patch-src::validatee.c
--- /usr/ports/net/xmlrpc-c/files/patch-src::validatee.c	Thu Jan  1 09:00:00 1970
+++ net/xmlrpc-c/files/patch-src::validatee.c	Tue Mar  2 23:43:23 2004
@@ -0,0 +1,10 @@
+--- src/validatee.c.orig	Sat Apr 14 04:04:07 2001
++++ src/validatee.c	Tue Mar  2 23:39:39 2004
+@@ -33,6 +33,7 @@
+ 
+ #include <stdio.h>
+ #include <stdlib.h>
++#include <string.h>
+ 
+ #include "xmlrpc.h"
+ #include "xmlrpc_abyss.h"
diff -urN /usr/ports/net/xmlrpc-c/files/patch-src::xmlrpc.h net/xmlrpc-c/files/patch-src::xmlrpc.h
--- /usr/ports/net/xmlrpc-c/files/patch-src::xmlrpc.h	Thu Jan  1 09:00:00 1970
+++ net/xmlrpc-c/files/patch-src::xmlrpc.h	Tue Mar  2 23:43:47 2004
@@ -0,0 +1,38 @@
+--- src/xmlrpc.h.orig	Thu Jun 28 01:35:01 2001
++++ src/xmlrpc.h	Tue Mar  2 23:39:39 2004
+@@ -152,7 +152,7 @@
+ 
+ /* The same as the above, but using a printf-style format string. */
+ void xmlrpc_env_set_fault_formatted (xmlrpc_env* env, int code,
+-				     char *format, ...);
++				     const char *format, ...);
+ 
+ /* A simple debugging assertion. */
+ #define XMLRPC_ASSERT_ENV_OK(env) \
+@@ -362,17 +362,23 @@
+ ** Increments the reference counts of input arguments if necessary.
+ ** See the xmlrpc-c documentation for more information. */
+ extern xmlrpc_value *
+-xmlrpc_build_value (xmlrpc_env* env, char* format, ...);
++xmlrpc_build_value (xmlrpc_env* env, const char* format, ...);
+ 
+ /* The same as the above, but using a va_list. */
+ extern xmlrpc_value *
+-xmlrpc_build_value_va (xmlrpc_env* env, char* format, va_list args);
++xmlrpc_build_value_va (xmlrpc_env* env, const char* format, va_list args);
+ 
+ /* Extract values from an xmlrpc_value and store them into C variables.
+ ** Does not increment the reference counts of output values.
+ ** See the xmlrpc-c documentation for more information. */
+ extern void
+-xmlrpc_parse_value (xmlrpc_env* env, xmlrpc_value* value, char* format, ...);
++xmlrpc_parse_value (xmlrpc_env* env, xmlrpc_value* value,
++                    const char* format, ...);
++
++/* The same as the above, but using a va_list. */
++extern void
++xmlrpc_parse_value_va (xmlrpc_env* env, xmlrpc_value* value,
++                       const char* format, va_list args);
+ 
+ /* Return the number of elements in an XML-RPC array.
+ ** Sets XMLRPC_TYPE_ERROR if 'array' is not an array. */
diff -urN /usr/ports/net/xmlrpc-c/files/patch-src::xmlrpc_abyss.c net/xmlrpc-c/files/patch-src::xmlrpc_abyss.c
--- /usr/ports/net/xmlrpc-c/files/patch-src::xmlrpc_abyss.c	Thu Jan  1 09:00:00 1970
+++ net/xmlrpc-c/files/patch-src::xmlrpc_abyss.c	Tue Mar  2 23:44:05 2004
@@ -0,0 +1,10 @@
+--- src/xmlrpc_abyss.c.orig	Wed May  2 05:18:48 2001
++++ src/xmlrpc_abyss.c	Tue Mar  2 23:39:39 2004
+@@ -34,6 +34,7 @@
+ 
+ #include <stdio.h>
+ #include <stdlib.h>
++#include <string.h>
+ 
+ #include "xmlrpc.h"
+ 
diff -urN /usr/ports/net/xmlrpc-c/files/patch-src::xmlrpc_data.c net/xmlrpc-c/files/patch-src::xmlrpc_data.c
--- /usr/ports/net/xmlrpc-c/files/patch-src::xmlrpc_data.c	Thu Jan  1 09:00:00 1970
+++ net/xmlrpc-c/files/patch-src::xmlrpc_data.c	Tue Mar  2 23:44:21 2004
@@ -0,0 +1,117 @@
+--- src/xmlrpc_data.c.orig	Wed Apr 25 04:20:20 2001
++++ src/xmlrpc_data.c	Tue Mar  2 23:39:39 2004
+@@ -182,10 +182,11 @@
+ **  (in theory) also be portable.
+ */
+ 
+-static xmlrpc_value* mkvalue(xmlrpc_env* env, char** format, va_list* args);
++static xmlrpc_value* mkvalue(xmlrpc_env* env,
++			     const char** format, va_list* args);
+ 
+ static xmlrpc_value* mkarray(xmlrpc_env* env,
+-			     char** format,
++			     const char** format,
+ 			     char delimiter,
+ 			     va_list* args)
+ {
+@@ -236,7 +237,7 @@
+ }
+ 
+ static xmlrpc_value* mkstruct(xmlrpc_env* env,
+-			      char** format,
++			      const char** format,
+ 			      char delimiter,
+ 			      va_list* args)
+ {
+@@ -357,7 +358,8 @@
+ }
+ #endif /* HAVE_UNICODE_WCHAR */
+ 
+-static xmlrpc_value* mkvalue(xmlrpc_env* env, char** format, va_list* args)
++static xmlrpc_value* mkvalue(xmlrpc_env* env,
++			     const char** format, va_list* args)
+ {
+     xmlrpc_value* val;
+     char *str, *contents;
+@@ -497,10 +499,10 @@
+ }
+ 
+ xmlrpc_value* xmlrpc_build_value_va (xmlrpc_env* env,
+-				     char* format,
++				     const char* format,
+ 				     va_list args)
+ {
+-    char *format_copy;
++    const char *format_copy;
+     va_list args_copy;
+     xmlrpc_value* retval;
+ 
+@@ -520,7 +522,7 @@
+ }
+ 
+ xmlrpc_value* xmlrpc_build_value (xmlrpc_env* env,
+-				  char* format, ...)
++				  const char* format, ...)
+ {
+     va_list args;
+     xmlrpc_value* retval;
+@@ -542,12 +544,12 @@
+ 
+ static void parsevalue (xmlrpc_env* env,
+ 			xmlrpc_value* val,
+-			char** format,
++			const char** format,
+ 			va_list* args);
+ 
+ static void parsearray (xmlrpc_env* env,
+ 			xmlrpc_value* array,
+-			char** format,
++			const char** format,
+ 			char delimiter,
+ 			va_list* args)
+ {
+@@ -584,7 +586,7 @@
+ 
+ static void parsestruct(xmlrpc_env* env,
+ 			xmlrpc_value* strct,
+-			char** format,
++			const char** format,
+ 			char delimiter,
+ 			va_list* args)
+ {
+@@ -633,7 +635,7 @@
+ 
+ static void parsevalue (xmlrpc_env* env,
+ 			xmlrpc_value* val,
+-			char** format,
++			const char** format,
+ 			va_list* args)
+ {
+     xmlrpc_int32 *int32ptr;
+@@ -783,12 +785,12 @@
+ 	return;
+ }
+ 
+-static void xmlrpc_parse_value_va (xmlrpc_env* env,
+-				   xmlrpc_value* value,
+-				   char* format,
+-				   va_list args)
++void xmlrpc_parse_value_va (xmlrpc_env* env,
++			    xmlrpc_value* value,
++			    const char* format,
++			    va_list args)
+ {
+-    char *format_copy;
++    const char *format_copy;
+     va_list args_copy;
+ 
+     XMLRPC_ASSERT_ENV_OK(env);
+@@ -808,7 +810,7 @@
+ 
+ void xmlrpc_parse_value (xmlrpc_env* env,
+ 			 xmlrpc_value* value,
+-			 char* format, ...)
++			 const char* format, ...)
+ {
+     va_list args;
+ 
diff -urN /usr/ports/net/xmlrpc-c/files/patch-src::xmlrpc_support.c net/xmlrpc-c/files/patch-src::xmlrpc_support.c
--- /usr/ports/net/xmlrpc-c/files/patch-src::xmlrpc_support.c	Thu Jan  1 09:00:00 1970
+++ net/xmlrpc-c/files/patch-src::xmlrpc_support.c	Tue Mar  2 23:44:38 2004
@@ -0,0 +1,11 @@
+--- src/xmlrpc_support.c.orig	Sat Apr 14 03:25:08 2001
++++ src/xmlrpc_support.c	Tue Mar  2 23:39:39 2004
+@@ -99,7 +99,7 @@
+ }
+ 
+ void xmlrpc_env_set_fault_formatted (xmlrpc_env* env, int code,
+-				     char *format, ...)
++				     const char *format, ...)
+ {
+     va_list args;
+     char buffer[ERROR_BUFFER_SZ];
diff -urN /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::DataType.cc net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::DataType.cc
--- /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::DataType.cc	Thu Jan  1 09:00:00 1970
+++ net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::DataType.cc	Tue Mar  2 23:45:16 2004
@@ -0,0 +1,187 @@
+--- tools/xml-rpc-api2cpp/DataType.cc.orig	Fri Mar 30 05:39:06 2001
++++ tools/xml-rpc-api2cpp/DataType.cc	Tue Mar  2 23:39:39 2004
+@@ -1,5 +1,5 @@
+-#include <iostream.h>
+-#include <strstream.h>
++#include <iostream>
++#include <sstream>
+ #include <stdexcept>
+ 
+ #include <XmlRpcCpp.h>
+@@ -12,12 +12,10 @@
+ //  Instances of DataType know how generate code fragments for manipulating
+ //  a specific XML-RPC data type.
+ 
+-string DataType::defaultParameterBaseName (int position) const {
+-    ostrstream name_stream;
+-    name_stream << typeName() << position << ends;
+-    string name(name_stream.str());
+-    // (Ask the ostrstream to reclaim ownership of its buffer.)
+-    name_stream.freeze(false);
++std::string DataType::defaultParameterBaseName (int position) const {
++    std::ostringstream name_stream;
++    name_stream << typeName() << position << std::ends;
++    std::string name(name_stream.str());
+     return name;
+ }
+ 
+@@ -29,27 +27,27 @@
+ 
+ class RawDataType : public DataType {
+ public:
+-    RawDataType (const string& type_name) : DataType(type_name) {}
++    RawDataType (const std::string& type_name) : DataType(type_name) {}
+     
+-    virtual string parameterFragment (const string& base_name) const;
+-    virtual string inputConversionFragment (const string& base_name) const;
+-    virtual string returnTypeFragment () const;
+-    virtual string outputConversionFragment (const string& var_name) const;
++    virtual std::string parameterFragment (const std::string& base_name) const;
++    virtual std::string inputConversionFragment (const std::string& base_name) const;
++    virtual std::string returnTypeFragment () const;
++    virtual std::string outputConversionFragment (const std::string& var_name) const;
+ };
+ 
+-string RawDataType::parameterFragment (const string& base_name) const {
++std::string RawDataType::parameterFragment (const std::string& base_name) const {
+     return "XmlRpcValue /*" + typeName() + "*/ " + base_name;
+ }
+ 
+-string RawDataType::inputConversionFragment (const string& base_name) const {
++std::string RawDataType::inputConversionFragment (const std::string& base_name) const {
+     return base_name;
+ }
+ 
+-string RawDataType::returnTypeFragment () const {
++std::string RawDataType::returnTypeFragment () const {
+     return "XmlRpcValue /*" + typeName() + "*/";
+ }
+ 
+-string RawDataType::outputConversionFragment (const string& var_name) const {
++std::string RawDataType::outputConversionFragment (const std::string& var_name) const {
+     return var_name;
+ }
+ 
+@@ -60,26 +58,26 @@
+ //  Other types can be easily converted to and from a single native type.
+ 
+ class SimpleDataType : public DataType {
+-    string mNativeType;
+-    string mMakerFunc;
+-    string mGetterFunc;
++    std::string mNativeType;
++    std::string mMakerFunc;
++    std::string mGetterFunc;
+ 
+ public:
+-    SimpleDataType (const string& type_name,
+-		    const string& native_type,
+-		    const string& maker_func,
+-		    const string& getter_func);
+-
+-    virtual string parameterFragment (const string& base_name) const;
+-    virtual string inputConversionFragment (const string& base_name) const;
+-    virtual string returnTypeFragment () const;
+-    virtual string outputConversionFragment (const string& var_name) const;
++    SimpleDataType (const std::string& type_name,
++		    const std::string& native_type,
++		    const std::string& maker_func,
++		    const std::string& getter_func);
++
++    virtual std::string parameterFragment (const std::string& base_name) const;
++    virtual std::string inputConversionFragment (const std::string& base_name) const;
++    virtual std::string returnTypeFragment () const;
++    virtual std::string outputConversionFragment (const std::string& var_name) const;
+ };
+ 
+-SimpleDataType::SimpleDataType (const string& type_name,
+-				const string& native_type,
+-				const string& maker_func,
+-				const string& getter_func)
++SimpleDataType::SimpleDataType (const std::string& type_name,
++				const std::string& native_type,
++				const std::string& maker_func,
++				const std::string& getter_func)
+     : DataType(type_name),
+       mNativeType(native_type),
+       mMakerFunc(maker_func),
+@@ -87,20 +85,20 @@
+ {
+ }
+ 
+-string SimpleDataType::parameterFragment (const string& base_name) const {
++std::string SimpleDataType::parameterFragment (const std::string& base_name) const {
+     return mNativeType + " " + base_name;
+ }
+ 
+-string SimpleDataType::inputConversionFragment (const string& base_name) const
++std::string SimpleDataType::inputConversionFragment (const std::string& base_name) const
+ {
+     return mMakerFunc + "(" + base_name + ")";
+ }
+ 
+-string SimpleDataType::returnTypeFragment () const {
++std::string SimpleDataType::returnTypeFragment () const {
+     return mNativeType; 
+ }
+ 
+-string SimpleDataType::outputConversionFragment (const string& var_name) const
++std::string SimpleDataType::outputConversionFragment (const std::string& var_name) const
+ {
+     return var_name + "." + mGetterFunc + "()";
+ }
+@@ -116,26 +114,26 @@
+ public:
+     VoidDataType () : DataType("void") {}
+     
+-    virtual string parameterFragment (const string& base_name) const;
+-    virtual string inputConversionFragment (const string& base_name) const;
+-    virtual string returnTypeFragment () const;
+-    virtual string outputConversionFragment (const string& var_name) const;
++    virtual std::string parameterFragment (const std::string& base_name) const;
++    virtual std::string inputConversionFragment (const std::string& base_name) const;
++    virtual std::string returnTypeFragment () const;
++    virtual std::string outputConversionFragment (const std::string& var_name) const;
+ };
+ 
+-string VoidDataType::parameterFragment (const string& base_name) const {
+-    throw domain_error("Can't handle functions with 'void' arguments'");
++std::string VoidDataType::parameterFragment (const std::string& base_name) const {
++    throw std::domain_error("Can't handle functions with 'void' arguments'");
+     
+ }
+ 
+-string VoidDataType::inputConversionFragment (const string& base_name) const {
+-    throw domain_error("Can't handle functions with 'void' arguments'");
++std::string VoidDataType::inputConversionFragment (const std::string& base_name) const {
++    throw std::domain_error("Can't handle functions with 'void' arguments'");
+ }
+ 
+-string VoidDataType::returnTypeFragment () const {
++std::string VoidDataType::returnTypeFragment () const {
+     return "void";
+ }
+ 
+-string VoidDataType::outputConversionFragment (const string& var_name) const {
++std::string VoidDataType::outputConversionFragment (const std::string& var_name) const {
+     return "/* Return value ignored. */";
+ }
+ 
+@@ -166,7 +164,7 @@
+ 
+ VoidDataType voidType;
+ 
+-const DataType& findDataType (const string& name) {
++const DataType& findDataType (const std::string& name) {
+     if (name == "int" || name == "i4")
+ 	return intType;
+     else if (name == "boolean")
+@@ -186,7 +184,7 @@
+     else if (name == "void")
+ 	return voidType;
+     else
+-	throw domain_error("Unknown XML-RPC type " + name);
++	throw std::domain_error("Unknown XML-RPC type " + name);
+     
+     // This code should never be executed.
+     XMLRPC_ASSERT(0);
diff -urN /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::DataType.h net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::DataType.h
--- /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::DataType.h	Thu Jan  1 09:00:00 1970
+++ net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::DataType.h	Tue Mar  2 23:45:27 2004
@@ -0,0 +1,40 @@
+--- tools/xml-rpc-api2cpp/DataType.h.orig	Mon Mar 26 03:34:53 2001
++++ tools/xml-rpc-api2cpp/DataType.h	Tue Mar  2 23:39:39 2004
+@@ -1,28 +1,28 @@
+ 
+ class DataType {
+-    string mTypeName;
++    std::string mTypeName;
+ 
+     DataType (const DataType&) { XMLRPC_ASSERT(0); }
+     DataType& operator= (const DataType&) { XMLRPC_ASSERT(0); return *this; }
+ 
+ public:
+-    DataType (const string& type_name) : mTypeName(type_name) {}
++    DataType (const std::string& type_name) : mTypeName(type_name) {}
+     virtual ~DataType () {}
+ 
+     // Return the name for this XML-RPC type.
+-    virtual string typeName () const { return mTypeName; }
++    virtual std::string typeName () const { return mTypeName; }
+ 
+     // Given a parameter position, calculate a unique base name for all
+     // parameter-related variables.
+-    virtual string defaultParameterBaseName (int position) const;
++    virtual std::string defaultParameterBaseName (int position) const;
+ 
+     // Virtual functions for processing parameters.
+-    virtual string parameterFragment (const string& base_name) const = 0;
+-    virtual string inputConversionFragment (const string& base_name) const = 0;
++    virtual std::string parameterFragment (const std::string& base_name) const = 0;
++    virtual std::string inputConversionFragment (const std::string& base_name) const = 0;
+ 
+     // Virtual functions for processing return values.
+-    virtual string returnTypeFragment () const = 0;
+-    virtual string outputConversionFragment (const string& var_name) const = 0;
++    virtual std::string returnTypeFragment () const = 0;
++    virtual std::string outputConversionFragment (const std::string& var_name) const = 0;
+ };
+ 
+-const DataType& findDataType (const string& name);
++const DataType& findDataType (const std::string& name);
diff -urN /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::SystemProxy.cc net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::SystemProxy.cc
--- /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::SystemProxy.cc	Thu Jan  1 09:00:00 1970
+++ net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::SystemProxy.cc	Tue Mar  2 23:45:48 2004
@@ -0,0 +1,19 @@
+--- tools/xml-rpc-api2cpp/SystemProxy.cc.orig	Mon Mar 26 08:46:28 2001
++++ tools/xml-rpc-api2cpp/SystemProxy.cc	Tue Mar  2 23:39:39 2004
+@@ -10,14 +10,14 @@
+     return result;
+ }
+ 
+-XmlRpcValue /*array*/ SystemProxy::methodSignature (string string1) {
++XmlRpcValue /*array*/ SystemProxy::methodSignature (std::string string1) {
+     XmlRpcValue params = XmlRpcValue::makeArray();
+     params.arrayAppendItem(XmlRpcValue::makeString(string1));
+     XmlRpcValue result = this->mClient.call("system.methodSignature", params);
+     return result;
+ }
+ 
+-string SystemProxy::methodHelp (string string1) {
++std::string SystemProxy::methodHelp (std::string string1) {
+     XmlRpcValue params = XmlRpcValue::makeArray();
+     params.arrayAppendItem(XmlRpcValue::makeString(string1));
+     XmlRpcValue result = this->mClient.call("system.methodHelp", params);
diff -urN /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::SystemProxy.h net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::SystemProxy.h
--- /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::SystemProxy.h	Thu Jan  1 09:00:00 1970
+++ net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::SystemProxy.h	Tue Mar  2 23:45:58 2004
@@ -0,0 +1,28 @@
+--- tools/xml-rpc-api2cpp/SystemProxy.h.orig	Mon Mar 26 08:49:56 2001
++++ tools/xml-rpc-api2cpp/SystemProxy.h	Tue Mar  2 23:39:39 2004
+@@ -12,7 +12,7 @@
+ public:
+     SystemProxy (const XmlRpcClient& client)
+         : mClient(client) {}
+-    SystemProxy (const string& server_url)
++    SystemProxy (const std::string& server_url)
+         : mClient(XmlRpcClient(server_url)) {}
+     SystemProxy (const SystemProxy& o)
+         : mClient(o.mClient) {}
+@@ -29,13 +29,13 @@
+        signatures. Each signature is an array of strings. The first item of
+        each signature is the return type, and any others items are
+        parameter types. */
+-    XmlRpcValue /*array*/ methodSignature (string string1);
++    XmlRpcValue /*array*/ methodSignature (std::string string1);
+ 
+     /* Given the name of a method, return a help string. */
+-    string methodHelp (string string1);
++    std::string methodHelp (std::string string1);
+ 
+     /* Process an array of calls, and return an array of results. Calls
+-       should be structs of the form {'methodName': string, 'params':
++       should be structs of the form {'methodName': std::string, 'params':
+        array}. Each result will either be a single-item array containg the
+        result value, or a struct of the form {'faultCode': int,
+        'faultString': string}. This is useful when you need to make lots of
diff -urN /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcClass.cc net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcClass.cc
--- /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcClass.cc	Thu Jan  1 09:00:00 1970
+++ net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcClass.cc	Tue Mar  2 23:46:21 2004
@@ -0,0 +1,81 @@
+--- tools/xml-rpc-api2cpp/XmlRpcClass.cc.orig	Mon Mar 26 08:49:19 2001
++++ tools/xml-rpc-api2cpp/XmlRpcClass.cc	Tue Mar  2 23:39:39 2004
+@@ -1,6 +1,6 @@
+-#include <iostream.h>
++#include <iostream>
+ #include <stdexcept>
+-#include <vector.h>
++#include <vector>
+ 
+ #include <XmlRpcCpp.h>
+ #include "DataType.h"
+@@ -14,7 +14,7 @@
+ //  This class stores information about a proxy class, and knows how to
+ //  generate code.
+ 
+-XmlRpcClass::XmlRpcClass (string class_name)
++XmlRpcClass::XmlRpcClass (std::string class_name)
+     : mClassName(class_name)
+ {
+ }
+@@ -39,37 +39,37 @@
+     mFunctions.push_back(function);
+ }
+ 
+-void XmlRpcClass::printDeclaration (ostream& out)
++void XmlRpcClass::printDeclaration (std::ostream& out)
+ {
+-    cout << "class " << mClassName << " {" << endl;
+-    cout << "    XmlRpcClient mClient;" << endl;
+-    cout << endl;
+-    cout << "public:" << endl;
+-    cout << "    " << mClassName << " (const XmlRpcClient& client)" << endl;
+-    cout << "        : mClient(client) {}" << endl;
+-    cout << "    " << mClassName << " (const string& server_url)" << endl;
+-    cout << "        : mClient(XmlRpcClient(server_url)) {}" << endl;
+-    cout << "    " << mClassName << " (const " << mClassName << "& o)" << endl;
+-    cout << "        : mClient(o.mClient) {}" << endl;
+-    cout << endl;
+-    cout << "    " << mClassName << "& operator= (const "
+-	 << mClassName << "& o) {" << endl;
+-    cout << "        if (this != &o) mClient = o.mClient;" << endl;
+-    cout << "        return *this;" << endl;
+-    cout << "    }" << endl;
++    std::cout << "class " << mClassName << " {" << std::endl;
++    std::cout << "    XmlRpcClient mClient;" << std::endl;
++    std::cout << std::endl;
++    std::cout << "public:" << std::endl;
++    std::cout << "    " << mClassName << " (const XmlRpcClient& client)" << std::endl;
++    std::cout << "        : mClient(client) {}" << std::endl;
++    std::cout << "    " << mClassName << " (const std::string& server_url)" << std::endl;
++    std::cout << "        : mClient(XmlRpcClient(server_url)) {}" << std::endl;
++    std::cout << "    " << mClassName << " (const " << mClassName << "& o)" << std::endl;
++    std::cout << "        : mClient(o.mClient) {}" << std::endl;
++    std::cout << std::endl;
++    std::cout << "    " << mClassName << "& operator= (const "
++	 << mClassName << "& o) {" << std::endl;
++    std::cout << "        if (this != &o) mClient = o.mClient;" << std::endl;
++    std::cout << "        return *this;" << std::endl;
++    std::cout << "    }" << std::endl;
+ 
+-    vector<XmlRpcFunction>::iterator f;
++    std::vector<XmlRpcFunction>::iterator f;
+     for (f = mFunctions.begin(); f < mFunctions.end(); ++f) {
+-	f->printDeclarations(cout);
++	f->printDeclarations(std::cout);
+     }
+ 
+-    cout << "};" << endl;    
++    std::cout << "};" << std::endl;    
+ }
+ 
+-void XmlRpcClass::printDefinition (ostream& out)
++void XmlRpcClass::printDefinition (std::ostream& out)
+ {
+-    vector<XmlRpcFunction>::iterator f;
++    std::vector<XmlRpcFunction>::iterator f;
+     for (f = mFunctions.begin(); f < mFunctions.end(); ++f) {
+-	f->printDefinitions(cout, mClassName);
++	f->printDefinitions(std::cout, mClassName);
+     }
+ }
diff -urN /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcClass.h net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcClass.h
--- /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcClass.h	Thu Jan  1 09:00:00 1970
+++ net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcClass.h	Tue Mar  2 23:46:30 2004
@@ -0,0 +1,29 @@
+--- tools/xml-rpc-api2cpp/XmlRpcClass.h.orig	Mon Mar 26 08:43:07 2001
++++ tools/xml-rpc-api2cpp/XmlRpcClass.h	Tue Mar  2 23:39:39 2004
+@@ -1,19 +1,19 @@
+-#include <vector.h>
++#include <vector>
+ 
+ class XmlRpcClass {
+-    string mClassName;
+-    vector<XmlRpcFunction> mFunctions;
++    std::string mClassName;
++    std::vector<XmlRpcFunction> mFunctions;
+ 
+ 
+ public:
+-    XmlRpcClass (string class_name);
++    XmlRpcClass (std::string class_name);
+     XmlRpcClass (const XmlRpcClass&);
+     XmlRpcClass& operator= (const XmlRpcClass&);
+ 
+-    string className () const { return mClassName; }
++    std::string className () const { return mClassName; }
+ 
+     void addFunction (const XmlRpcFunction& function);
+ 
+-    void printDeclaration (ostream& out);
+-    void printDefinition (ostream& out);
++    void printDeclaration (std::ostream& out);
++    void printDefinition (std::ostream& out);
+ };
diff -urN /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcFucntion.cc net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcFucntion.cc
--- /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcFucntion.cc	Thu Jan  1 09:00:00 1970
+++ net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcFucntion.cc	Tue Mar  2 23:46:54 2004
@@ -0,0 +1,123 @@
+--- tools/xml-rpc-api2cpp/XmlRpcFunction.cc.orig	Mon Mar 26 08:21:07 2001
++++ tools/xml-rpc-api2cpp/XmlRpcFunction.cc	Tue Mar  2 23:39:39 2004
+@@ -1,4 +1,4 @@
+-#include <iostream.h>
++#include <iostream>
+ #include <stdexcept>
+ 
+ #include <XmlRpcCpp.h>
+@@ -12,9 +12,9 @@
+ //  Contains everything we know about a given server function, and knows
+ //  how to print local bindings.
+ 
+-XmlRpcFunction::XmlRpcFunction(const string& function_name,
+-			       const string& method_name,
+-			       const string& help,
++XmlRpcFunction::XmlRpcFunction(const std::string& function_name,
++			       const std::string& method_name,
++			       const std::string& help,
+ 			       XmlRpcValue synopsis)
+     : mFunctionName(function_name), mMethodName(method_name),
+       mHelp(help), mSynopsis(synopsis)
+@@ -37,10 +37,10 @@
+     return *this;
+ }
+ 
+-void XmlRpcFunction::printDeclarations (ostream& out) {
++void XmlRpcFunction::printDeclarations (std::ostream& out) {
+ 
+     // XXX - Do a sloppy job of printing documentation.
+-    out << endl << "    /* " << mHelp << " */" << endl;
++    out << std::endl << "    /* " << mHelp << " */" << std::endl;
+ 
+     // Print each declaration.
+     size_t end = mSynopsis.arraySize();
+@@ -48,16 +48,16 @@
+ 	printDeclaration(out, i);
+ }
+ 
+-void XmlRpcFunction::printDefinitions (ostream& out, const string& className) {
++void XmlRpcFunction::printDefinitions (std::ostream& out, const std::string& className) {
+     size_t end = mSynopsis.arraySize();
+     for (size_t i = 0; i < end; i++) {
+-	out << endl;
++	out << std::endl;
+ 	printDefinition(out, className, i);
+     }
+ }
+ 
+ // Print the parameter declarations.
+-void XmlRpcFunction::printParameters (ostream& out, size_t synopsis_index) {
++void XmlRpcFunction::printParameters (std::ostream& out, size_t synopsis_index) {
+     size_t end = parameterCount(synopsis_index);
+     bool first = true;
+     for (size_t i = 0; i < end; i++) {
+@@ -67,47 +67,47 @@
+ 	    out << ", ";
+ 
+ 	const DataType& ptype (parameterType(synopsis_index, i));
+-	string basename = ptype.defaultParameterBaseName(i + 1);
++	std::string basename = ptype.defaultParameterBaseName(i + 1);
+ 	out << ptype.parameterFragment(basename);
+     }
+ }
+ 
+-void XmlRpcFunction::printDeclaration (ostream& out, size_t synopsis_index) {
++void XmlRpcFunction::printDeclaration (std::ostream& out, size_t synopsis_index) {
+     const DataType& rtype (returnType(synopsis_index));
+     out << "    " << rtype.returnTypeFragment() << " "
+ 	<< mFunctionName << " (";
+     printParameters(out, synopsis_index);
+-    out << ");" << endl;
++    out << ");" << std::endl;
+ }
+ 
+-void XmlRpcFunction::printDefinition (ostream& out,
+-				      const string& className,
++void XmlRpcFunction::printDefinition (std::ostream& out,
++				      const std::string& className,
+ 				      size_t synopsis_index)
+ {
+     const DataType& rtype (returnType(synopsis_index));
+     out << rtype.returnTypeFragment() << " "
+ 	<< className << "::" << mFunctionName << " (";
+     printParameters(out, synopsis_index);
+-    out << ") {" << endl;    
+-    out << "    XmlRpcValue params = XmlRpcValue::makeArray();" << endl;
++    out << ") {" << std::endl;    
++    out << "    XmlRpcValue params = XmlRpcValue::makeArray();" << std::endl;
+ 
+     /* Emit code to convert the parameters into an array of XML-RPC objects. */
+     size_t end = parameterCount(synopsis_index);
+     for (size_t i = 0; i < end; i++) {
+ 	const DataType& ptype (parameterType(synopsis_index, i));
+-	string basename = ptype.defaultParameterBaseName(i + 1);
++	std::string basename = ptype.defaultParameterBaseName(i + 1);
+ 	out << "    params.arrayAppendItem("
+-	    << ptype.inputConversionFragment(basename) << ");" << endl;
++	    << ptype.inputConversionFragment(basename) << ");" << std::endl;
+     }
+ 
+     /* Emit the function call.*/
+     out << "    XmlRpcValue result = this->mClient.call(\""
+-	<< mMethodName << "\", params);" << endl;    
++	<< mMethodName << "\", params);" << std::endl;    
+ 
+     /* Emit the return statement. */
+     out << "    return " << rtype.outputConversionFragment("result")
+-	<< ";" << endl;
+-    out << "}" << endl;
++	<< ";" << std::endl;
++    out << "}" << std::endl;
+ }
+ 
+ const DataType& XmlRpcFunction::returnType (size_t synopsis_index) {
+@@ -119,7 +119,7 @@
+     XmlRpcValue func_synop = mSynopsis.arrayGetItem(synopsis_index);
+     size_t size = func_synop.arraySize();
+     if (size < 1)
+-	throw domain_error("Synopsis contained no items");
++	throw std::domain_error("Synopsis contained no items");
+     return size - 1;
+ }
+ 
diff -urN /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcFucntion.h net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcFucntion.h
--- /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcFucntion.h	Thu Jan  1 09:00:00 1970
+++ net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcFucntion.h	Tue Mar  2 23:47:02 2004
@@ -0,0 +1,42 @@
+--- tools/xml-rpc-api2cpp/XmlRpcFunction.h.orig	Mon Mar 26 05:17:50 2001
++++ tools/xml-rpc-api2cpp/XmlRpcFunction.h	Tue Mar  2 23:39:39 2004
+@@ -1,27 +1,27 @@
+ 
+ class XmlRpcFunction {
+-    string mFunctionName;
+-    string mMethodName;
+-    string mHelp;
++    std::string mFunctionName;
++    std::string mMethodName;
++    std::string mHelp;
+     XmlRpcValue mSynopsis;
+ 
+ public: 
+-    XmlRpcFunction(const string& function_name,
+-		   const string& method_name,
+-		   const string& help,
++    XmlRpcFunction(const std::string& function_name,
++		   const std::string& method_name,
++		   const std::string& help,
+ 		   XmlRpcValue synopsis);
+ 
+     XmlRpcFunction (const XmlRpcFunction&);
+     XmlRpcFunction& operator= (const XmlRpcFunction&);
+     
+-    void printDeclarations (ostream& out);
+-    void printDefinitions  (ostream& out, const string& className);
++    void printDeclarations (std::ostream& out);
++    void printDefinitions  (std::ostream& out, const std::string& className);
+ 
+ private:
+-    void printParameters  (ostream& out, size_t synopsis_index);
+-    void printDeclaration (ostream& out, size_t synopsis_index);
+-    void printDefinition  (ostream& out,
+-			   const string& className,
++    void printParameters  (std::ostream& out, size_t synopsis_index);
++    void printDeclaration (std::ostream& out, size_t synopsis_index);
++    void printDefinition  (std::ostream& out,
++			   const std::string& className,
+ 			   size_t synopsis_index);
+ 
+     const DataType& returnType (size_t synopsis_index);
diff -urN /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::xml-rpc-api2cpp net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::xml-rpc-api2cpp
--- /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::xml-rpc-api2cpp	Thu Jan  1 09:00:00 1970
+++ net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::xml-rpc-api2cpp	Tue Mar  2 23:47:22 2004
@@ -0,0 +1,170 @@
+--- tools/xml-rpc-api2cpp/xml-rpc-api2cpp.cc.orig	Thu Apr 12 08:21:38 2001
++++ tools/xml-rpc-api2cpp/xml-rpc-api2cpp.cc	Tue Mar  2 23:39:39 2004
+@@ -1,4 +1,4 @@
+-#include <iostream.h>
++#include <iostream>
+ #include <stdexcept>
+ 
+ #include <XmlRpcCpp.h>
+@@ -17,9 +17,9 @@
+ //  Connect to a remote server and extract the information we'll need to
+ //  build a proxy class.
+ 
+-XmlRpcClass get_class_info (string server_url,
+-			    string class_prefix,
+-			    string class_name)
++XmlRpcClass get_class_info (std::string server_url,
++			    std::string class_prefix,
++			    std::string class_name)
+ {
+     // Create a place to store our data.
+     XmlRpcClass info(class_name);
+@@ -33,22 +33,22 @@
+     for (size_t i = 0; i < end; i++) {
+ 
+ 	// Break the method name into two pieces.
+-	string method_prefix;
+-	string function_name;
+-	string method_name = methods.arrayGetItem(i).getString();
++	std::string method_prefix;
++	std::string function_name;
++	std::string method_name = methods.arrayGetItem(i).getString();
+ 	size_t last_dot = method_name.rfind('.');
+-	if (last_dot == string::npos) {
++	if (last_dot == std::string::npos) {
+ 	    function_name = method_name;
+ 	} else {
+-	    method_prefix = string(method_name, 0, last_dot);
+-	    function_name = string(method_name, last_dot + 1);
++	    method_prefix = std::string(method_name, 0, last_dot);
++	    function_name = std::string(method_name, last_dot + 1);
+ 	}
+ 
+ 	// Decide whether we care about this function.
+ 	if (method_prefix == class_prefix) {
+ 
+ 	    // Fetch some information about the function.
+-	    string help = system.methodHelp(method_name);
++	    std::string help = system.methodHelp(method_name);
+ 	    XmlRpcValue signature = system.methodSignature(method_name);
+ 
+ 	    // Add this function to our class information.
+@@ -66,23 +66,23 @@
+ //=========================================================================
+ //  Print a complete header for the specified class.
+ 
+-void print_header (ostream& out, XmlRpcClass& class_info) {
+-    string class_name = class_info.className();
+-    out << "// " << class_name << ".h - xmlrpc-c C++ proxy class" << endl;
+-    out << "// Auto-generated by xml-rpc-api2cpp." << endl;
+-    out << endl;
+-
+-    string header_symbol = "_" + class_name + "_H_";
+-    out << "#ifndef " << header_symbol << endl;
+-    out << "#define " << header_symbol << " 1" << endl;
+-    out << endl;
+-    out << "#include <XmlRpcCpp.h>" << endl;
+-    out << endl;
++void print_header (std::ostream& out, XmlRpcClass& class_info) {
++    std::string class_name = class_info.className();
++    out << "// " << class_name << ".h - xmlrpc-c C++ proxy class" << std::endl;
++    out << "// Auto-generated by xml-rpc-api2cpp." << std::endl;
++    out << std::endl;
++
++    std::string header_symbol = "_" + class_name + "_H_";
++    out << "#ifndef " << header_symbol << std::endl;
++    out << "#define " << header_symbol << " 1" << std::endl;
++    out << std::endl;
++    out << "#include <XmlRpcCpp.h>" << std::endl;
++    out << std::endl;
+ 
+-    class_info.printDeclaration(cout);
++    class_info.printDeclaration(std::cout);
+ 
+-    out << endl;
+-    out << "#endif /* " << header_symbol << " */" << endl;
++    out << std::endl;
++    out << "#endif /* " << header_symbol << " */" << std::endl;
+ }
+ 
+ 
+@@ -91,16 +91,16 @@
+ //=========================================================================
+ //  Print a complete header for the specified class.
+ 
+-void print_cc_file (ostream& out, XmlRpcClass& class_info) {
+-    string class_name = class_info.className();
+-    out << "// " << class_name << ".cc - xmlrpc-c C++ proxy class" << endl;
+-    out << "// Auto-generated by xml-rpc-api2cpp." << endl;
+-    out << endl;
++void print_cc_file (std::ostream& out, XmlRpcClass& class_info) {
++    std::string class_name = class_info.className();
++    out << "// " << class_name << ".cc - xmlrpc-c C++ proxy class" << std::endl;
++    out << "// Auto-generated by xml-rpc-api2cpp." << std::endl;
++    out << std::endl;
+ 
+-    out << "#include <XmlRpcCpp.h>" << endl;
+-    out << "#include \"" << class_name << ".h\"" << endl;
++    out << "#include <XmlRpcCpp.h>" << std::endl;
++    out << "#include \"" << class_name << ".h\"" << std::endl;
+ 
+-    class_info.printDefinition(cout);
++    class_info.printDefinition(std::cout);
+ }
+ 
+ 
+@@ -113,18 +113,18 @@
+ 
+     /* Parse our command-line arguments. */
+     if (argc != 4) {
+-	cerr << argv[0] << ": Usage:" << endl
++	std::cerr << argv[0] << ": Usage:" << std::endl
+ 	     << "  xml-rpc-api2cpp <server_url> <method_prefix> <local_class>"
+-	     << endl << endl
+-	     << "Sample arguments:" << endl
+-	     << "  server_url = http://localhost/RPC2" << endl
+-	     << "  method_prefix = system" << endl
+-	     << "  local_class = SystemProxy" << endl;
++	     << std::endl << std::endl
++	     << "Sample arguments:" << std::endl
++	     << "  server_url = http://localhost/RPC2" << std::endl
++	     << "  method_prefix = system" << std::endl
++	     << "  local_class = SystemProxy" << std::endl;
+ 	exit(1);
+     }
+-    string server_url = argv[1];
+-    string method_prefix = argv[2];
+-    string local_class = argv[3];
++    std::string server_url = argv[1];
++    std::string method_prefix = argv[2];
++    std::string local_class = argv[3];
+ 
+     int status = 0;
+     XmlRpcClient::Initialize(NAME, VERSION);
+@@ -133,18 +133,18 @@
+ 	XmlRpcClass system = get_class_info(server_url,
+ 					    method_prefix,
+ 					    local_class);
+-	print_header(cout, system);
+-	cout << endl;
+-	print_cc_file(cout, system);
++	print_header(std::cout, system);
++	std::cout << std::endl;
++	print_cc_file(std::cout, system);
+     } catch (XmlRpcFault& fault) {
+-	cerr << argv[0] << ": XML-RPC fault #" << fault.getFaultCode()
+-	     << ": " << fault.getFaultString() << endl;
++	std::cerr << argv[0] << ": XML-RPC fault #" << fault.getFaultCode()
++	     << ": " << fault.getFaultString() << std::endl;
+ 	status = 1;
+-    } catch (logic_error& err) {
+-	cerr << argv[0] << ": " << err.what() << endl;
++    } catch (std::logic_error& err) {
++	std::cerr << argv[0] << ": " << err.what() << std::endl;
+ 	status = 1;
+     } catch (...) {
+-	cerr << argv[0] << ": Unknown exception" << endl;
++	std::cerr << argv[0] << ": Unknown exception" << std::endl;
+ 	status = 1;
+     }
+ 
>Release-Note:
>Audit-Trail:
>Unformatted:



More information about the freebsd-ports-bugs mailing list