Rcs::Agent - an RCS archive manipulation method library

    $rcs = new Rcs::Agent (	file => "/data/src/foobar.c");

    $rcs = new Rcs::Agent (	file => "foobar.c", 
    				workdir => "/data/src");

    my $parent = $rcs->parent (revision => '1.2');

    my $parent = $rcs->parent (revision => '1.5.3.1');

    my $description = $rcs->description ();

    $rcs->description (description => 'Main source file');

    if ($rcs->locked(revision => "1.3")) {
        <code if version is locked>
    } else {
        <code if version is unlocked>
    }

    my $author = $rcs->author(revision => "1.3");

# Rcs::Agent
#
# An RCS frobnicator
#
# $Id: Agent.pm,v 1.32 2007/08/20 16:39:56 nick Exp $

package Rcs::Agent;

# Be neutoric about syntax
use strict;

# These packages are part of the base perl system 
use Carp;
use File::Basename;
use File::stat;
use Cwd;

# These packages are from CPAN
use String::ShellQuote;
use File::Temp;

# Data::Dumper is used solely for debugging
# use Data::Dumper;

use vars qw(@ISA @EXPORT_OK @EXPORT $VERSION $AUTOLOAD);

$VERSION = '1.05';

1;

##
## new
##  

sub new {
	my ($type) = shift if @_;
	my $class = ref($type) || $type || "Rcs::Agent";
	my %args = @_;
	my ($tag);
	my @tags = qw (file workdir rcsdir suffix tmpdir);

	my $self = {
		version	=> $VERSION,
		err	=> "",
	};

	foreach $tag (@tags) {
		$self->{$tag} = $args{$tag} if (defined ($args{$tag}));
	}

	# Default suffix is ",v"
	$self->{suffix} = ",v" unless (defined ($self->{suffix}));

	# don't continue unless a filename is supplied
	return undef if (!defined ($self->{file}));

	# filename contains path separators?
	if ($self->{file} =~ /\//) {
		my $dir = dirname($self->{file});
		# if pathname is absolute, then path => workdir, basename => file
		if ($dir =~ /^\//) {
			$self->{workdir} = $dir;
			$self->{file} = basename($self->{file});
		# otherwise append path to workdir, if it already exists.
		} else {
			$self->{workdir} = defined ($self->{workdir}) ? $self->{workdir} : "";
			$self->{workdir} .= "/$dir";
		}
	}

	$self->{workdir} = "." unless (defined ($self->{workdir}));

	# don't continue unless the work directory actually exists
	return undef unless (-d $self->{workdir});

	# trim trailing slashes off end of workdir
	$self->{workdir} =~ s/(\/+)$//g;

	# Figure out correct rcsdir
	#
	# If rcsdir has been supplied, then use that.
	# If rcsdir hasn't been supplied, then check for workdir/RCS/foo,v and workdir/foo,v in order

	unless (defined ($self->{rcsdir})) {
		# if RCS/ directory exists and there's a version file in it, use that.
		if (-d $self->{workdir}."/RCS" && 
				-e $self->{workdir}."/RCS/".$self->{file}.$self->{suffix}) {
			$self->{rcsdir} = $self->{workdir}."/RCS";

		# if the version file is in the workdir, use that...
		} elsif (-e $self->{workdir}."/".$self->{file}.$self->{suffix}) {
			$self->{rcsdir} = $self->{workdir};

		# there's no version file at all => use RCS/ dir if it exists, otherwise workdir
		} else {
			$self->{rcsdir} = (-d $self->{workdir}."/RCS") ?
				$self->{workdir}."/RCS" : $self->{workdir};
		}
	}

	$self->{rcsdir} =~ s/(\/+)$//g;

	$self->{rcsfile} = $self->{rcsdir}."/".$self->{file}.$self->{suffix};

	$self->{hpux} = 1 if $^O eq 'hpux';

	bless $self, $class;

	return $self;
}

##
## err
##

sub err {
	my $self = shift;

	$self->{err};
}

##
## head
##

sub head {
	my $self = shift;

	$self->{err} = "";

	$self->parse || return undef;

	return $self->{head};
}

##
## timestamp
##

sub timestamp {
	my $self = shift;

	$self->{err} = "";

	my $sb = stat($self->{rcsfile});
	unless (defined($sb)) {
		$self->{err} = "couldn't open $self->{rcsfile}: $!";
		return undef;
	}

	$self->{mtime} = $sb->mtime;

	$sb->mtime;
}

##
## archived
##

sub archived {
	my $self = shift;

	-r $self->{rcsfile} ? 1 : 0;
}


##
## parse
##
## parses the RCS archive file.  This is an internal-only function.  Please ignore it.
##
## returns:     1 if the file already has a readable and parsable RCS archive file
##              undef otherwise, putting flag in error buffer
##

sub parse {
	my $self = shift;
	my %args = @_;
	my %branches;

	$self->{err} = "";

	# only parse file if not parsed previously and rcs file has not been modified
	if ($self->{parsed}) {
		my $mtime = $self->{mtime};
		return 1 if ($mtime == $self->timestamp);
	}

	if (!$self->archived) {
		$self->{err} = "RCS archive file not found";
		return undef;
	} 

	# This is to prevent recursion
	if (defined ($self->{parsing})) {
		return 1;
	}
	$self->{parsing} = 1;

	# First, we need to delete a whole bunch of stuff if it's already
	# defined from previous parsing attempts.
	foreach my $tag (qw (access revisions head symbols strict)) {
		delete $self->{$tag} if defined ($self->{$tag});
	}

	unless (open (INPUT, $self->{rcsfile})) {
		$self->{err} = "couldn't open $self->{rcsfile}: $!";
		return undef;
	}

	# The preamble contains information about the archive.  We slurp it in as a single
	# paragraph

	my $oldseparator = $/;
	$/ = "";

	my $data = <INPUT>;
	$data =~ s/[\n\r\s]+/ /g;
	my @tokens = split (/\s*;\s*/, $data);

	$self->{strict} = 0;

	# For the moment, we only parse head, locks, symbols and strict.
	foreach my $token (@tokens) {
		if ($token =~ /^access/) {
			my @access = split (/ /, $token); shift @access;
                        $self->{access} = \@access if @access;
			next;
		}

		if ($token =~ /^head\s+([\d\.]+)/) {
			$self->{head} = $1;
			next;
		}

		if ($token =~ /^strict/) {
			$self->{strict} = 1;
			next;
		}

		if ($token =~ /^symbols/) {
			my @symtokens = split (/ /, $token); shift @symtokens;
			foreach my $tag (@symtokens) {
				next unless ($tag =~ /(.*):(.*)/);
				$self->{symbols}->{$1} = $2;
			}
			next;
		}

		if ($token =~ /^locks/) {
			my @symtokens = split (/ /, $token); shift @symtokens;
			foreach my $tag (@symtokens) {
				next unless ($tag =~ /(.*):(.*)/);
				$self->{revisions}->{$2}->{locker} = $1;
			}
			next;
		}
	}

	# deal with the individual revision entry
	while ($data = <INPUT>) {
		my ($nextrev);
		$data =~ s/[\n\r\s]+/ /g;
		next unless ($data =~ /([\d\.]+)\s+(.*)/);
		my $revision = $1; $data = $2;

		delete $branches{$revision} if ($branches{$revision});

		@tokens = split (/\s*;\s*/, $data);

		foreach my $token (@tokens) {
			if ($token =~ /^next\s+([\d\.]+)/) {
				my ($up, $down) = qw (parent child);
				$nextrev = $1;

				# set up doubly linked list so that each revision knows what's next
				# to it.  For some reason which I don't see, the direction of the
				# next revisions in the head line is in the opposite direction to
				# revisions in the branches.  If you don't understand what I mean
				# here, take a look at the direction of the arrows in the ascii art
				# in the man page for rcsfile(5).  This means that we have to
				# invert child and parent in this context.

				if ($revision =~ /^\d+\.\d+$/) {		# i.e. head branch
					($up, $down) = qw (child parent);	# i.e. arseways
				}

				$self->{revisions}->{$revision}->{$down} = $nextrev;
				$self->{revisions}->{$nextrev}->{$up} = $revision;

				# we need a place to put in initial revision numbers. This is as
				# good as any
				$self->{revisions}->{$revision}->{linesadded} = 0;
				$self->{revisions}->{$revision}->{linesdeleted} = 0;
				next;
			}

			if ($token =~ /^author\s+(\S+)/) {
				$self->{revisions}->{$revision}->{author} = $1;
				next;
			}

			if ($token =~ /^state\s+(\S+)/) {
				$self->{revisions}->{$revision}->{state} = $1;
				next;
			}

			if ($token =~ /^date\s+(\S+)/) {
				$self->{revisions}->{$revision}->{date} = $1;
				next;
			}

			if ($token =~ /^branches/) {
				my @symtokens = split (/ /, $token); shift @symtokens;
				next unless ($#symtokens >= 0);
				push (@{$self->{revisions}->{$revision}->{branches}}, @symtokens);
				foreach my $symtoken (@symtokens) {
					$self->{revisions}->{$symtoken}->{parent} = $revision;
					$branches{$symtoken} = 1;
				}

				next;
			}
		}

		last unless ($nextrev || scalar(%branches));
	}

	# Now we need to go back to line-by-line processing mode
	$/ = $oldseparator;

	my $intext = 0;

	# pull out the archive description
	while (chomp($data = <INPUT>)) {

		if (!$intext && $data =~ /^desc/) {
			$intext = 1;
			next;
		}

		# first line of data text
		if ($intext == 1 && $data =~ /^\@/) {
			$data =~ s/^\@//;
			$intext++;
		}
			
		# end of text input is marked by @ at EOL
		if ($intext && $data =~ /[^\@]*\@$/) {
			$data =~ s/\@$//;	# remove trailing 
			push @{$self->{desc}}, $data if ($data);
			$intext = 0;
			last;
		}

		push @{$self->{desc}}, $data if ($intext);
	}

	my $texttype = ""; my $revision = "";
	my $donelog = 0; my $donetext = 0;

	# finally we reach the revision info
	while ($data = <INPUT>) {
		my $added = 0;
		my $deleted = 0;

		chomp ($data);

		next if (!$revision && $data =~ /^\s*$/);

		$revision = $data;

		$data = <INPUT>;
		if ($data =~ /^log/) {
			chomp ($data = <INPUT>);
			$data =~ s/^\@//;
			push @{$self->{revisions}->{$revision}->{log}}, log_unquote($data) if ($data =~ /./);
			while (chomp($data = <INPUT>)) {
				if ($data =~ /(|[^\@])\@$/) {
					$data =~ s/\@$//;
					push @{$self->{revisions}->{$revision}->{log}}, log_unquote($data) if ($data);
					last;
				}
				push @{$self->{revisions}->{$revision}->{log}}, log_unquote($data);
			}
		}

		$data = <INPUT>;
		if ($data =~ /^text/) {
			$data = <INPUT>;
			$data =~ s/^\@//;

			TEXT: while ($data) {
				chomp($data);

				if ($data =~ /(|[^\@])\@$/) {
					$data =~ s/\@$//;
					last TEXT;
				}

				if ($revision eq $self->{head}) {
					$data = <INPUT>;
					next TEXT;
				} elsif ($data =~ /^d\d+\s+(\d+)$/) {
					$deleted += $1;
				} elsif ($data =~ /^a\d+\s+(\d+)$/) {
					my $localadd = $1;
					$added += $localadd;
					for (my $i = 0; $i <$localadd; $i++) {
						$data = <INPUT>;
						redo TEXT if ($data =~ /(|[^\@])\@$/); # urk, spaghetti
					}
				}
				$data = <INPUT>;
			};

			if ($revision eq $self->{head}) {
				$revision = "";
				next;
			}

			# Due to the way that branches are managed, the head branch always lists
			# diffs relative to the child revision, while sub-branches always list them
			# relative to the current revision.  See the explanation above for more
			# details

			my ($diffrecip);

			if ($revision =~ /^\d+\.\d+$/) {
				$diffrecip = $self->child(revision => $revision);
				$self->{revisions}->{$diffrecip}->{linesadded} = $deleted;
				$self->{revisions}->{$diffrecip}->{linesdeleted} = $added;
			} else {
				$diffrecip = $revision;
				$self->{revisions}->{$diffrecip}->{linesadded} = $added;
				$self->{revisions}->{$diffrecip}->{linesdeleted} = $deleted;
			}

			$revision = "";
		}
	}

	close (INPUT);

	delete ($self->{parsing});
	$self->timestamp;
	$self->{parsed} = 1;

	1;
}

##
## diff
##

sub diff {
	my $self = shift;
	my %args = @_;
	my ($exitcode, $stdout, $stderr);

	$self->{err} = "";

	$self->parse || return undef;

	my $cmdargs = "";

	my %outputformat = (
		"context" => "-c",
		"unified" => "-u",
		"old" => "",
	);

	unless (defined $args{format}) {
		$args{format} = "old";
	}

	my $validformats = join('|', keys %outputformat);
	if ($args{format} =~ /^($validformats)$/i) {
		$cmdargs = $outputformat{lc($1)};
	} else {
		$cmdargs = $outputformat{"old"};
	}

	foreach my $rev ($args{revision1}, $args{revision2}) {
		next unless (defined ($rev));
		# We can either have a revision or a tag here
		unless (defined ($self->{revisions}->{$rev}) || 
			defined ($self->{symbols}->{$rev})) {
			$self->{err} = "invalid revision number / tag supplied";
			return undef;
		}

		$cmdargs .= " -r".shell_quote("$rev");
	}

	my $q = $self->{hpux} ? '' : '-q';
	my $command = "rcsdiff $q $cmdargs ".shell_quote($self->{rcsfile});

	($exitcode, $stdout, $stderr) = $self->pipestderrout(command => $command, dir => $self->{workdir});

	if ($exitcode > 1) {
		$self->{err} = join("\n", @{$stderr})."\n";
		return undef;
	}

	return $stdout;
}

##
## checkin
##

sub checkin {
	my $self = shift;
	my %args = @_;
	my $cmdargs = "";
	my ($exitcode, $stdout, $stderr);

	$self->{err} = "";

	$args{log} = "*** empty log message ***" unless (defined ($args{log}) && $args{log} =~ /\S/);

	$cmdargs .= "-m".shell_quote($args{log});

	# Added 'tag' argument to checkin so we can tag the revision checked in
	if ( defined $args{tag} ) {
		$cmdargs .= ( defined($args{force}) and istrue($args{force}) ) ? " -N" : " -n";
		$cmdargs .= shell_quote($args{tag});
	}

	my $lock = defined ($args{lock}) ? istrue ($args{lock}) : 0;
	my $checkout = (defined ($args{checkout}) || $lock) ? istrue ($args{checkout}) : 1;

	if ($lock) {
		$cmdargs .= " -l";
	} elsif ($checkout) {
		$cmdargs .= " -u";
	}

	if (defined ($args{revision})) {
		unless ($args{revision} =~ /^\d[\d\.]*\d$/) {
			$self->{err} = "incorrect revision format";
			return undef;
		}
		if (defined ($self->{revisions}->{$args{revision}})) {
			$self->{err} = "specified revision already exists";
			return undef;
		}
		$cmdargs .= " -r".shell_quote($args{revision});
	}

	my $command = "ci $cmdargs ".shell_quote($self->{rcsfile});

	($exitcode, $stdout, $stderr) = $self->pipestderrout(command => $command, dir => $self->{workdir});

	if ($exitcode > 0) {
		$self->{err} = join("\n", @{$stderr})."\n";
		return undef;
	}

	return 1;
}

##
## checkout
##

sub checkout {
	my $self = shift;
	my %args = @_;
	my $cmdargs = "";
	my ($exitcode, $stdout, $stderr);

	$self->{err} = "";

	$self->parse || return undef;

	$cmdargs .= " -l" if (defined ($args{lock}) && istrue ($args{lock}));

	# HP-UX co does not have -f option, so just delete the file
	if ( $self->{hpux} ) {
		if (defined($args{force}) and istrue($args{force})) {
			unlink "$self->{workdir}/$self->{file}";
		}
	} else {
		$cmdargs .= " -f" if (defined ($args{force}) && istrue ($args{force}));
	}

	if (defined ($args{revision})) {
		$self->rexists (revision => $args{revision}) || return undef;
		$cmdargs .= " -r".shell_quote($args{revision});
	}

	my $command = "co $cmdargs ".shell_quote($self->{rcsfile});

	($exitcode, $stdout, $stderr) = $self->pipestderrout(command => $command, dir => $self->{workdir});

	if ($exitcode > 0) {
		$self->{err} = join("\n", @{$stderr})."\n";
		return undef;
	}

	return 1;
}

##
## lock
##
## Locks the specified revision in the archive 
##
## parameters:
##	[revision]	the revision number to lock
##	[lock]		1 => lock, 0 => unlock [default: lock]
##

sub lock {
	my $self = shift;
	my %args = @_;
	
	my $cmdargs = "";
	my ($exitcode, $stdout, $stderr, $lockcmd);

	$self->{err} = "";

	$self->parse || return undef;

	if (defined ($args{lock})) {
		$lockcmd = istrue ($args{lock}) ? "l" : "u";
	} else {
		$lockcmd = "l";
	}

	$cmdargs .= " -$lockcmd";
	
	if (defined ($args{revision})) {
		$self->rexists (revision => $args{revision}) || return undef;
		$cmdargs .= shell_quote($args{revision});
	}

	my $command = "rcs $cmdargs ".shell_quote($self->{rcsfile});

	($exitcode, $stdout, $stderr) = $self->pipestderrout(command => $command, dir => $self->{workdir});

	if ($exitcode > 0) {
		$self->{err} = join("\n", @{$stderr})."\n";
		return undef;
	}

	return 1;
}

##
## unlock
##

sub unlock {
	my $self = shift;

	$self->lock (lock => 0, @_);
}

##
## initialize
##

sub initialize {
	my $self = shift;
	my %args = @_;

	my $cmdargs = "";
	my ($exitcode, $stdout, $stderr, $lockcmd);

	if ($self->archived) {
		$self->{err} = "RCS archive already exists";
		return undef;
	}

	$args{description} = "" unless (defined ($args{description}) && $args{description} =~ /\S/);

	$cmdargs .= " -kb" if ($args{binary});
	$cmdargs .= " -t-".shell_quote($args{description}) if ($args{description});

	my $command = "rcs -i $cmdargs ".shell_quote($self->{rcsfile});

	($exitcode, $stdout, $stderr) = $self->pipestderrout(command => $command, dir => $self->{workdir});

	if ($exitcode > 0) {
		$self->{err} = join("\n", @{$stderr})."\n";
		return undef;
	}

	return $self->parse;
}

##
## rexists
##

sub rexists {
	my $self = shift;
	my %args = @_;
	my $revision;

	$self->{err} = "";

	$self->parse || return undef;

	unless (defined ($args{revision})) {
		$self->{err} = "revision parameter not defined";
		return undef;
	}

	$revision = $self->symbol_lookup(symbol => $args{revision});

	unless (defined($self->{revisions})) {
		$self->{err} = "revision tree does not exist - RCS archive not yet set up";
		return undef;
	}

	if (defined ($self->{revisions}->{$revision})){
		return $revision;
	}

	$self->{err} = "revision not found in RCS archive";
	return undef;
}

##
## parent
##

sub parent {
	my $self = shift;
	my %args = @_;

	$self->{err} = "";

	$self->parse || return undef;

	my $revision = defined ($args{revision}) ? $self->symbol_lookup(symbol => $args{revision}) : $self->{head};

	$self->rexists (revision => $revision) || return undef;

	return $self->{revisions}->{$revision}->{parent};
}

##
## child
##

sub child {
	my $self = shift;
	my %args = @_;

	$self->{err} = "";

	$self->parse || return undef;

	my $revision = defined ($args{revision}) ? $self->symbol_lookup(symbol => $args{revision}) : $self->{head};

	$self->rexists (revision => $revision) || return undef;

	return $self->{revisions}->{$revision}->{child};
}

##
## revisions
##

sub revisions {
	my $self = shift;
	my %args = @_;

	# FIXME: we need to do something about branches here

	$self->{err} = "";

	$self->parse || return undef;

	my @array = keys (%{$self->{revisions}});

	\@array;
}

##
## symbols
##

sub symbols {
	my $self = shift;
	my %args = @_;

	$self->{err} = "";

	$self->parse || return undef;

	my @array = keys (%{$self->{symbols}});

	\@array;
}

##
## access
##

# Added access method to return access list of rcs file
sub access {
	my $self = shift;
	my %args = @_;

	$self->{err} = "";

	$self->parse || return undef;

	return unless exists $self->{access};

	my @array = @{$self->{access}} or return;

	\@array;
}

##
## description
##

sub description {
	my $self = shift;
	my %args = @_;

	$self->{err} = "";

	$self->parse || return undef;

	if ($args{description}) {
		my ($exitcode, $stdout, $stderr);
		my $cmdargs .= " -t-".shell_quote($args{description});
		my $command = "rcs -q $cmdargs ".shell_quote($self->{rcsfile});
		
		($exitcode, $stdout, $stderr) = $self->pipestderrout(command => $command, dir => $self->{workdir});
		
		if ($exitcode > 1) {
			$self->{err} = join("\n", @{$stderr})."\n";
			return undef;
		}
		$self->{desc} = $args{description};
	}

	return $self->{desc};
}

##
## AUTOLOAD
##

sub AUTOLOAD {
	my $self = shift;
	my ($method) = $AUTOLOAD;
	my %args = @_;
	my $revision;

	$method =~ s/^.*:://;

	($method =~ /^(access|locked|locker|state|author|date|log)$/) ||
		confess ("Can't locate object method \"$method\"");

	$method = "locker" if ($method eq "locked");

	$self->{err} = "";

	$self->parse || return undef;

	$revision = defined ($args{revision}) ? $self->symbol_lookup(symbol => $args{revision}) : $self->{head};

	$self->rexists (revision => $revision) || return undef;

	if (defined ($self->{revisions}->{$revision}->{$method})) {
		return $self->{revisions}->{$revision}->{$method};
	}

	return undef;
}

##
## DESTROY
##
## Some methods explicitly call DESTROY().  We need something to return
## success.
##

sub DESTROY {
	return;
}


##
## pipestderrout
##
## executes a command, trapping the output from both STDERR and STDOUT. This sort of thing is a 
## real pain in the ass in perl, and the simplest (but not the most efficient) way to do it is
## to simply use shell redirects to files and then slurp up the contents of these files.  The best 
## way to do it is probably to use IPC::Run which is unfortunately a pretty heavyweight package.
##
## this command should not be called from any user programs.  The API may change at any stage
## without warning.  Use at your own risk.  May bite if not handled carefully.
##
## returns:	an array containing the exit code and references to stdout and stderr respectively
##		undef if no command is issued, or if the temporary directory is unwritable,
##		putting flag in error buffer.
##

sub pipestderrout {
	my $self = shift;
	my %args = @_;
	my ($exitcode, $stdout, $stderr, $cwd);

	unless (defined ($args{command})) {
		$self->{err} = "must supply \"command\" argument";
		return undef;
	}

	my $tmpdir = defined ($self->{tmpdir}) ? $self->{tmpdir} : "/tmp";
	unless (-d $tmpdir && -r$tmpdir) {
		$self->{err} = "cannot write to tmpdir: \"$tmpdir\"";
		return undef;
	}

	my $tmpstdout = File::Temp::mktemp("$tmpdir/tempXXXXXX");
	my $tmpstderr = File::Temp::mktemp("$tmpdir/tempXXXXXX");

	if (defined ($args{dir})) {
		$cwd = cwd();
		# $cwd is tainted.  we need to untaint
		$cwd =~ m|^([/\w\-\._]+)$|;
		$cwd = $1;
		unless (chdir ($args{dir})) {
			$self->{err} = "cannot change to working directory";
			return undef;
		}
	}

	my $retval = system ("$args{command} < /dev/null 1> $tmpstdout 2> $tmpstderr");

	if (defined ($cwd)) {
		chdir ($cwd);
	}

	$exitcode = $retval >> 8;
	
	my @buf1 = ();
	open (INPUT, $tmpstdout);
	while (<INPUT>) {
		chomp;
		push @buf1, $_;
	}
	close (INPUT);
	unlink ($tmpstdout);
	$stdout = \@buf1;	

	my @buf2 = ();
	open (INPUT, $tmpstderr);
	while (<INPUT>) {
		chomp;
		push @buf2, $_;
	}
	close (INPUT);
	unlink ($tmpstderr);
	$stderr = \@buf2;

	return ($exitcode, $stdout, $stderr);
}


##
## symbol_lookup
##
## Looks up the parameter "symbol" in the RCS symbols table, and if found,
## returns the revision version of the symbol.  Otherwise, returns the
## original version of the "symbol" parameter.
##
## This function allow you do do things like:
##
## $args{revision} = $self->symbol_lookup(symbol => $args{revision});
##
## which allows the programmer to use rcs symbols everywhere instead of
## version numbers.
##

sub symbol_lookup {
        my $self = shift;
	my %args = @_;

	if (defined ($self->{symbols}->{$args{symbol}})) {
		return $self->{symbols}->{$args{symbol}};
	}

	return $args{symbol};
}


##
## log_unquote
##
## Converts from internal RCS quoted-log format to normal format
##

sub log_unquote {
	my $arg = shift;
	
	$arg =~ s/\@\@/\@/g;

	$arg;
}


##
## log_quote
##
## Converts from normal text format to internal RCS quoted-log format.
##

sub log_quote {
	my $arg = shift;
	
	$arg =~ s/\@/\@\@/g;

	$arg;
}


##
## true
##
## evaluates to one or zero, depending on the argument supplied 
##

sub istrue {
	my $arg = shift;
	
	if ($arg =~ /^(y|ye|yes|t|tr|tru|true|1)/i) {
		return 1;
	}
	
	return 0;
}

##
## usinghpux
##
## Setting this invokes some hackery elsewhere
## to get around crippled behaviour on HP's version of rcs
##

sub usinghpux {
  my $self = shift;
  $self->{hpux} = shift;
}