p4ruby 2022.1.2359956-x64-mingw-ucrt

data/ext/P4/p4mergedata.cpp

@@ -0,0 +1,272 @@
+/*******************************************************************************
+
+ Copyright (c) 2001-2008, Perforce Software, Inc.  All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1.  Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ 2.  Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL PERFORCE SOFTWARE, INC. BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ *******************************************************************************/
+
+/*******************************************************************************
+ * Name		: p4mergedata.cc
+ *
+ * Author	: Tony Smith <tony@perforce.com> or <tony@smee.org>
+ *
+ * Description	: Class for holding merge data
+ *
+ ******************************************************************************/
+#include <ruby.h>
+#include "undefdups.h"
+#include <p4/clientapi.h>
+#include <p4/i18napi.h>
+#include <p4/strtable.h>
+#include <p4/spec.h>
+#include "p4result.h"
+#include "p4rubydebug.h"
+#include "clientuserruby.h"
+#include "p4utils.h"
+#include "p4mergedata.h"
+
+static void mergedata_free(P4MergeData *md) {
+	delete md;
+}
+
+static void mergedata_mark(P4MergeData *md) {
+	md->GCMark();
+}
+
+P4MergeData::P4MergeData(ClientUser *ui, ClientMerge *m, StrPtr &hint,
+		VALUE info) {
+	this->debug = 0;
+	this->actionmerger = 0;
+	this->ui = ui;
+	this->merger = m;
+	this->hint = hint;
+	this->info = info;
+
+	// Extract (forcibly) the paths from the RPC buffer.
+	StrPtr *t;
+	if ((t = ui->varList->GetVar("baseName"))) base = t->Text();
+	if ((t = ui->varList->GetVar("yourName"))) yours = t->Text();
+	if ((t = ui->varList->GetVar("theirName"))) theirs = t->Text();
+
+}
+
+P4MergeData::P4MergeData(ClientUser *ui, ClientResolveA *m, StrPtr &hint,
+		VALUE info) {
+	this->debug = 0;
+	this->merger = 0;
+	this->ui = ui;
+	this->hint = hint;
+	this->actionmerger = m;
+	this->info = info;
+
+}
+
+VALUE P4MergeData::GetYourName() {
+	if (merger && yours.Length())
+		return P4Utils::ruby_string(yours.Text());
+	else
+		return Qnil;
+}
+
+VALUE P4MergeData::GetTheirName() {
+	if (merger && theirs.Length())
+		return P4Utils::ruby_string(theirs.Text());
+	else
+		return Qnil;
+}
+
+VALUE P4MergeData::GetBaseName() {
+	if (merger && base.Length())
+		return P4Utils::ruby_string(base.Text());
+	else
+		return Qnil;
+}
+
+VALUE P4MergeData::GetYourPath() {
+	if (merger && merger->GetYourFile())
+		return P4Utils::ruby_string(merger->GetYourFile()->Name());
+	else
+		return Qnil;
+}
+
+VALUE P4MergeData::GetTheirPath() {
+	if (merger && merger->GetTheirFile())
+		return P4Utils::ruby_string(merger->GetTheirFile()->Name());
+	else
+		return Qnil;
+}
+
+VALUE P4MergeData::GetBasePath() {
+	if (merger && merger->GetBaseFile())
+		return P4Utils::ruby_string(merger->GetBaseFile()->Name());
+	else
+		return Qnil;
+}
+
+VALUE P4MergeData::GetResultPath() {
+	if (merger && merger->GetResultFile())
+		return P4Utils::ruby_string(merger->GetResultFile()->Name());
+	else
+		return Qnil;
+}
+
+VALUE P4MergeData::GetMergeHint() {
+	if (hint.Length())
+		return P4Utils::ruby_string(hint.Text());
+	else
+		return Qnil;
+}
+
+VALUE P4MergeData::RunMergeTool() {
+	Error e;
+	if (merger) {
+		ui->Merge(merger->GetBaseFile(), merger->GetTheirFile(),
+				merger->GetYourFile(), merger->GetResultFile(), &e);
+
+		if (e.Test()) return Qfalse;
+		return Qtrue;
+	}
+	return Qfalse;
+}
+
+VALUE P4MergeData::GetActionResolveStatus() {
+	return actionmerger ? Qtrue : Qfalse;
+}
+
+VALUE P4MergeData::GetContentResolveStatus() {
+	return merger ? Qtrue : Qfalse;
+}
+
+VALUE P4MergeData::GetMergeInfo() {
+	return this->info;
+}
+
+VALUE P4MergeData::GetMergeAction() {
+	//	If we don't have an actionMerger then return nil
+	if (actionmerger) {
+		StrBuf buf;
+		actionmerger->GetMergeAction().Fmt(&buf, EF_PLAIN);
+		if (buf.Length())
+			return P4Utils::ruby_string(buf.Text());
+		else
+			return Qnil;
+	}
+	return Qnil;
+}
+
+VALUE P4MergeData::GetYoursAction() {
+	if (actionmerger) {
+		StrBuf buf;
+		actionmerger->GetYoursAction().Fmt(&buf, EF_PLAIN);
+		if (buf.Length())
+			return P4Utils::ruby_string(buf.Text());
+		else
+			return Qnil;
+	}
+	return Qnil;
+}
+
+VALUE P4MergeData::GetTheirAction() {
+	if (actionmerger) {
+		StrBuf buf;
+		actionmerger->GetTheirAction().Fmt(&buf, EF_PLAIN);
+		if (buf.Length())
+			return P4Utils::ruby_string(buf.Text());
+		else
+			return Qnil;
+	}
+	return Qnil;
+}
+
+VALUE P4MergeData::GetType() {
+	if (actionmerger) {
+		StrBuf buf;
+		actionmerger->GetType().Fmt(&buf, EF_PLAIN);
+		if (buf.Length())
+			return P4Utils::ruby_string(buf.Text());
+		else
+			return Qnil;
+	}
+	return Qnil;
+}
+
+void P4MergeData::Invalidate() {
+	actionmerger = NULL;
+	merger = NULL;
+}
+
+VALUE P4MergeData::GetString() {
+	StrBuf result;
+	StrBuf buffer;
+
+	if (actionmerger) {
+		result << "P4MergeData - Action\n";
+		actionmerger->GetMergeAction().Fmt(&buffer, EF_INDENT);
+		result << "\tmergeAction: " << buffer << "\n";
+		buffer.Clear();
+
+		actionmerger->GetTheirAction().Fmt(&buffer, EF_INDENT);
+		result << "\ttheirAction: " << buffer << "\n";
+		buffer.Clear();
+
+		actionmerger->GetYoursAction().Fmt(&buffer, EF_INDENT);
+		result << "\tyoursAction: " << buffer << "\n";
+		buffer.Clear();
+
+		actionmerger->GetType().Fmt(&buffer, EF_INDENT);
+		result << "\ttype: " << buffer << "\n";
+		buffer.Clear();
+
+		result << "\thint: " << hint << "\n";
+		return P4Utils::ruby_string(result.Text());
+	} else {
+		result << "P4MergeData - Content\n";
+		if (yours.Length()) result << "yourName: " << yours << "\n";
+		if (theirs.Length()) result << "thierName: " << theirs << "\n";
+		if (base.Length()) result << "baseName: " << base << "\n";
+
+		if ( merger && merger->GetYourFile())
+			result << "\tyourFile: " << merger->GetYourFile()->Name() << "\n";
+		if ( merger && merger->GetTheirFile())
+			result << "\ttheirFile: " << merger->GetTheirFile()->Name() << "\n";
+		if ( merger && merger->GetBaseFile())
+			result << "\tbaseFile: " << merger->GetBaseFile()->Name() << "\n";
+
+		return P4Utils::ruby_string(result.Text());
+	}
+	return Qnil;
+}
+
+VALUE P4MergeData::Wrap(VALUE pClass) {
+	VALUE md;
+	VALUE argv[1];
+
+	md = Data_Wrap_Struct(pClass, mergedata_mark, mergedata_free, this);
+	rb_obj_call_init(md, 0, argv);
+	return md;
+}
+
+void P4MergeData::GCMark() {
+	// We don't hold Ruby objects
+}
+

data/ext/P4/p4mergedata.h

@@ -0,0 +1,97 @@
+/*******************************************************************************
+
+Copyright (c) 2001-2008, Perforce Software, Inc.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1.  Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+2.  Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL PERFORCE SOFTWARE, INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*******************************************************************************/
+
+/*******************************************************************************
+ * Name		: p4mergedata.h
+ *
+ * Author	: Tony Smith <tony@perforce.com> or <tony@smee.org>
+ *
+ * Description	: Class for holding merge data
+ *
+ ******************************************************************************/
+
+class P4MergeData
+{
+    public:
+    P4MergeData( ClientUser *ui, ClientMerge *m, StrPtr &hint, VALUE info );
+    P4MergeData( ClientUser *ui, ClientResolveA *m, StrPtr &hint, VALUE info );
+
+    void  SetDebug( int d )	{ debug = d;	}
+
+    //	Content resolve
+    VALUE	GetYourName();
+    VALUE	GetTheirName();
+    VALUE	GetBaseName();
+
+    VALUE	GetYourPath();
+    VALUE	GetTheirPath();
+    VALUE	GetBasePath();
+    VALUE	GetResultPath();
+
+    VALUE	RunMergeTool();
+
+    //	What type of resolve is it?
+    VALUE	GetActionResolveStatus();
+    VALUE	GetContentResolveStatus();
+
+    //	Action Resolve
+    VALUE	GetMergeInfo();
+
+    VALUE	GetMergeAction();
+    VALUE	GetYoursAction();
+    VALUE	GetTheirAction();
+    VALUE	GetType();
+
+
+    VALUE	GetString();
+    VALUE	GetMergeHint();
+
+    // Wrap as Ruby object of class pClass
+    VALUE	Wrap( VALUE pClass );
+
+    // Invalidate our merger and actionMerger objects as they do not survive
+    // beyond the life of a resolve while this object itself might well do so,
+    // particularly in the case of an exception raised from within the block.
+    void	Invalidate();
+
+    // Ruby garbage collection
+    void  GCMark();
+
+    private:
+    int				debug;
+    ClientUser *	ui;
+    StrBuf			hint;
+    ClientMerge *	merger;
+    ClientResolveA*	actionmerger;
+    StrBuf			yours;
+    StrBuf			theirs;
+    StrBuf			base;
+
+    VALUE			info;
+
+};
+

data/ext/P4/p4result.cpp

@@ -0,0 +1,260 @@
+/*******************************************************************************
+
+Copyright (c) 2001-2008, Perforce Software, Inc.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1.  Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+2.  Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL PERFORCE SOFTWARE, INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*******************************************************************************/
+
+
+/*******************************************************************************
+ * Name		: p4result.cc
+ *
+ * Author	: Tony Smith <tony@perforce.com> or <tony@smee.org>
+ *
+ * Description	: Ruby class for holding results of Perforce commands 
+ *
+ ******************************************************************************/
+
+#include <ruby.h>
+#include "undefdups.h"
+#include <p4/clientapi.h>
+#include "gc_hack.h"
+#include "p4error.h"
+#include "p4utils.h"
+#include "p4result.h"
+
+P4Result::P4Result()
+{
+    output = rb_ary_new();
+    warnings = rb_ary_new();
+    errors = rb_ary_new();
+    messages = rb_ary_new();
+    track = rb_ary_new();
+    apiLevel = atoi( P4Tag::l_client );
+    ID	idP4 	= rb_intern( "P4" );
+    ID	idP4Msg	= rb_intern( "Message" );
+
+    VALUE cP4	= rb_const_get_at( rb_cObject, idP4 );
+    cP4Msg	= rb_const_get_at( cP4, idP4Msg );
+
+    Reset();
+}
+
+
+void
+P4Result::Reset()
+{
+    output = rb_ary_new();
+    warnings = rb_ary_new();
+    errors = rb_ary_new();
+    messages = rb_ary_new();
+    track = rb_ary_new();
+}
+
+//
+// Direct output - not via a message of any kind. For example,
+// binary output.
+//
+void
+P4Result::AddOutput( VALUE v )
+{
+    rb_ary_push( output, v );
+
+    //
+    // Call the ruby thread scheduler to allow another thread to run
+    // now. We should perhaps only call this every 'n' times, but I've
+    // no idea what a good value for n might be; so for now at least, n=1
+    //
+    rb_thread_schedule();
+}
+
+/*
+ * Main distribution of output to the user. This method sorts the
+ * output into groups: output, warnings, errors, and sends all output
+ * (regardless of severity) to the messages array.
+ */
+void
+P4Result::AddMessage( Error *e )
+{
+
+    int s;
+    s = e->GetSeverity();
+
+    // 
+    // Empty and informational messages are pushed out as output as nothing
+    // worthy of error handling has occurred. Warnings go into the warnings
+    // list and the rest are lumped together as errors.
+    //
+
+    if ( s == E_EMPTY || s == E_INFO )
+	rb_ary_push( output, FmtMessage( e ) );
+    else if ( s == E_WARN )
+	rb_ary_push( warnings, FmtMessage( e ) );
+    else
+	rb_ary_push( errors, FmtMessage( e ) );
+
+    //
+    // Whatever severity, format the message into the messages array, wrapped
+    // up in a P4::Message object.
+    //
+    rb_ary_push( messages, WrapMessage( e ) );
+
+    //
+    // Call the ruby thread scheduler to allow another thread to run
+    // now. We should perhaps only call this every 'n' times, but I've 
+    // no idea what a good value for n might be; so for now at least, n=1
+    //
+    rb_thread_schedule();
+}
+
+void
+P4Result::AddTrack( const char *msg )
+{
+    rb_ary_push( track,  P4Utils::ruby_string( msg ) );
+
+    //
+    // Call the ruby thread scheduler to allow another thread to run
+    // now. We should perhaps only call this every 'n' times, but I've 
+    // no idea what a good value for n might be; so for now at least, n=1
+    //
+    rb_thread_schedule();
+}
+
+void
+P4Result::DeleteTrack()
+{
+    rb_ary_clear( track );
+
+    //
+    // Call the ruby thread scheduler to allow another thread to run
+    // now. We should perhaps only call this every 'n' times, but I've
+    // no idea what a good value for n might be; so for now at least, n=1
+    //
+    rb_thread_schedule();
+}
+
+void
+P4Result::AddTrack( VALUE t )
+{
+    rb_ary_push( track, t );
+
+    //
+    // Call the ruby thread scheduler to allow another thread to run
+    // now. We should perhaps only call this every 'n' times, but I've 
+    // no idea what a good value for n might be; so for now at least, n=1
+    //
+    rb_thread_schedule();
+}
+
+int
+P4Result::ErrorCount()
+{
+    return Length( errors );
+}
+
+int
+P4Result::WarningCount()
+{
+    return Length( warnings );
+}
+
+void
+P4Result::FmtErrors( StrBuf &buf )
+{
+    Fmt( "[Error]: ", errors, buf );
+}
+
+void
+P4Result::FmtWarnings( StrBuf &buf )
+{
+    Fmt( "[Warning]: ", warnings, buf );
+}
+
+
+int
+P4Result::Length( VALUE ary )
+{
+    ID		iLength;
+    VALUE 	len;
+
+    iLength = rb_intern( "length" );
+
+    len = rb_funcall( ary, iLength, 0 );
+    return NUM2INT( len );
+}
+
+void
+P4Result::GCMark()
+{
+    rb_gc_mark( output );
+    rb_gc_mark( errors );
+    rb_gc_mark( warnings );
+    rb_gc_mark( messages );
+    rb_gc_mark( track );
+}
+
+
+void
+P4Result::Fmt( const char *label, VALUE ary, StrBuf &buf )
+{
+    ID		idJoin;
+    VALUE	s1;
+    StrBuf	csep;
+    VALUE	rsep;
+
+    buf.Clear();
+    // If the array is empty, then we just return
+    if( ! Length( ary ) ) return;
+
+    // Not empty, so we'll format it. 
+    idJoin 	= rb_intern( "join" );
+ 
+    // This is the string we'll use to prefix each entry in the array
+    csep << "\n\t" << label;
+    rsep =  P4Utils::ruby_string( csep.Text() );
+
+    // Since Array#join() won't prefix the first element with the separator
+    // we'll have to do it manually.
+    buf << csep;
+
+    // Join the array elements together, and append the result to the buffer
+    s1 		= rb_funcall( ary, idJoin, 1, rsep );
+    buf << StringValuePtr( s1 );
+
+    return;
+}
+
+VALUE
+P4Result::FmtMessage( Error *e )
+{
+    StrBuf t;
+    e->Fmt( t, EF_PLAIN );
+    return  P4Utils::ruby_string( t.Text(), t.Length() );
+}
+
+VALUE
+P4Result::WrapMessage( Error *e )
+{
+    P4Error *pe = new P4Error( *e );
+    return pe->Wrap( cP4Msg );
+}

data/ext/P4/p4result.h

@@ -0,0 +1,86 @@
+/*******************************************************************************
+
+Copyright (c) 2001-2008, Perforce Software, Inc.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1.  Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+2.  Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL PERFORCE SOFTWARE, INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*******************************************************************************/
+
+/*******************************************************************************
+ * Name		: p4result.h
+ *
+ * Author	: Tony Smith <tony@perforce.com> or <tony@smee.org>
+ *
+ * Description	: C++ class for holding results of Perforce commands 
+ *
+ ******************************************************************************/
+
+class P4Result
+{
+    public:
+
+    P4Result();
+    
+    // Setting
+    void	AddOutput( VALUE v );
+    void	AddMessage( Error *e );
+    void	AddTrack( const char *msg );
+    void	AddTrack( VALUE t );
+    void 	DeleteTrack();
+
+    // Getting
+    VALUE	GetOutput()	{ return output;	}
+    VALUE	GetErrors()	{ return errors;	}
+    VALUE	GetWarnings()	{ return warnings;	}
+    VALUE	GetMessages()	{ return messages;	}
+    VALUE 	GetTrack()	{ return track;         }
+
+    // Get errors/warnings as a formatted string
+    void	FmtErrors( StrBuf &buf );
+    void	FmtWarnings( StrBuf &buf );
+
+    // Set API level for backwards compatibility
+    void	SetApiLevel( int l )	{ apiLevel = l; }
+    // Testing
+    int		ErrorCount();
+    int		WarningCount();
+
+    // Clear previous results
+    void	Reset();
+
+    // Ruby garbage collection
+    void	GCMark();
+
+    private:
+    int		Length( VALUE ary );
+    void	Fmt( const char *label, VALUE ary, StrBuf &buf );
+    VALUE	FmtMessage( Error *e );
+    VALUE	WrapMessage( Error *e );
+
+    VALUE	cP4Msg;
+    VALUE	output;
+    VALUE	warnings;
+    VALUE	errors;
+    VALUE	messages;
+    VALUE	track;
+    int		apiLevel;
+};