p4ruby 2020.1.2056123 → 2021.1.2265066

data/ext/P4/clientuserruby.cpp

@@ -38,6 +38,7 @@
 #include <ruby.h>
 #include "undefdups.h"
 #include <p4/clientapi.h>
+#include <p4/strtable.h>
 #include <p4/clientprog.h>
 #include <p4/spec.h>
 #include <p4/diff.h>
@@ -65,6 +66,19 @@ static const int CANCEL = 2;
  * server, and converts the data to Ruby form for returning to the caller.
  ******************************************************************************/
 
+class SSOShim : public ClientSSO {
+public:
+	SSOShim(ClientUserRuby *ui) : ui(ui) {}
+	virtual ClientSSOStatus	Authorize( StrDict &vars,
+				           int maxLength,
+				           StrBuf &result )
+	{
+		return ui->Authorize(vars, maxLength, result);
+	}
+private:
+	ClientUserRuby *ui;
+} ;
+
 ClientUserRuby::ClientUserRuby(SpecMgr *s) {
 	specMgr = s;
 	debug = 0;
@@ -77,14 +91,22 @@ ClientUserRuby::ClientUserRuby(SpecMgr *s) {
 	rubyExcept = 0;
 	alive = 1;
 	track = false;
+    	SetSSOHandler( new SSOShim( this ) );
+
+	ssoEnabled = 0;
+	ssoResultSet = 0;
+	ssoResult = Qnil;
+	ssoHandler = Qnil;
 
 	ID idP4 = rb_intern("P4");
 	ID idP4OH = rb_intern("OutputHandler");
 	ID idP4Progress = rb_intern("Progress");
+	ID idP4SSO = rb_intern("SSOHandler");
 
 	VALUE cP4 = rb_const_get_at(rb_cObject, idP4);
 	cOutputHandler = rb_const_get_at(cP4, idP4OH);
 	cProgress = rb_const_get_at(cP4, idP4Progress );
+	cSSOHandler = rb_const_get_at(cP4, idP4SSO);
 }
 
 void ClientUserRuby::Reset() {
@@ -719,8 +741,239 @@ void ClientUserRuby::GCMark() {
 	if (mergeResult != Qnil) rb_gc_mark( mergeResult);
 	if (handler != Qnil) rb_gc_mark( handler);
 	if (progress != Qnil) rb_gc_mark( progress );
-	rb_gc_mark( cOutputHandler);
+	if (ssoResult != Qnil) rb_gc_mark( ssoResult );
+	if (ssoHandler != Qnil) rb_gc_mark( ssoHandler );
+	rb_gc_mark( cOutputHandler );
 	rb_gc_mark( cProgress );
+	rb_gc_mark( cSSOHandler );
 
 	results.GCMark();
 }
+
+
+/*
+ * Set the Handler object. Double-check that it is either nil or
+ * an instance of OutputHandler to avoid future problems
+ */
+
+VALUE
+ClientUserRuby::SetRubySSOHandler(VALUE h) {
+	if (P4RDB_CALLS) fprintf(stderr, "[P4] SetSSOHandler()\n");
+
+	if (Qnil != h && Qfalse == rb_obj_is_kind_of(h, cSSOHandler)) {
+		rb_raise(eP4, "Handler needs to be an instance of P4::SSOHandler");
+		return Qfalse;
+	}
+
+	ssoHandler = h;
+	alive = 1; // ensure that we don't drop out after the next call
+
+	return Qtrue;
+}
+
+
+// returns true if output should be reported
+// false if the output is handled and should be ignored
+static VALUE CallMethodSSO(VALUE data) {
+	VALUE *args = reinterpret_cast<VALUE *>(data);
+	return rb_funcall(args[0], (ID) rb_intern("authorize"), 2, args[1], args[2]);
+}
+
+ClientSSOStatus
+ClientUserRuby::CallSSOMethod(VALUE vars, int maxLength, StrBuf &result) {
+	ClientSSOStatus answer = CSS_SKIP;
+	int excepted = 0;
+	result.Clear();
+
+	if (P4RDB_COMMANDS) fprintf(stderr, "[P4] CallSSOMethod\n");
+
+	// some wild hacks to satisfy the rb_protect method
+
+	VALUE args[3] = { ssoHandler, vars, INT2NUM( maxLength ) };
+
+	VALUE res = rb_protect(CallMethodSSO, (VALUE) args, &excepted);
+
+	if (excepted) { // exception thrown
+		alive = 0;
+		rb_jump_tag(excepted);
+	} else if( FIXNUM_P( res ) ) {
+		int a = NUM2INT(res);
+		if (P4RDB_COMMANDS)
+			fprintf(stderr, "[P4] CallSSOMethod returned %d\n", a);
+
+		if( a < CSS_PASS || a > CSS_SKIP )
+			rb_raise(eP4, "P4::SSOHandler::authorize returned out of range response");
+		answer = (ClientSSOStatus) a;
+	} else if( Qtrue == rb_obj_is_kind_of(res, rb_cArray) ) {
+		VALUE resval1 = rb_ary_shift(res);
+		Check_Type( resval1, T_FIXNUM );
+		int a = NUM2INT(resval1);
+		if( a < CSS_PASS || a > CSS_SKIP )
+			rb_raise(eP4, "P4::SSOHandler::authorize returned out of range response");
+		answer = (ClientSSOStatus) a;
+
+		VALUE resval2 = rb_ary_shift(res);
+		if( resval2 != Qnil )
+		{
+			Check_Type( resval2, T_STRING );
+			result.Set(StringValuePtr(resval2));
+			if (P4RDB_COMMANDS)
+				fprintf(stderr, "[P4] CallSSOMethod returned %d, %s\n", a, result.Text());
+		}
+
+	} else {
+		Check_Type( res, T_STRING );
+		answer = CSS_PASS;
+
+		result.Set(StringValuePtr(res));
+		if (P4RDB_COMMANDS)
+			fprintf(stderr, "[P4] CallSSOMethod returned %s\n", result.Text());
+
+	}
+
+	return answer;
+}
+
+ClientSSOStatus
+ClientUserRuby::Authorize( StrDict &vars, int maxLength, StrBuf &strbuf )
+{
+	ssoVars.Clear();
+
+	if( ssoHandler != Qnil )
+	{
+		ClientSSOStatus res = CallSSOMethod( specMgr->StrDictToHash(&vars), maxLength, strbuf );
+		if( res != CSS_SKIP )
+			return res;
+		if (P4RDB_COMMANDS)
+			fprintf(stderr, "[P4] Authorize skipped result from SSO Handler\n" );
+	}
+
+	if( !ssoEnabled )
+		return CSS_SKIP;
+
+	if( ssoEnabled < 0 )
+		return CSS_UNSET;
+
+	if( ssoResultSet )
+	{
+		strbuf.Clear();
+			VALUE resval = ssoResult;
+
+		//if( P4RDB_CALLS )
+		//    std::cerr << "[P4] ClientSSO::Authorize(). Using supplied input"
+		//              << std::endl;
+
+		if (Qtrue == rb_obj_is_kind_of(ssoResult, rb_cArray)) {
+			resval = rb_ary_shift(ssoResult);
+		}
+	
+		if( resval != Qnil ) {
+			// Convert whatever's left into a string
+			ID to_s = rb_intern("to_s");
+			VALUE str = rb_funcall(resval, to_s, 0);
+			strbuf.Set(StringValuePtr(str));
+		}
+
+		return ssoResultSet == 2 ? CSS_FAIL
+				: CSS_PASS;
+	}
+
+	ssoVars.CopyVars( vars );
+	return CSS_EXIT;
+}
+
+VALUE
+ClientUserRuby::EnableSSO( VALUE e )
+{
+	if( e == Qnil )
+	{
+		ssoEnabled = 0;
+		return Qtrue;
+	}
+
+	if( e == Qtrue )
+	{
+		ssoEnabled = 1;
+		return Qtrue;
+	}
+
+	if( e == Qfalse )
+	{
+		ssoEnabled = -1;
+		return Qtrue;
+	}
+
+	return Qfalse;
+}
+
+VALUE
+ClientUserRuby::SSOEnabled()
+{
+	if( ssoEnabled == 1 )
+	{
+		return Qtrue;
+	}
+	else if( ssoEnabled == -1 )
+	{
+		return Qfalse;
+	}
+	else
+	{
+		return Qnil;
+	}
+}
+
+VALUE
+ClientUserRuby::SetSSOPassResult( VALUE i )
+{
+	ssoResultSet = 1;
+	return SetSSOResult( i );
+}
+
+VALUE
+ClientUserRuby::GetSSOPassResult()
+{
+	if( ssoResultSet == 1 )
+	{
+		return ssoResult;
+	}
+	else
+	{
+		return Qnil;
+	}
+}
+
+VALUE
+ClientUserRuby::SetSSOFailResult( VALUE i )
+{
+	ssoResultSet = 2;
+	return SetSSOResult( i );
+}
+
+VALUE
+ClientUserRuby::GetSSOFailResult()
+{
+	if( ssoResultSet == 2 )
+	{
+		return ssoResult;
+	}
+	else
+	{
+		return Qnil;
+	}
+}
+
+VALUE
+ClientUserRuby::SetSSOResult( VALUE i )
+{
+	if (P4RDB_CALLS) fprintf(stderr, "[P4] P4ClientSSO::SetResult()\n");
+ 
+	ssoResult = i;
+	return Qtrue;
+}
+
+VALUE
+ClientUserRuby::GetSSOVars()
+{
+    	return specMgr->StrDictToHash( &ssoVars );
+}

data/ext/P4/clientuserruby.h

@@ -42,7 +42,7 @@
 class SpecMgr;
 class ClientProgress;
 
-class ClientUserRuby: public ClientUser, public KeepAlive {
+class ClientUserRuby: public ClientUser, public ClientSSO, public KeepAlive {
 public:
 	ClientUserRuby(SpecMgr *s);
 
@@ -101,6 +101,21 @@ public:
 		return progress;
 	}
 
+	// SSO handler support
+
+	virtual ClientSSOStatus Authorize( StrDict &vars, int maxLength, StrBuf &result );
+	VALUE EnableSSO( VALUE e );
+	VALUE SSOEnabled();
+	VALUE SetSSOPassResult( VALUE i );
+	VALUE GetSSOPassResult();
+	VALUE SetSSOFailResult( VALUE i );
+	VALUE GetSSOFailResult();
+	VALUE GetSSOVars();
+	VALUE SetRubySSOHandler( VALUE handler );
+	VALUE GetRubySSOHandler() {
+		return ssoHandler;
+	}
+
 	// override from KeepAlive
 	virtual int IsAlive() {
 		return alive;
@@ -112,6 +127,8 @@ private:
 	void ProcessOutput(const char * method, VALUE data);
 	void ProcessMessage(Error * e);
 	bool CallOutputMethod(const char * method, VALUE data);
+	VALUE SetSSOResult( VALUE i );
+	ClientSSOStatus CallSSOMethod(VALUE vars, int maxLength, StrBuf &result);
 
 private:
 	StrBuf cmd;
@@ -124,10 +141,18 @@ private:
 	VALUE cOutputHandler;
 	VALUE progress;
 	VALUE cProgress;
+	VALUE cSSOHandler;
 	int debug;
 	int apiLevel;
 	int alive;
 	int rubyExcept;
 	bool track;
+	
+	// SSO handler support
+	int         ssoEnabled;
+	int         ssoResultSet;
+	StrBufDict  ssoVars;
+	VALUE       ssoResult;
+	VALUE 	    ssoHandler;
 };
 

data/ext/P4/extconf.rb

@@ -425,6 +425,8 @@ def p4_cpu(os)
     when :darwin, :linux
       if cpu =~ /i686/
         'x86'
+      elsif cpu =~ /universal/
+        'x86_64'
       else
         cpu
       end
@@ -442,23 +444,19 @@ end
 # directory name where we can download files from.
 def p4_platform_label
   case RbConfig::CONFIG["target_os"].downcase
-    when /nt|mswin|mingw/
+    when /nt|mswin|mingw|cygwin|msys/
       # Ruby on windows is only MinGW via Rubyinstaller.org, though this may
       # not work on all rubies.
-      if RbConfig::CONFIG['MAJOR'].to_i >= 2
-        # Note that x64 or x86 needs to be suffixed to this
-        'mingw64'
-      else
-        'mingwx86'
-      end
-    when /darwin/
+      # There are too many permutations of Windows p4api, to automate.
+      raise 'Automatic fetching of p4api from perforce FTP is not supported on Windows'
+    when /darwin19|darwin[2-9][0-9]/
+      "macosx1015#{p4_cpu(:darwin)}"
+    when /darwin/      
       "darwin90#{p4_cpu(:darwin)}"
     when /solaris/
       "solaris10#{p4_cpu(:solaris)}"
     when /linux/
-      "linux26#{p4_cpu(:linux)}"
-    when /cygwin/
-      raise 'cygwin is not supported for the --download-p4api option'
+      "linux26#{p4_cpu(:linux)}"    
   end
 end
 
@@ -484,6 +482,8 @@ def filename
                 filename = 'p4api-openssl1.0.2.zip'
              end
     end
+  elsif RbConfig::CONFIG['target_os'].downcase =~ /darwin19|darwin[2-9][0-9]/
+    filename = 'p4api-openssl1.1.1.tgz'
   else
     filename = 'p4api.tgz'
     if !openssl_number.to_s.empty?

data/ext/P4/p4.cpp

@@ -314,6 +314,25 @@ static VALUE p4_set_enviro_file( VALUE self, VALUE rbstr )
     return Qtrue;
 }
 
+static VALUE p4_get_evar( VALUE self, VALUE var )
+{
+    P4ClientApi	*p4;
+    const StrPtr *val;
+    Data_Get_Struct( self, P4ClientApi, p4 );
+    val = p4->GetEVar( StringValuePtr( var ) );
+    if( !val ) return Qnil;
+
+    return P4Utils::ruby_string( val->Text() );
+}
+
+static VALUE p4_set_evar( VALUE self, VALUE var, VALUE val )
+{
+    P4ClientApi *p4;
+    Data_Get_Struct( self, P4ClientApi, p4 );
+    p4->SetEVar( StringValuePtr( var ), StringValuePtr( val ) );
+    return Qtrue;
+}
+
 static VALUE p4_get_host( VALUE self )
 {
     P4ClientApi	*p4;
@@ -642,7 +661,7 @@ static VALUE p4_run( VALUE self, VALUE args )
 
     // Allocate storage on the stack so it's automatically reclaimed
     // when we exit.
-    char **p4args = ALLOCA_N( char *, argc + 1 );
+    char **p4args = RB_ALLOC_N( char *, argc + 1 );
 
     // Copy the args across
     for ( i = 0; i < argc; i++ )
@@ -808,6 +827,72 @@ static VALUE p4_set_progress( VALUE self, VALUE progress )
     return p4->SetProgress( progress );
 }
 
+/*******************************************************************************
+ * SSO handler support
+ ******************************************************************************/
+static VALUE p4_get_enabled_sso( VALUE self )
+{
+    P4ClientApi	*p4;
+    Data_Get_Struct( self, P4ClientApi, p4 );
+    return p4->GetEnableSSO();
+}
+
+static VALUE p4_set_enable_sso( VALUE self, VALUE enable )
+{
+    P4ClientApi	*p4;
+    Data_Get_Struct( self, P4ClientApi, p4 );
+    return p4->SetEnableSSO( enable );
+}
+
+static VALUE p4_get_sso_vars( VALUE self )
+{
+    P4ClientApi	*p4;
+    Data_Get_Struct( self, P4ClientApi, p4 );
+    return p4->GetSSOVars();
+}
+
+static VALUE p4_get_sso_passresult( VALUE self )
+{
+    P4ClientApi	*p4;
+    Data_Get_Struct( self, P4ClientApi, p4 );
+    return p4->GetSSOPassResult();
+}
+
+static VALUE p4_set_sso_passresult( VALUE self, VALUE result )
+{
+    P4ClientApi	*p4;
+    Data_Get_Struct( self, P4ClientApi, p4 );
+    return p4->SetSSOPassResult( result );
+}
+
+static VALUE p4_get_sso_failresult( VALUE self )
+{
+    P4ClientApi	*p4;
+    Data_Get_Struct( self, P4ClientApi, p4 );
+    return p4->GetSSOFailResult();
+}
+
+static VALUE p4_set_sso_failresult( VALUE self, VALUE result )
+{
+    P4ClientApi	*p4;
+    Data_Get_Struct( self, P4ClientApi, p4 );
+    return p4->SetSSOFailResult( result );
+}
+static VALUE p4_get_ssohandler( VALUE self )
+{
+    P4ClientApi	*p4;
+    Data_Get_Struct( self, P4ClientApi, p4 );
+    return p4->GetSSOHandler();
+}
+
+static VALUE p4_set_ssohandler( VALUE self, VALUE handler )
+{
+    P4ClientApi	*p4;
+    Data_Get_Struct( self, P4ClientApi, p4 );
+    p4->SetSSOHandler( handler );
+    return Qtrue;
+}
+
 /*******************************************************************************
  * P4::MergeData methods. Construction/destruction defined elsewhere
  ******************************************************************************/
@@ -1262,6 +1347,8 @@ void	Init_P4()
     rb_define_method( cP4, "set_env", 	RUBY_METHOD_FUNC(p4_set_env)     , 2 );
     rb_define_method( cP4, "enviro_file", RUBY_METHOD_FUNC(p4_get_enviro_file), 0);
     rb_define_method( cP4, "enviro_file=", RUBY_METHOD_FUNC(p4_set_enviro_file), 1);
+    rb_define_method( cP4, "evar", 	RUBY_METHOD_FUNC(p4_get_evar)     , 1 );
+    rb_define_method( cP4, "set_evar", 	RUBY_METHOD_FUNC(p4_set_evar)     , 2 );
     rb_define_method( cP4, "host", 	RUBY_METHOD_FUNC(p4_get_host)    , 0 );
     rb_define_method( cP4, "host=", 	RUBY_METHOD_FUNC(p4_set_host)    , 1 );
     rb_define_method( cP4, "ignore_file",RUBY_METHOD_FUNC(p4_get_ignore) , 0 );
@@ -1335,6 +1422,18 @@ void	Init_P4()
     rb_define_method( cP4, "progress", RUBY_METHOD_FUNC(p4_get_progress), 0);
     rb_define_method( cP4, "progress=", RUBY_METHOD_FUNC(p4_set_progress), 1);
 
+    // SSO handling
+    rb_define_method( cP4, "loginsso", RUBY_METHOD_FUNC(p4_get_enabled_sso), 0);
+    rb_define_method( cP4, "loginsso=", RUBY_METHOD_FUNC(p4_set_enable_sso), 1);
+    rb_define_method( cP4, "ssovars", RUBY_METHOD_FUNC(p4_get_sso_vars), 0);
+    rb_define_method( cP4, "ssopassresult", RUBY_METHOD_FUNC(p4_get_sso_passresult), 0);
+    rb_define_method( cP4, "ssopassresult=", RUBY_METHOD_FUNC(p4_set_sso_passresult), 1);
+    rb_define_method( cP4, "ssofailresult", RUBY_METHOD_FUNC(p4_get_sso_failresult), 0);
+    rb_define_method( cP4, "ssofailresult=", RUBY_METHOD_FUNC(p4_set_sso_failresult), 1);
+    rb_define_method( cP4, "ssohandler", RUBY_METHOD_FUNC(p4_get_ssohandler), 0);
+    rb_define_method( cP4, "ssohandler=", RUBY_METHOD_FUNC(p4_set_ssohandler), 1);
+
+
     // P4::MergeData class
     cP4MD = rb_define_class_under( cP4, "MergeData", rb_cObject );
 

data/ext/P4/p4clientapi.cpp

@@ -37,6 +37,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <ruby.h>
 #include "undefdups.h"
 #include <p4/clientapi.h>
+#include <p4/strtable.h>
 #include <p4/i18napi.h>
 #include <p4/enviro.h>
 #include <p4/hostenv.h>
@@ -142,6 +143,21 @@ P4ClientApi::GetEnviroFile()
     return enviro->GetEnviroFile();
 }
 
+void
+P4ClientApi::SetEVar( const char *var, const char *val )
+{
+    StrRef sVar( var );
+    StrRef sVal( val );
+    client.SetEVar( sVar, sVal );
+}
+
+const StrPtr *
+P4ClientApi::GetEVar( const char *var )
+{
+    StrRef sVar( var );
+    return client.GetEVar( sVar );
+}
+
 void
 P4ClientApi::SetApiLevel( int level )
 {
@@ -699,6 +715,17 @@ P4ClientApi::SetProgress( VALUE progress ) {
     return ui.SetProgress( progress );
 }
 
+VALUE
+P4ClientApi::SetSSOHandler( VALUE h )
+{
+    if ( P4RDB_COMMANDS )
+        fprintf( stderr, "[P4] Received SSO handler object\n" );
+
+    ui.SetRubySSOHandler( h );
+
+    return Qtrue;
+}
+
 
 void
 P4ClientApi::GCMark()
@@ -760,3 +787,49 @@ P4ClientApi::Except( const char *func, Error *e )
     e->Fmt( &m );
     Except( func, m.Text() );
 }
+
+//
+// SSO Handlers
+//
+
+VALUE
+P4ClientApi::SetEnableSSO( VALUE e )
+{
+    return ui.EnableSSO( e );
+}
+
+VALUE
+P4ClientApi::GetEnableSSO()
+{
+    return ui.SSOEnabled();
+}
+
+VALUE
+P4ClientApi::GetSSOVars()
+{
+    return ui.GetSSOVars();
+}
+
+VALUE
+P4ClientApi::SetSSOPassResult( VALUE r )
+{
+    return ui.SetSSOPassResult( r );
+}
+
+VALUE
+P4ClientApi::GetSSOPassResult()
+{
+    return ui.GetSSOPassResult();
+}
+
+VALUE
+P4ClientApi::SetSSOFailResult( VALUE r )
+{
+   return ui.SetSSOFailResult( r );
+}
+
+VALUE
+P4ClientApi::GetSSOFailResult()
+{
+    return ui.GetSSOFailResult();
+}

data/ext/P4/p4clientapi.h

@@ -73,6 +73,7 @@ public:
     void SetClient( const char *c )	{ client.SetClient( c );	}
     void SetCwd( const char *c );
     void SetEnviroFile( const char *c );
+    void SetEVar( const char *var, const char *val );
     void SetHost( const char *h )	{ client.SetHost( h );		}
     void SetIgnoreFile( const char *f )	{ client.SetIgnoreFile( f );	}
     void SetMaxResults( int v )		{ maxResults = v;		}
@@ -96,6 +97,7 @@ public:
     const StrPtr &GetCwd()		{ return client.GetCwd();	}
     const char * GetEnv( const char *v);
     const StrPtr *GetEnviroFile();
+    const StrPtr *GetEVar(const char *v);
     const StrPtr &GetHost()		{ return client.GetHost();	}
     const StrPtr &GetIgnoreFile()	{ return client.GetIgnoreFile();}
     const StrPtr &GetLanguage()		{ return client.GetLanguage();	}
@@ -169,6 +171,17 @@ public:
     VALUE SetProgress( VALUE progress );
     VALUE GetProgress() { return ui.GetProgress(); }
 
+    // SSO handler
+    VALUE SetEnableSSO( VALUE e );
+    VALUE GetEnableSSO();
+    VALUE GetSSOVars();
+    VALUE SetSSOPassResult( VALUE r );
+    VALUE GetSSOPassResult();
+    VALUE SetSSOFailResult( VALUE r );
+    VALUE GetSSOFailResult();
+    VALUE SetSSOHandler( VALUE handler );
+    VALUE GetSSOHandler() { return ui.GetRubySSOHandler(); }
+
     // Ruby garbage collection
     void  GCMark();
 

data/ext/P4/p4specdata.cpp

@@ -106,3 +106,32 @@ SpecDataRuby::SetLine( SpecElem *sd, int x, const StrPtr *v, Error *e )
 	}
 	return;
 }
+
+void
+SpecDataRuby::Comment ( SpecElem *sd, int x, const char **wv,  int nl, Error *e )
+{
+	VALUE 	key;
+	VALUE	val;
+	VALUE	ary;
+	StrBuf	t;
+
+	key = P4Utils::ruby_string( sd->tag.Text(), sd->tag.Length() );
+	val = P4Utils::ruby_string( *wv );
+
+	if( sd->IsList() )
+	{
+
+	    ary = rb_hash_aref( hash, key ); // rb_hash_aref  - get the value for hash key
+	    if( ary == Qnil )
+	    {
+		ary = rb_ary_new();
+		rb_hash_aset( hash, key, ary ); // rb_hash_aset(hash, key, value) - set the hash key to value
+	    }
+	    rb_ary_store( ary, x, val );
+	}
+	else
+	{ 
+	    rb_hash_aset( hash, key, val );
+	}
+	return;
+}

data/ext/P4/p4specdata.h

@@ -44,6 +44,8 @@ class SpecDataRuby : public SpecData
 	virtual StrPtr *GetLine( SpecElem *sd, int x, const char **cmt );
 	virtual void	SetLine( SpecElem *sd, int x, const StrPtr *val,
 				Error *e );
+	virtual void	Comment( SpecElem *sd, int x, const char **wv,
+	            int nl, Error *e );
 
     private:
 	VALUE	hash;