p4ruby 2015.2.1265122-x86-mingw32

data/ext/P4/p4clientapi.h

@@ -0,0 +1,239 @@
+/*******************************************************************************
+
+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		: p4clientapi.h
+ *
+ * Author	: Tony Smith <tony@perforce.com> or <tony@smee.org>
+ *
+ * Description	: Ruby bindings for the Perforce API. Definitions of our
+ * 		  main interface to Perforce
+ *
+ ******************************************************************************/
+
+
+/*******************************************************************************
+ * P4ClientApi class - where we register our Ruby classes and plumb together 
+ * the components
+ ******************************************************************************/
+
+class Enviro;
+class P4ClientApi
+{
+public:
+    P4ClientApi();
+    ~P4ClientApi();
+
+    // Tagged mode - can be enabled/disabled on a per-command basis
+    void Tagged( int enable );
+    int	 IsTagged()			{ return IsTag();		}
+
+    // Set track mode - track usage of this command on the server
+    int SetTrack( int enable );
+    int GetTrack()			{ return IsTrackMode() != 0;    }
+
+    // Set streams mode 
+
+    void SetStreams( int enable );
+    int IsStreams() 			{ return IsStreamsMode() != 0;    };
+
+    // Returns bool, but may raise exception
+    int  SetCharset( const char *c );
+
+    // Set API level for backwards compatibility
+    void SetApiLevel( int level );
+
+    void SetClient( const char *c )	{ client.SetClient( c );	}
+    void SetCwd( const char *c );
+    void SetEnviroFile( const char *c );
+    void SetHost( const char *h )	{ client.SetHost( h );		}
+    void SetIgnoreFile( const char *f )	{ client.SetIgnoreFile( f );	}
+    void SetMaxResults( int v )		{ maxResults = v;		}
+    void SetMaxScanRows( int v )	{ maxScanRows = v;		}
+    void SetMaxLockTime( int v )	{ maxLockTime = v;		}
+    VALUE SetEnv( const char *var, const char *val ); 
+    void SetLanguage( const char *l )	{ client.SetLanguage( l );	}
+    void SetPassword( const char *p )	{ client.SetPassword( p );	}
+    void SetPort( const char *p )	{ client.SetPort( p );		}
+    void SetProg( const char *p )	{ prog = p;			}
+    void SetProtocol( const char *var, const char *val );
+    void SetTicketFile( const char *p );
+    void SetUser( const char *u )	{ client.SetUser( u );		}
+    void SetVersion( const char *v )	{ version = v;			}
+
+    int	 GetApiLevel()			{ return apiLevel;		}
+    const StrPtr &GetCharset()		{ return client.GetCharset();	}
+    const StrPtr &GetClient()		{ return client.GetClient();	}
+    const StrPtr &GetConfig()		{ return client.GetConfig();	}
+    const StrPtr &GetCwd()		{ return client.GetCwd();	}
+    const char * GetEnv( const char *v);
+    const StrPtr *GetEnviroFile();
+    const StrPtr &GetHost()		{ return client.GetHost();	}
+    const StrPtr &GetIgnoreFile()	{ return client.GetIgnoreFile();}
+    const StrPtr &GetLanguage()		{ return client.GetLanguage();	}
+    const StrPtr &GetPassword()		{ return client.GetPassword();	}
+    const StrPtr &GetPort()		{ return client.GetPort();	}
+    const StrPtr &GetProg()		{ return prog;			}
+    const StrPtr &GetTicketFile()	{ return ticketFile;		}
+    const StrPtr &GetUser()		{ return client.GetUser();	}
+    const StrPtr &GetVersion()		{ return version;		}
+
+    int		  IsIgnored( const char *path );
+
+    int		  GetMaxResults()	{ return maxResults;		}
+    int		  GetMaxScanRows()	{ return maxScanRows;		}
+    int		  GetMaxLockTime()	{ return maxLockTime;		}
+    int		  GetServerLevel();
+    int		  ServerCaseSensitive();
+    int		  ServerUnicode();
+
+
+    // Session management
+    VALUE Connect();		// P4Exception on error
+    VALUE Connected();		// Return true if connected and not dropped.
+    VALUE Disconnect();
+
+    // Executing commands. 
+    VALUE Run( const char *cmd, int argc, char * const *argv );
+    VALUE SetInput( VALUE input );
+
+    // Result handling
+    VALUE GetErrors()		{ return ui.GetResults().GetErrors();}
+    VALUE GetWarnings()		{ return ui.GetResults().GetWarnings();}
+    VALUE GetMessages()		{ return ui.GetResults().GetMessages();}
+    VALUE GetTrackOutput()	{ return ui.GetResults().GetTrack();}
+
+    // Spec parsing
+    VALUE ParseSpec( const char * type, const char *form );
+    VALUE FormatSpec( const char *type, VALUE hash );
+    VALUE SpecFields( const char * type );
+
+    // Exception levels:
+    //
+    // 		0 - No exceptions raised
+    // 		1 - Exceptions raised for errors
+    // 		2 - Exceptions raised for errors and warnings
+    //
+    void  ExceptionLevel( int i )	{ exceptionLevel = i; 	}
+    int   ExceptionLevel()		{ return exceptionLevel; }
+
+    void  Except( const char *func, Error *e );
+    void  Except( const char *func, const char *msg );
+    void  Except( const char *func, const char *msg, const char *cmd );
+
+    //
+    // Debugging support. Debug levels are:
+    //
+    //     1:	Debugs commands being executed
+    //     2:	Debug UI method calls
+    //     3:	Show garbage collection
+    //
+    int   GetDebug() { return debug; }
+    void  SetDebug( int d );
+
+    // Handler support
+
+    VALUE SetHandler( VALUE handler );
+    VALUE GetHandler() { return ui.GetHandler(); }
+
+    //	Progress API support
+    VALUE SetProgress( VALUE progress );
+    VALUE GetProgress() { return ui.GetProgress(); }
+
+    // Ruby garbage collection
+    void  GCMark();
+
+
+private:
+
+    void RunCmd(const char *cmd, ClientUser *ui, int argc, char * const *argv);
+
+    VALUE ConnectOrReconnect();	// internal connect method
+
+    enum {
+	S_TAGGED 	= 0x0001,
+	S_CONNECTED	= 0x0002,
+	S_CMDRUN	= 0x0004,
+	S_UNICODE	= 0x0008,
+	S_CASEFOLDING	= 0x0010,
+	S_TRACK		= 0x0020,
+	S_STREAMS	= 0x0040,
+
+	S_INITIAL_STATE	= 0x0041,
+	S_RESET_MASK	= 0x001E,
+    };
+
+    void	InitFlags()		{ flags = S_INITIAL_STATE;	}
+    void	ResetFlags()		{ flags &= ~S_RESET_MASK;	}
+
+    void	SetTag()		{ flags |= S_TAGGED;		}
+    void	ClearTag()		{ flags &= ~S_TAGGED;		}
+    int		IsTag()			{ return flags & S_TAGGED;	}
+
+    void	SetConnected()		{ flags |= S_CONNECTED;		}
+    void	ClearConnected() 	{ flags &= ~S_CONNECTED;	}
+    int		IsConnected()		{ return flags & S_CONNECTED;	}
+
+    void	SetCmdRun()		{ flags |= S_CMDRUN;		}
+    void	ClearCmdRun() 		{ flags &= ~S_CMDRUN;		}
+    int		IsCmdRun()		{ return flags & S_CMDRUN;	}
+
+    void	SetUnicode()		{ flags |= S_UNICODE;		}
+    void	ClearUnicode() 		{ flags &= ~S_UNICODE;		}
+    int		IsUnicode()		{ return flags & S_UNICODE;	}
+
+    void	SetCaseFold()		{ flags |= S_CASEFOLDING;	}
+    void	ClearCaseFold()		{ flags &= ~S_CASEFOLDING;	}
+    int		IsCaseFold()		{ return flags & S_CASEFOLDING;	}
+
+    void	SetTrackMode()		{ flags |= S_TRACK;		}
+    void	ClearTrackMode()	{ flags &= ~S_TRACK;		}
+    int		IsTrackMode()		{ return flags & S_TRACK;	}
+
+    void	SetStreamsMode()	{ flags |= S_STREAMS;		}
+    void	ClearStreamsMode()	{ flags &= ~S_STREAMS;		}
+    int		IsStreamsMode()		{ return flags & S_STREAMS;	}
+
+    private:
+    ClientApi		client;
+    ClientUserRuby	ui;
+    Enviro *		enviro;
+    SpecMgr		specMgr;
+    StrBuf		prog;
+    StrBuf		version;
+    StrBuf		ticketFile;
+    int			depth;
+    int			debug;
+    int			exceptionLevel;
+    int			apiLevel;
+    int			server2;
+    int			flags;
+    int			maxResults;
+    int			maxScanRows;
+    int			maxLockTime;
+};
+

data/ext/P4/p4error.cpp

@@ -0,0 +1,122 @@
+/*******************************************************************************
+
+Copyright (c) 2010, 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		: p4error.cc
+ *
+ * Author	: Tony Smith <tony@perforce.com> or <tony@smee.org>
+ *
+ * Description	: Class for bridging Perforce's Error class to Ruby
+ *
+ ******************************************************************************/
+#include <ruby.h>
+#include "undefdups.h"
+#include <p4/clientapi.h>
+#include "p4rubydebug.h"
+#include "p4utils.h"
+#include "p4error.h"
+
+
+static void error_free( P4Error *e )
+{
+    delete e;
+}
+
+static void error_mark( P4Error *e )
+{
+    e->GCMark();
+}
+
+
+P4Error::P4Error( const Error &other )
+{
+    this->debug = 0;
+
+    error = other;
+}
+
+VALUE
+P4Error::GetId()
+{
+    ErrorId *id = error.GetId( 0 );
+    if( !id )
+	return INT2NUM( 0 );
+    return INT2NUM( id->UniqueCode() );
+}
+
+VALUE
+P4Error::GetGeneric()
+{
+    return INT2NUM( error.GetGeneric() );
+}
+
+VALUE
+P4Error::GetSeverity()
+{
+    return INT2NUM( error.GetSeverity() );
+}
+
+VALUE
+P4Error::GetText()
+{
+    StrBuf t;
+    error.Fmt( t, EF_PLAIN );
+    return P4Utils::ruby_string( t.Text(), t.Length() );
+}
+
+VALUE
+P4Error::Inspect()
+{
+    StrBuf a;
+    StrBuf b;
+
+    error.Fmt( a, EF_PLAIN );
+    b << "[";
+    b << "Gen:" << error.GetGeneric();
+    b << "/Sev:" << error.GetSeverity();
+    b << "]: ";
+    b << a;
+    return P4Utils::ruby_string( b.Text(), b.Length() );
+}
+
+VALUE
+P4Error::Wrap( VALUE pClass )
+{
+    VALUE e;
+    VALUE argv[ 1 ];
+
+    e = Data_Wrap_Struct( pClass, error_mark, error_free, this );
+    rb_obj_call_init( e, 0, argv );
+    return e;
+}
+
+void
+P4Error::GCMark()
+{
+    // We don't hold Ruby objects
+}
+

data/ext/P4/p4error.h

@@ -0,0 +1,61 @@
+/*******************************************************************************
+
+Copyright (c) 2010, 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		: p4error.h
+ *
+ * Author	: Tony Smith <tony@perforce.com> or <tony@smee.org>
+ *
+ * Description	: Class for bridging Perforce's Error class to Ruby
+ *
+ ******************************************************************************/
+
+class P4Error
+{
+    public:
+    // Construct by copying another error object
+    P4Error( const Error &other );
+
+    void  SetDebug( int d )	{ debug = d;	}
+
+    VALUE	GetId();
+    VALUE	GetGeneric();
+    VALUE	GetSeverity();
+    VALUE	GetText();
+    VALUE	Inspect();
+
+    // Wrap as Ruby object of class pClass
+    VALUE	Wrap( VALUE pClass );
+
+    // Ruby garbage collection
+    void  GCMark();
+
+    private:
+    Error		error;
+    int			debug;
+};
+

data/ext/P4/p4mapmaker.cpp

@@ -0,0 +1,459 @@
+/*******************************************************************************
+
+Copyright (c) 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		: p4mapmaker.cpp
+ *
+ * Author	: Tony Smith <tony@perforce.com> 
+ *
+ * Description	: Class to encapsulate Perforce map manipulation from Ruby
+ *
+ ******************************************************************************/
+#include <ruby.h>
+#include "undefdups.h"
+#include <p4/clientapi.h>
+#include <p4/mapapi.h>
+#include <p4/debug.h>
+#include "p4rubydebug.h"
+#include "p4utils.h"
+#include "p4mapmaker.h"
+
+
+P4MapMaker::P4MapMaker()
+{
+    map = new MapApi;
+}
+
+P4MapMaker::~P4MapMaker()
+{
+    delete map;
+}
+
+P4MapMaker::P4MapMaker( const P4MapMaker &m )
+{
+    StrBuf	l, r;
+    const StrPtr *s;
+    MapType	t;
+    int 	i;
+
+    map = new MapApi;
+    for( i = 0; i < m.map->Count(); i++ )
+    {
+	s = m.map->GetLeft( i );
+	if( !s ) break;
+	l = *s;
+
+	s = m.map->GetRight( i );
+	if( !s ) break;
+	r = *s;
+
+	t = m.map->GetType( i );
+
+	map->Insert( l, r, t );
+    }
+}
+    
+
+P4MapMaker * 
+P4MapMaker::Join( P4MapMaker *l, P4MapMaker *r)
+{
+    P4MapMaker *m = new P4MapMaker();
+    delete m->map;
+
+    m->map = MapApi::Join( l->map, r->map );
+    return m;
+}
+
+void
+P4MapMaker::Insert( VALUE m )
+{
+    StrBuf	in;
+    StrBuf	lbuf;
+    StrBuf	r;
+    StrRef	l;
+    MapType	t = MapInclude;
+
+    in = StringValuePtr( m );
+    SplitMapping( in, lbuf, r );
+
+    l = lbuf.Text();
+
+    // Look for mapType in lhs only. 
+    if( l[ 0 ] == '-' )
+    {
+	l += 1;
+	t = MapExclude;
+    }
+    else if( l[ 0 ] == '+' )
+    {
+	l += 1;
+	t = MapOverlay;
+    }
+
+    map->Insert( l, r, t );
+}
+
+
+void
+P4MapMaker::Insert( VALUE l, VALUE r )
+{
+    StrBuf	left;
+    StrBuf	right;
+    StrBuf *	dest = &left;
+    int		quoted = 0;
+    int		index = 0;
+
+    const char *p;
+    MapType	t = MapInclude;
+
+    p = StringValuePtr( l );
+    for( ; ; )
+    {
+	for( index = 0; *p; p++ )
+	{
+	    switch( *p )
+	    {
+	    case '"':
+		quoted = !quoted;
+		break;
+
+	    case ' ':
+	    case '\t':
+		// Embedded whitespace ok; leading not.
+		if( quoted || index )
+		{
+		    dest->Extend( *p );
+		    index++;
+		}
+		break;
+
+	    case '-':
+		if( !index )
+		    t = MapExclude;
+		else 
+		    dest->Extend( *p );
+		index++;
+		break;
+		
+	    case '+':
+		if( !index )
+		    t = MapOverlay;
+		else 
+		    dest->Extend( *p );
+		index++;
+		break;
+
+	    default:
+		dest->Extend( *p );
+		index++;
+	    }
+	}
+
+	if( dest == &right )
+	    break;
+
+	dest = &right;
+	p = StringValuePtr( r );
+	quoted = 0;
+    }
+    left.Terminate();
+    right.Terminate();
+
+    map->Insert( left, right, t );
+}
+
+int
+P4MapMaker::Count()
+{
+    return map->Count();
+}
+
+void
+P4MapMaker::Clear()
+{
+    map->Clear();
+}
+
+void
+P4MapMaker::Reverse()
+{
+    MapApi *		nmap = new MapApi;
+    const StrPtr *	l;
+    const StrPtr *	r;
+    MapType		t;
+
+    for( int i = 0; i < map->Count(); i++ )
+    {
+	l = map->GetLeft( i );
+	r = map->GetRight( i );
+	t = map->GetType( i );
+
+	nmap->Insert( *r, *l, t );
+    }
+
+    delete map;
+    map = nmap;
+}
+	
+VALUE
+P4MapMaker::Translate( VALUE p, int fwd )
+{
+    StrBuf	from;
+    StrBuf	to;
+    MapDir	dir = MapLeftRight;
+
+    if( !fwd )
+	dir = MapRightLeft;
+
+    from = StringValuePtr( p );
+    if( map->Translate( from, to, dir ) )
+	return P4Utils::ruby_string( to.Text(), to.Length() );
+    return Qnil;
+}
+
+VALUE
+P4MapMaker::Lhs()
+{
+    VALUE		a = rb_ary_new();
+    StrBuf		s;
+    const StrPtr *	l;
+    MapType		t;
+    int			quote;
+
+    for( int i = 0; i < map->Count(); i++ )
+    {
+	s.Clear();
+	quote = 0;
+
+	l = map->GetLeft( i );
+	t = map->GetType( i );
+
+	if( l->Contains( StrRef( " " ) ) )
+	{
+	    quote++;
+	    s << "\"";
+	}
+
+	switch( t )
+	{
+	case MapInclude:
+	    break;
+	case MapExclude:
+	    s << "-";
+	    break;
+	case MapOverlay:
+	    s << "+";
+	};
+
+	s << l->Text();
+	if( quote ) s << "\"";
+
+	rb_ary_push( a, P4Utils::ruby_string( s.Text(), s.Length() ) );
+    }
+    return a;
+}
+
+VALUE
+P4MapMaker::Rhs()
+{
+    VALUE		a = rb_ary_new();
+    StrBuf		s;
+    const StrPtr *	r;
+    int			quote;
+
+    for( int i = 0; i < map->Count(); i++ )
+    {
+	s.Clear();
+	quote = 0;
+
+	r = map->GetRight( i );
+
+	if( r->Contains( StrRef( " " ) ) )
+	{
+	    quote++;
+	    s << "\"";
+	}
+
+	s << r->Text();
+	if( quote ) s << "\"";
+
+	rb_ary_push( a, P4Utils::ruby_string( s.Text(), s.Length() ) );
+    }
+    return a;
+}
+
+VALUE
+P4MapMaker::ToA()
+{
+    VALUE		a = rb_ary_new();
+    StrBuf		s;
+    const StrPtr *	l;
+    const StrPtr *	r;
+    MapType		t;
+    int			quote;
+
+    for( int i = 0; i < map->Count(); i++ )
+    {
+	s.Clear();
+	quote = 0;
+
+	l = map->GetLeft( i );
+	r = map->GetRight( i );
+	t = map->GetType( i );
+
+	if( l->Contains( StrRef( " " ) ) ||
+	    r->Contains( StrRef( " " ) ) )
+	{
+	    quote++;
+	    s << "\"";
+	}
+
+	switch( t )
+	{
+	case MapInclude:
+	    break;
+	case MapExclude:
+	    s << "-";
+	    break;
+	case MapOverlay:
+	    s << "+";
+	};
+
+	s << l->Text();
+
+	if( quote ) s << "\" \"";
+	else s << " ";
+
+	s << r->Text();
+	if( quote ) s << "\"";
+
+	rb_ary_push( a, P4Utils::ruby_string( s.Text(), s.Length() ) );
+    }
+    return a;
+}
+
+void
+P4MapMaker::Inspect( StrBuf &b )
+{
+    if( !map->Count() )
+    {
+	b << "(empty)";
+	return;
+    }
+
+    const StrPtr *l, *r;
+    int	  t;
+
+    b << "\n";
+
+    for( int i = 0; i < map->Count(); i++ )
+    {
+
+	l = map->GetLeft( i );
+	r = map->GetRight( i );
+	t = map->GetType( i );
+
+	b << "\t";
+	switch( t )
+	{
+	case MapExclude:
+	    b << "-";
+	    break;
+
+	case MapOverlay:
+	    b << "+";
+	    break;
+
+	case MapInclude:
+	    break;
+	}
+
+	b << l->Text();
+	b << " ";
+	b << r->Text();
+	b << "\n";
+    }
+}
+
+//
+// Take a single string containing either a half-map, or both halves of
+// a mapping and split it in two. If there's only one half of a mapping in
+// the input, then l, and r are set to the same value as 'in'. If 'in'
+// contains two halves, then they are split.
+//
+void
+P4MapMaker::SplitMapping( const StrPtr &in, StrBuf &l, StrBuf &r )
+{
+    char *	pos;
+    int		quoted = 0;
+    int		split = 0;
+    StrBuf *	dest = &l;
+
+    pos = in.Text();
+
+    l.Clear();
+    r.Clear();
+
+    while( *pos )
+    {
+	switch( *pos )
+	{
+	case '"':
+	    quoted = !quoted;
+	    break;
+
+	case ' ':
+	    if( !quoted && !split )
+	    {
+		// whitespace in the middle. skip it, and start updating
+		// the destination
+		split = 1;
+		dest->Terminate();
+		dest = &r;
+	    }
+	    else if( !quoted )
+	    {
+		// Trailing space on rhs. ignore
+	    }
+	    else
+	    {
+		// Embedded space
+		dest->Extend( *pos );
+	    }
+	    break;
+
+	default:
+	    dest->Extend( *pos );
+	}
+	pos++;
+    }
+    l.Terminate();
+    r.Terminate();
+
+    if( !r.Length() )
+	r = l;
+}