pg 0.7.9.2008.02.05 → 0.7.9.2008.03.18

data/BSD

@@ -0,0 +1,23 @@
+PostgreSQL Database Management System
+(formerly known as Postgres, then as Postgres95)
+
+Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
+
+Portions Copyright (c) 1994, The Regents of the University of California
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose, without fee, and without a written agreement
+is hereby granted, provided that the above copyright notice and this
+paragraph and the following two paragraphs appear in all copies.
+
+IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
+DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING
+LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
+DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
+ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATIONS TO
+PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

data/README

@@ -22,9 +22,13 @@ Maintainer:
   Jeff Davis <ruby-pg@j-davis.com>
 
 Copying:
-  You may redistribute this software under the terms of the GPL,
-  included in the file named GPL; or under the same terms as Ruby,
-  included in the file name LICENSE.
+  You may redistribute this software under the terms of the Ruby license,
+  included in the file "LICENSE". The Ruby license also allows distribution
+  under the terms of the GPL, included in the file "COPYING.txt" and the
+  file "GPL".
+
+  Portions of the code are from the PostgreSQL project, and are distributed
+  under the terms of the BSD license, included in the file "BSD".
 
 - Summary
 
@@ -34,7 +38,7 @@ This library works with PostgreSQL 7.4 and later.
 - Requirements
 
   Ruby 1.8 or later.
-  PostgreSQL 7.4 or later installed.
+  PostgreSQL 7.3 or later installed.
 
   It may work with earlier versions as well, but those are
   not regularly tested.
@@ -75,8 +79,7 @@ For example:
 - How to use ?
 
 This gem builds and installs two PostgreSQL database adapters, 'postgres'
-and 'pg'. 'postgres' is currently (Jan 2008) the recommended PostgreSQL
-adapter for use with Rails.
+and 'pg'. 
 
 The standard way to download and install the most current stable  
 version of the postgres gem (from http://gems.rubyforge.org) is to use  
@@ -98,14 +101,11 @@ on Mac OS X with PostgreSQL in /Library/PostgreSQL8 use
 --with-pgsql-include-dir=/Library/PostgreSQL8/include --with-pgsql-lib- 
 dir=/Library/PostgreSQL8/lib
 
-To use the postgres adapter with Rails:
+To use the module with Rails:
 refer to it as
 adapter: postgresql
 in your database:yaml file
 
-The pg adapter cannot be used with Rails yet and is available for  
-testing and developer use.
-
 To use these modules in Ruby directly (not Rails), refer to the RDoc
 documentation.
 

data/ext/compat.c

@@ -209,6 +209,18 @@ PQfformat(const PGresult *res, int column_number)
 {
 	rb_raise(rb_eStandardError, "PQfformat not supported by this client version.");
 }
+
+PQnoticeReceiver 
+PQsetNoticeReceiver(PGconn *conn, PQnoticeReceiver proc, void *arg)
+{
+	rb_raise(rb_eStandardError, "PQsetNoticeReceiver not supported by this client version.");
+}
+
+char *
+PQresultErrorField(const PGresult *res, int fieldcode)
+{
+	rb_raise(rb_eStandardError, "PQresultErrorField not supported by this client version.");
+}
 #endif /* PG_BEFORE_070400 */
 
 #ifdef PG_BEFORE_070300

data/ext/compat.h

@@ -118,6 +118,8 @@ int PQserverVersion(const PGconn* conn);
  */
 #define CONNECTION_SSL_STARTUP 1000000
 
+typedef void (*PQnoticeReceiver) (void *arg, const PGresult *res);
+
 typedef enum
 {
 	PQERRORS_TERSE,		/* single-line error messages */
@@ -156,6 +158,8 @@ PGVerbosity PQsetErrorVerbosity(PGconn *conn, PGVerbosity verbosity);
 Oid PQftable(const PGresult *res, int column_number);
 int PQftablecol(const PGresult *res, int column_number);
 int PQfformat(const PGresult *res, int column_number);
+char *PQresultErrorField(const PGresult *res, int fieldcode);
+PQnoticeReceiver PQsetNoticeReceiver(PGconn *conn, PQnoticeReceiver proc, void *arg);
 
 #else
 #define PGNOTIFY_EXTRA(notify) ((notify)->extra)

data/ext/extconf.rb

@@ -1,14 +1,25 @@
 require 'mkmf'
 
+unless system("pg_config --bindir > /dev/null")
+	$stderr.write("ERROR: can't find pg_config.\n")
+	$stderr.write("HINT: Make sure pg_config is in your PATH\n")
+	exit 1
+end
+
 # OS X compatibility
-if(PLATFORM =~ /darwin/) then
+if(RUBY_PLATFORM =~ /darwin/) then
 	# test if postgresql is probably universal
 	bindir = (IO.popen("pg_config --bindir").readline.chomp rescue nil)
 	filetype = (IO.popen("file #{bindir}/pg_config").
 		readline.chomp rescue nil)
 	# if it's not universal, ARCHFLAGS should be set
 	if((filetype !~ /universal binary/) && ENV['ARCHFLAGS'].nil?) then
-		arch = (IO.popen("uname -m").readline.chomp rescue nil)
+		arch_tmp = (IO.popen("uname -p").readline.chomp rescue nil)
+		if(arch_tmp == 'powerpc') 
+			arch = 'ppc'
+		else
+			arch = 'i386'
+		end
 		$stderr.write %{
 		===========   WARNING   ===========
 		
@@ -32,13 +43,6 @@ if(PLATFORM =~ /darwin/) then
 	end
 end
 
-# windows compatibility, need different library name
-if(PLATFORM =~ /mingw|mswin/) then
-	$libname = '/ms/libpq'
-else
-	$libname = 'pq'
-end
-
 if RUBY_VERSION < '1.8'
 	puts 'This library is for ruby-1.8 or higher.'
 	exit 1
@@ -53,10 +57,11 @@ def pg_config(type)
 end
 
 def have_build_env
-	have_library($libname) && have_header('libpq-fe.h') && have_header('libpq/libpq-fs.h')
+	(have_library('pq') || have_library('libpq') || have_library('ms/libpq')) &&
+   have_header('libpq-fe.h') && have_header('libpq/libpq-fs.h')
 end
 
-dir_config('pgsql', config_value('include'), config_value('lib'))
+dir_config('pg', config_value('include'), config_value('lib'))
 
 desired_functions = %w(
 	PQconnectionUsedPassword

data/ext/pg.c

@@ -9,7 +9,7 @@
   modified at: Wed Jan 20 16:41:51 1999
 
   $Author: jdavis $
-  $Date: 2008-02-05 11:23:59 -0800 (Tue, 05 Feb 2008) $
+  $Date: 2008-03-18 09:44:07 -0700 (Tue, 18 Mar 2008) $
 ************************************************/
 
 #include "pg.h"
@@ -52,6 +52,9 @@ static VALUE pgconn_finish(VALUE self);
 static VALUE pgresult_clear(VALUE self);
 static VALUE pgresult_aref(VALUE self, VALUE index);
 
+static PQnoticeReceiver default_notice_receiver = NULL;
+static PQnoticeProcessor default_notice_processor = NULL;
+
 /*
  * Used to quote the values passed in a Hash to PGconn.init
  * when building the connection string.
@@ -108,13 +111,15 @@ value_as_cstring(VALUE in_str)
 static void
 free_pgconn(PGconn *conn)
 {
-    PQfinish(conn);
+	if(conn != NULL)
+		PQfinish(conn);
 }
 
 static void
 free_pgresult(PGresult *result)
 {
-    PQclear(result);
+	if(result != NULL)
+		PQclear(result);
 }
 
 static PGconn*
@@ -187,6 +192,45 @@ static VALUE yield_pgresult(VALUE rb_pgresult)
 	return Qnil;
 }
 
+static void
+notice_receiver_proxy(void *arg, const PGresult *result)
+{
+	VALUE proc;
+	VALUE self = (VALUE)arg;
+
+	if ((proc = rb_iv_get(self, "@notice_receiver")) != Qnil) {
+		rb_funcall(proc, rb_intern("call"), 1, 
+			Data_Wrap_Struct(rb_cPGresult, NULL, NULL, (PGresult*)result));
+	}
+	return;
+}
+
+static void
+notice_processor_proxy(void *arg, const char *message)
+{
+	VALUE proc;
+	VALUE self = (VALUE)arg;
+
+	if ((proc = rb_iv_get(self, "@notice_processor")) != Qnil) {
+		rb_funcall(proc, rb_intern("call"), 1, rb_tainted_str_new2(message));
+	}
+	return;
+}
+
+/********************************************************************
+ *
+ * Document-class: PGError
+ *
+ * This is the exception class raised when an error is returned from
+ * a libpq API call.
+ * 
+ * The attributes +connection+ and +result+ are set to the connection
+ * object and result set object, respectively.
+ *
+ * If the connection object or result set object is not available from
+ * the context in which the error was encountered, it is +nil+.
+ */
+
 /********************************************************************
  * 
  * Document-class: PGconn
@@ -207,17 +251,13 @@ static VALUE yield_pgresult(VALUE rb_pgresult)
 
 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
 static VALUE
-pgconn_alloc(klass)
-    VALUE klass;
+pgconn_alloc(VALUE klass)
 {
 	return Data_Wrap_Struct(klass, NULL, free_pgconn, NULL);
 }
 #else
 static VALUE
-pgconn_s_new(argc, argv, klass)
-    int argc;
-    VALUE *argv;
-    VALUE klass;
+pgconn_s_new(int argc, VALUE *argv, VALUE klass)
 {
     VALUE self = rb_obj_alloc(klass);
     rb_obj_call_init(self, argc, argv);
@@ -269,7 +309,6 @@ pgconn_init(argc, argv, self)
 	char *conninfo = NULL;
 	VALUE conninfo_rstr;
 	VALUE error;
-	VALUE temp;
 	char *host, *port, *opt, *tty, *dbname, *login, *pwd;
 	host=port=opt=tty=dbname=login=pwd=NULL;
 
@@ -332,6 +371,17 @@ pgconn_init(argc, argv, self)
     return self;
 }
 
+/*TODO
+ * call-seq:
+ *    PGconn.connect_start( ... ) -> PGconn
+ */
+static VALUE
+pgconn_s_connect_start(int argc, VALUE *argv, VALUE self)
+{
+	rb_raise(rb_eStandardError, "PGconn.connect_start unimplemented.");
+	return Qnil;
+}
+
 /*
  * call-seq:
  *    PGconn.conndefaults() -> Array
@@ -422,6 +472,20 @@ pgconn_s_isthreadsafe(self)
  * PGconn INSTANCE METHODS
  **************************************************************************/
 
+/*TODO
+ * call-seq:
+ *    conn.connect_poll() -> Fixnum
+ *
+ * 
+ */
+static VALUE
+pgconn_connect_poll(VALUE self)
+{
+	PostgresPollingStatusType status;
+	status = PQconnectPoll(get_pgconn(self));
+	return INT2FIX((int)status);
+}
+
 /*
  * call-seq:
  *    conn.finish()
@@ -441,7 +505,8 @@ pgconn_finish(self)
  * call-seq:
  *    conn.reset()
  *
- * Resets the backend connection. This method closes the backend connection and tries to re-connect.
+ * Resets the backend connection. This method closes the 
+ * backend connection and tries to re-connect.
  */
 static VALUE
 pgconn_reset(self)
@@ -451,9 +516,39 @@ pgconn_reset(self)
     return self;
 }
 
-//TODO conn.reset_start
+/*
+ * call-seq:
+ *    conn.reset_start() -> nil
+ *
+ * Initiate a connection reset in a nonblocking manner.
+ * This will close the current connection and attempt to
+ * reconnect using the same connection parameters.
+ * Use PGconn#reset_poll to check the status of the 
+ * connection reset.
+ */
+static VALUE
+pgconn_reset_start(VALUE self)
+{
+	if(PQresetStart(get_pgconn(self)) == 0)
+		rb_raise(rb_ePGError, "reset has failed");
+	return Qnil;
+}
 
-//TODO conn.reset_poll
+/*
+ * call-seq:
+ *    conn.reset_poll -> Fixnum
+ *
+ * Checks the status of a connection reset operation.
+ * See PGconn#connect_start and PGconn#connect_poll for
+ * usage information and return values.
+ */
+static VALUE
+pgconn_reset_poll(VALUE self)
+{
+	PostgresPollingStatusType status;
+	status = PQresetPoll(get_pgconn(self));
+	return INT2FIX((int)status);
+}
 
 /*
  * call-seq:
@@ -663,14 +758,20 @@ pgconn_error_message(self)
     return rb_tainted_str_new2(error);
 }
 
-//TODO PQsocket
 /*
  * call-seq:
- *    conn.socket() -> TCPSocket
+ *    conn.socket() -> Fixnum
  *
- * Returns the socket file descriptor of this
- * connection.
+ * Returns the socket's file descriptor for this connection.
  */
+static VALUE
+pgconn_socket(VALUE self)
+{
+	int sd;
+	if( (sd = PQsocket(get_pgconn(self))) < 0)
+		rb_raise(rb_ePGError, "Can't get socket descriptor");
+	return INT2NUM(sd);
+}
 
 
 /*
@@ -820,14 +921,19 @@ pgconn_exec(argc, argv, self)
 			param_format = rb_hash_aref(param, sym_format);
 		}
 		else {
-			param_type = INT2NUM(0);
+			param_type = Qnil;
 			if(param == Qnil)
 				param_value = param;
 			else
 				param_value = rb_obj_as_string(param);
-			param_format = INT2NUM(0);
+			param_format = Qnil;
 		}
-		paramTypes[i] = NUM2INT(param_type);
+
+		if(param_type == Qnil)
+			paramTypes[i] = 0;
+		else
+			paramTypes[i] = NUM2INT(param_type);
+
 		if(param_value == Qnil) {
 			paramValues[i] = NULL;
 			paramLengths[i] = 0;
@@ -835,9 +941,13 @@ pgconn_exec(argc, argv, self)
 		else {
 			Check_Type(param_value, T_STRING);
 			paramValues[i] = StringValuePtr(param_value);
-			paramLengths[i] = RSTRING_LEN(param_value) + 1;
+			paramLengths[i] = RSTRING_LEN(param_value);
 		}
-		paramFormats[i] = NUM2INT(param_format);
+
+		if(param_format == Qnil)
+			paramFormats[i] = 0;
+		else
+			paramFormats[i] = NUM2INT(param_format);
 	}
 	
 	result = PQexecParams(conn, StringValuePtr(command), nParams, paramTypes, 
@@ -903,7 +1013,10 @@ pgconn_prepare(argc, argv, self)
 		for(i = 0; i < nParams; i++) {
 			param = rb_ary_entry(in_paramtypes, i);
 			Check_Type(param, T_FIXNUM);
-			paramTypes[i] = NUM2INT(param);
+			if(param == Qnil)
+				paramTypes[i] = 0;
+			else
+				paramTypes[i] = NUM2INT(param);
 		}
 	}
 	result = PQprepare(conn, StringValuePtr(name), StringValuePtr(command),
@@ -1009,9 +1122,13 @@ pgconn_exec_prepared(argc, argv, self)
 		else {
 			Check_Type(param_value, T_STRING);
 			paramValues[i] = StringValuePtr(param_value);
-			paramLengths[i] = RSTRING_LEN(param_value) + 1;
+			paramLengths[i] = RSTRING_LEN(param_value);
 		}
-		paramFormats[i] = NUM2INT(param_format);
+
+		if(param_format == Qnil)
+			paramFormats[i] = 0;
+		else
+			paramFormats[i] = NUM2INT(param_format);
 	}
 	
 	result = PQexecPrepared(conn, StringValuePtr(name), nParams, 
@@ -1342,7 +1459,12 @@ pgconn_send_query(argc, argv, self)
 				param_value = rb_obj_as_string(param);
 			param_format = INT2NUM(0);
 		}
-		paramTypes[i] = NUM2INT(param_type);
+
+		if(param_type == Qnil)
+			paramTypes[i] = 0;
+		else
+			paramTypes[i] = NUM2INT(param_type);
+
 		if(param_value == Qnil) {
 			paramValues[i] = NULL;
 			paramLengths[i] = 0;
@@ -1350,9 +1472,13 @@ pgconn_send_query(argc, argv, self)
 		else {
 			Check_Type(param_value, T_STRING);
 			paramValues[i] = StringValuePtr(param_value);
-			paramLengths[i] = RSTRING_LEN(param_value) + 1;
+			paramLengths[i] = RSTRING_LEN(param_value);
 		}
-		paramFormats[i] = NUM2INT(param_format);
+
+		if(param_format == Qnil)
+			paramFormats[i] = 0;
+		else
+			paramFormats[i] = NUM2INT(param_format);
 	}
 	
 	result = PQsendQueryParams(conn, StringValuePtr(command), nParams, paramTypes, 
@@ -1417,7 +1543,10 @@ pgconn_send_prepare(argc, argv, self)
 		for(i = 0; i < nParams; i++) {
 			param = rb_ary_entry(in_paramtypes, i);
 			Check_Type(param, T_FIXNUM);
-			paramTypes[i] = NUM2INT(param);
+			if(param == Qnil)
+				paramTypes[i] = 0;
+			else
+				paramTypes[i] = NUM2INT(param);
 		}
 	}
 	result = PQsendPrepare(conn, StringValuePtr(name), StringValuePtr(command),
@@ -1519,6 +1648,7 @@ pgconn_send_query_prepared(argc, argv, self)
 				param_value = rb_obj_as_string(param);
 			param_format = INT2NUM(0);
 		}
+
 		if(param_value == Qnil) {
 			paramValues[i] = NULL;
 			paramLengths[i] = 0;
@@ -1526,9 +1656,13 @@ pgconn_send_query_prepared(argc, argv, self)
 		else {
 			Check_Type(param_value, T_STRING);
 			paramValues[i] = StringValuePtr(param_value);
-			paramLengths[i] = RSTRING_LEN(param_value) + 1;
+			paramLengths[i] = RSTRING_LEN(param_value);
 		}
-		paramFormats[i] = NUM2INT(param_format);
+
+		if(param_format == Qnil)
+			paramFormats[i] = 0;
+		else
+			paramFormats[i] = NUM2INT(param_format);
 	}
 	
 	result = PQsendQueryPrepared(conn, StringValuePtr(name), nParams, 
@@ -1911,31 +2045,54 @@ pgconn_set_error_verbosity(VALUE self, VALUE in_verbosity)
 	return INT2FIX(PQsetErrorVerbosity(conn, verbosity));
 }
 
-/*TODO
+/*
  * call-seq:
- *    conn.trace( port )
+ *    conn.trace( stream ) -> nil
  * 
- * Enables tracing message passing between backend.
- * The trace message will be written to the _port_ object,
- * which is an instance of the class +File+.
+ * Enables tracing message passing between backend. The 
+ * trace message will be written to the stream _stream_,
+ * which must implement a method +fileno+ that returns
+ * a writable file descriptor.
  */
 static VALUE
-pgconn_trace(self, port)
-    VALUE self, port;
+pgconn_trace(VALUE self, VALUE stream)
 {
-    //OpenFile* fp;
+	FILE *fp;
+	VALUE fileno;
+	FILE *new_fp;
+	int old_fd, new_fd;
+	VALUE new_file;
 
-    Check_Type(port, T_FILE);
-    //GetOpenFile(port, fp);
+	if(rb_respond_to(stream,rb_intern("fileno")) == Qfalse)
+		rb_raise(rb_eArgError, "stream does not respond to method: fileno");
 
-    //PQtrace(get_pgconn(self), fp->f2?fp->f2:fp->f);
+	fileno = rb_funcall(stream, rb_intern("fileno"), 0);
+	if(fileno == Qnil)
+		rb_raise(rb_eArgError, "can't get file descriptor from stream");
 
-    return self;
+	/* Duplicate the file descriptor and re-open
+	 * it. Then, make it into a ruby File object
+	 * and assign it to an instance variable.
+	 * This prevents a problem when the File
+	 * object passed to this function is closed
+	 * before the connection object is. */
+	old_fd = NUM2INT(fileno);
+	new_fd = dup(old_fd);
+	new_fp = fdopen(new_fd, "w");
+
+	if(new_fp == NULL)
+		rb_raise(rb_eArgError, "stream is not writable");
+
+	new_file = rb_funcall(rb_cIO, rb_intern("new"), 1, INT2NUM(new_fd));
+	rb_iv_set(self, "@trace_stream", new_file);
+
+	PQtrace(get_pgconn(self), new_fp);
+	return Qnil;
 }
 
 /*
  * call-seq:
- *    conn.untrace()
+ *    conn.untrace() -> nil
  * 
  * Disables the message tracing.
  */
@@ -1943,14 +2100,105 @@ static VALUE
 pgconn_untrace(self)
     VALUE self;
 {
-    PQuntrace(get_pgconn(self));
-    return self;
+	VALUE trace_stream;
+	PQuntrace(get_pgconn(self));
+	trace_stream = rb_iv_get(self, "@trace_stream");
+	rb_funcall(trace_stream, rb_intern("close"), 0);
+	rb_iv_set(self, "@trace_stream", Qnil);
+	return Qnil;
 }
 
-//TODO set_notice_receiver
+/*
+ * call-seq:
+ *   conn.set_notice_receiver {|result| ... } -> Proc
+ *
+ * Notice and warning messages generated by the server are not returned
+ * by the query execution functions, since they do not imply failure of
+ * the query. Instead they are passed to a notice handling function, and
+ * execution continues normally after the handler returns. The default
+ * notice handling function prints the message on <tt>stderr</tt>, but the
+ * application can override this behavior by supplying its own handling
+ * function.
+ *
+ * This function takes a new block to act as the handler, which should
+ * accept a single parameter that will be a PGresult object, and returns 
+ * the Proc object previously set, or +nil+ if it was previously the default.
+ *
+ * If you pass no arguments, it will reset the handler to the default.
+ */
+static VALUE
+pgconn_set_notice_receiver(VALUE self)
+{
+    VALUE proc, old_proc;
+    PGconn *conn = get_pgconn(self);
+
+	/* If default_notice_receiver is unset, assume that the current 
+	 * notice receiver is the default, and save it to a global variable. 
+	 * This should not be a problem because the default receiver is
+	 * always the same, so won't vary among connections.
+	 */
+	if(default_notice_receiver == NULL)
+		default_notice_receiver = PQsetNoticeReceiver(conn, NULL, NULL);
+
+	old_proc = rb_iv_get(self, "@notice_receiver");
+	if( rb_block_given_p() ) {
+		proc = rb_block_proc();
+		PQsetNoticeReceiver(conn, notice_receiver_proxy, (void *)self);
+	} else {
+		/* if no block is given, set back to default */
+		proc = Qnil;
+		PQsetNoticeReceiver(conn, default_notice_receiver, NULL);
+	}
 
-//TODO set_notice_processor
+	rb_iv_set(self, "@notice_receiver", proc);
+	return old_proc;
+}
 
+/*
+ * call-seq:
+ *   conn.set_notice_processor {|message| ... } -> Proc
+ *
+ * Notice and warning messages generated by the server are not returned
+ * by the query execution functions, since they do not imply failure of
+ * the query. Instead they are passed to a notice handling function, and
+ * execution continues normally after the handler returns. The default
+ * notice handling function prints the message on <tt>stderr</tt>, but the
+ * application can override this behavior by supplying its own handling
+ * function.
+ *
+ * This function takes a new block to act as the handler, which should
+ * accept a single parameter that will be a PGresult object, and returns 
+ * the Proc object previously set, or +nil+ if it was previously the default.
+ *
+ * If you pass no arguments, it will reset the handler to the default.
+ */
+static VALUE
+pgconn_set_notice_processor(VALUE self)
+{
+    VALUE proc, old_proc;
+    PGconn *conn = get_pgconn(self);
+
+	/* If default_notice_processor is unset, assume that the current 
+	 * notice processor is the default, and save it to a global variable. 
+	 * This should not be a problem because the default processor is
+	 * always the same, so won't vary among connections.
+	 */
+	if(default_notice_processor == NULL)
+		default_notice_processor = PQsetNoticeProcessor(conn, NULL, NULL);
+
+	old_proc = rb_iv_get(self, "@notice_processor");
+	if( rb_block_given_p() ) {
+		proc = rb_block_proc();
+		PQsetNoticeProcessor(conn, notice_processor_proxy, (void *)self);
+	} else {
+		/* if no block is given, set back to default */
+		proc = Qnil;
+		PQsetNoticeProcessor(conn, default_notice_processor, NULL);
+	}
+
+	rb_iv_set(self, "@notice_processor", proc);
+	return old_proc;
+}
 /*
  * call-seq:
  *    conn.get_client_encoding() -> String
@@ -2002,20 +2250,17 @@ pgconn_transaction(VALUE self)
 		result = PQexec(conn, "BEGIN");
 		rb_pgresult = new_pgresult(result);
 		pgresult_check(self, rb_pgresult);
-		fprintf(stderr,"BEGIN\n");
 		rb_protect(rb_yield, self, &status);
 		if(status == 0) {
 			result = PQexec(conn, "COMMIT");
 			rb_pgresult = new_pgresult(result);
 			pgresult_check(self, rb_pgresult);
-			fprintf(stderr,"COMMIT\n");
 		}
 		else {
 			/* exception occurred, ROLLBACK and re-raise */
 			result = PQexec(conn, "ROLLBACK");
 			rb_pgresult = new_pgresult(result);
 			pgresult_check(self, rb_pgresult);
-			fprintf(stderr,"ROLLBACK\n");
 			rb_jump_tag(status);
 		}
 			
@@ -2055,7 +2300,7 @@ pgconn_s_quote_ident(VALUE self, VALUE in_str)
 	/* result size at most NAMEDATALEN*2 plus surrounding
      * double-quotes. */
 	char buffer[NAMEDATALEN*2+2];
-	int i=0,j=0;
+	unsigned int i=0,j=0;
 	
 	if(strlen(str) >= NAMEDATALEN) {
 		rb_raise(rb_eArgError, 
@@ -2139,13 +2384,10 @@ static VALUE
 pgconn_get_last_result(VALUE self)
 {
 	VALUE ret, result;
-	int result_found = 0;
+	ret = Qnil;
 	while((result = pgconn_get_result(self)) != Qnil) {
 		ret = result;
-		result_found = 1;
 	}
-	if(!result_found)
-		return Qnil;
 	return ret;
 } 
 
@@ -2168,45 +2410,6 @@ pgconn_async_exec(int argc, VALUE *argv, VALUE self)
 	return pgconn_get_last_result(self);
 }
 
-/*TODO */
-static void
-notice_proxy(self, message)
-    VALUE self;
-    const char *message;
-{
-    VALUE block;
-    if ((block = rb_iv_get(self, "@on_notice")) != Qnil) {
-        rb_funcall(block, rb_intern("call"), 1, rb_str_new2(message));
-    }
-}
-
-/*TODO
- * call-seq:
- *   conn.on_notice {|message| ... }
- *
- * Notice and warning messages generated by the server are not returned
- * by the query execution functions, since they do not imply failure of
- * the query. Instead they are passed to a notice handling function, and
- * execution continues normally after the handler returns. The default
- * notice handling function prints the message on <tt>stderr</tt>, but the
- * application can override this behavior by supplying its own handling
- * function.
- */
-static VALUE
-pgconn_set_notice_processor(self)
-    VALUE self;
-{
-    VALUE block = rb_block_proc();
-    PGconn *conn = get_pgconn(self);
-    if (PQsetNoticeProcessor(conn, NULL, NULL) != notice_proxy) {
-        PQsetNoticeProcessor(conn, notice_proxy, (void *) self);
-    }
-    rb_iv_set(self, "@on_notice", block);
-    return self;
-}
-
-
-
 /**************************************************************************
  * LARGE OBJECT SUPPORT
  **************************************************************************/
@@ -2612,10 +2815,11 @@ pgresult_result_error_message(self)
  * * +PG_DIAG_SOURCE_FUNCTION+
  */
 static VALUE
-pgresult_result_error_field(self)
-    VALUE self;
+pgresult_result_error_field(VALUE self, VALUE field)
 {
-    return rb_tainted_str_new2(PQresultErrorMessage(get_pgresult(self)));
+	PGresult *result = get_pgresult(self);
+	int fieldcode = NUM2INT(field);
+    return rb_tainted_str_new2(PQresultErrorField(result,fieldcode));
 }
 
 /*
@@ -2629,7 +2833,7 @@ pgresult_clear(self)
     VALUE self;
 {
     PQclear(get_pgresult(self));
-    DATA_PTR(self) = 0;
+    DATA_PTR(self) = NULL;
     return Qnil;
 }
 
@@ -2864,7 +3068,8 @@ pgresult_getvalue(self, tup_num, field_num)
    	}
 	if(PQgetisnull(result, i, j))
 		return Qnil;
-	return rb_tainted_str_new2(PQgetvalue(result, i, j));
+	return rb_tainted_str_new(PQgetvalue(result, i, j), 
+				PQgetlength(result, i, j));
 }
 
 /*
@@ -3032,7 +3237,8 @@ pgresult_aref(self, index)
 			rb_hash_aset(tuple, fname, Qnil);
 		}
 		else {
-			val = rb_tainted_str_new2(PQgetvalue(result, tuple_num, field_num));
+			val = rb_tainted_str_new(PQgetvalue(result, tuple_num, field_num),
+				PQgetlength(result, tuple_num, field_num));
 			rb_hash_aset(tuple, fname, val);
 		}
 	}
@@ -3119,6 +3325,7 @@ Init_pg()
 	rb_define_singleton_method(rb_cPGconn, "isthreadsafe", pgconn_s_isthreadsafe, 0);
 	rb_define_singleton_method(rb_cPGconn, "encrypt_password", pgconn_s_encrypt_password, 0);
 	rb_define_singleton_method(rb_cPGconn, "quote_ident", pgconn_s_quote_ident, 1);
+	rb_define_singleton_method(rb_cPGconn, "connect_start", pgconn_s_connect_start, -1);
 	rb_define_singleton_method(rb_cPGconn, "conndefaults", pgconn_s_conndefaults, 0);
 
 	/******     PGconn CLASS CONSTANTS: Connection Status     ******/
@@ -3160,9 +3367,12 @@ Init_pg()
 
 	/******     PGconn INSTANCE METHODS: Connection Control     ******/
 	rb_define_method(rb_cPGconn, "initialize", pgconn_init, -1);
+	rb_define_method(rb_cPGconn, "connect_poll", pgconn_connect_poll, 0);
+	rb_define_method(rb_cPGconn, "finish", pgconn_finish, 0);
 	rb_define_method(rb_cPGconn, "reset", pgconn_reset, 0);
+	rb_define_method(rb_cPGconn, "reset_start", pgconn_reset_start, 0);
+	rb_define_method(rb_cPGconn, "reset_poll", pgconn_reset_poll, 0);
 	rb_define_method(rb_cPGconn, "conndefaults", pgconn_s_conndefaults, 0);
-	rb_define_method(rb_cPGconn, "finish", pgconn_finish, 0);
 	rb_define_alias(rb_cPGconn, "close", "finish");
 
 	/******     PGconn INSTANCE METHODS: Connection Status     ******/
@@ -3179,7 +3389,7 @@ Init_pg()
 	rb_define_method(rb_cPGconn, "protocol_version", pgconn_protocol_version, 0);
 	rb_define_method(rb_cPGconn, "server_version", pgconn_server_version, 0);
 	rb_define_method(rb_cPGconn, "error_message", pgconn_error_message, 0);
-	//rb_define_method(rb_cPGconn, "socket", pgconn_socket, 0);
+	rb_define_method(rb_cPGconn, "socket", pgconn_socket, 0);
 	rb_define_method(rb_cPGconn, "backend_pid", pgconn_backend_pid, 0);
 	rb_define_method(rb_cPGconn, "connection_needs_password", pgconn_connection_needs_password, 0);
 	rb_define_method(rb_cPGconn, "connection_used_password", pgconn_connection_used_password, 0);
@@ -3230,7 +3440,7 @@ Init_pg()
 	rb_define_method(rb_cPGconn, "untrace", pgconn_untrace, 0);
 
 	/******     PGconn INSTANCE METHODS: Notice Processing     ******/
-	//rb_define_method(rb_cPGconn, "set_notice_receiver", pgconn_set_notice_receiver, 0);
+	rb_define_method(rb_cPGconn, "set_notice_receiver", pgconn_set_notice_receiver, 0);
 	rb_define_method(rb_cPGconn, "set_notice_processor", pgconn_set_notice_processor, 0);
 
 	/******     PGconn INSTANCE METHODS: Other    ******/
@@ -3304,7 +3514,7 @@ Init_pg()
 	rb_define_method(rb_cPGresult, "result_status", pgresult_result_status, 0);
 	rb_define_method(rb_cPGresult, "res_status", pgresult_res_status, 1);
 	rb_define_method(rb_cPGresult, "result_error_message", pgresult_result_error_message, 0);
-	rb_define_method(rb_cPGresult, "result_error_field", pgresult_result_error_field, 0);
+	rb_define_method(rb_cPGresult, "result_error_field", pgresult_result_error_field, 1);
 	rb_define_method(rb_cPGresult, "clear", pgresult_clear, 0);
 	rb_define_method(rb_cPGresult, "ntuples", pgresult_ntuples, 0);
 	rb_define_alias(rb_cPGresult, "num_tuples", "ntuples");

data/ext/pg.h

@@ -1,7 +1,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/types.h>
-#include <unistd.h>
 
 #include "ruby.h"
 #include "rubyio.h"
@@ -10,9 +9,9 @@
 
 #include "compat.h"
 
-#if RUBY_VERSION_CODE < 180
-#define rb_check_string_type(x) rb_check_convert_type(x, T_STRING, "String", "to_str")
-#endif /* RUBY_VERSION_CODE < 180 */
+#if RUBY_VM != 1
+#define RUBY_18_COMPAT
+#endif
 
 #ifndef RARRAY_LEN
 #define RARRAY_LEN(x) RARRAY((x))->len
@@ -30,5 +29,9 @@
 #define StringValuePtr(x) STR2CSTR(x)
 #endif /* StringValuePtr */
 
+#ifdef RUBY_18_COMPAT
+#define rb_io_stdio_file GetWriteFile
+#endif
+
 void Init_pg(void);
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: pg
 version: !ruby/object:Gem::Version 
-  version: 0.7.9.2008.02.05
-date: 2008-02-05 00:00:00 -08:00
+  version: 0.7.9.2008.03.18
+date: 2008-03-18 00:00:00 -07:00
 summary: Ruby extension library providing an API to PostgreSQL
 require_paths: 
 - lib
@@ -33,12 +33,12 @@ authors:
 - Dave Lee
 - Jeff Davis
 files: 
-- COPYING
+- README
+- LICENSE
 - COPYING.txt
 - Contributors
 - GPL
-- LICENSE
-- README
+- BSD
 - ext/compat.c
 - ext/compat.h
 - ext/pg.h

data/COPYING

@@ -1,340 +0,0 @@
-		    GNU GENERAL PUBLIC LICENSE
-		       Version 2, June 1991
-
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.
- 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-			    Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users.  This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it.  (Some other Free Software Foundation software is covered by
-the GNU Library General Public License instead.)  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have.  You must make sure that they, too, receive or can get the
-source code.  And you must show them these terms so they know their
-rights.
-
-  We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
-  Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software.  If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary.  To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-		    GNU GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License.  The "Program", below,
-refers to any such program or work, and a "work based on the Program"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language.  (Hereinafter, translation is included without limitation in
-the term "modification".)  Each licensee is addressed as "you".
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
-  1. You may copy and distribute verbatim copies of the Program's
-source code as you receive it, in any medium, provided that you
-conspicuously and appropriately publish on each copy an appropriate
-copyright notice and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
-
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
-
-  2. You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) You must cause the modified files to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    b) You must cause any work that you distribute or publish, that in
-    whole or in part contains or is derived from the Program or any
-    part thereof, to be licensed as a whole at no charge to all third
-    parties under the terms of this License.
-
-    c) If the modified program normally reads commands interactively
-    when run, you must cause it, when started running for such
-    interactive use in the most ordinary way, to print or display an
-    announcement including an appropriate copyright notice and a
-    notice that there is no warranty (or else, saying that you provide
-    a warranty) and that users may redistribute the program under
-    these conditions, and telling the user how to view a copy of this
-    License.  (Exception: if the Program itself is interactive but
-    does not normally print such an announcement, your work based on
-    the Program is not required to print an announcement.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
-    a) Accompany it with the complete corresponding machine-readable
-    source code, which must be distributed under the terms of Sections
-    1 and 2 above on a medium customarily used for software interchange; or,
-
-    b) Accompany it with a written offer, valid for at least three
-    years, to give any third party, for a charge no more than your
-    cost of physically performing source distribution, a complete
-    machine-readable copy of the corresponding source code, to be
-    distributed under the terms of Sections 1 and 2 above on a medium
-    customarily used for software interchange; or,
-
-    c) Accompany it with the information you received as to the offer
-    to distribute corresponding source code.  (This alternative is
-    allowed only for noncommercial distribution and only if you
-    received the program in object code or executable form with such
-    an offer, in accord with Subsection b above.)
-
-The source code for a work means the preferred form of the work for
-making modifications to it.  For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable.  However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
-
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License.  Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
-  5. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Program or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
-  6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  7. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded.  In such case, this License incorporates
-the limitation as if written in the body of this License.
-
-  9. The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Program
-specifies a version number of this License which applies to it and "any
-later version", you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation.  If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
-  10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission.  For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this.  Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-
-			    NO WARRANTY
-
-  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
-
-  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
-OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
-TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
-YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
-PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGES.
-
-		     END OF TERMS AND CONDITIONS
-
-	    How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
-
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
-    Gnomovision version 69, Copyright (C) year name of author
-    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, the commands you use may
-be called something other than `show w' and `show c'; they could even be
-mouse-clicks or menu items--whatever suits your program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the program, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-  `Gnomovision' (which makes passes at compilers) written by James Hacker.
-
-  <signature of Ty Coon>, 1 April 1989
-  Ty Coon, President of Vice
-
-This General Public License does not permit incorporating your program into
-proprietary programs.  If your program is a subroutine library, you may
-consider it more useful to permit linking proprietary applications with the
-library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.