Mail Archives: cygwin/2001/01/12/02:20:05
--Message-Boundary-18202
Content-type: text/plain; charset=US-ASCII
Content-transfer-encoding: 7BIT
Content-description: Mail message body
Hello,
Its interesting that Ehud Karni posted a shell script for mount tables and a
request came in for suggestions about 'pushing Cygwin out' to many
machines. I have been thinking a bit about Cygwin setup since I installed
freshly three time over the year-end season, and each time the
configuration I wanted to end up with was somewhat different. I learned a
little more about Cygwin (still have a L O N G way to go).
logins are a funny thing -- users seem very specific and individualistic about
that and everybody seems to have a slightly different preference. So my
offering today might not be of much interest to the older users on this List,
who long since made up their own minds how to do what they like on login.
But newer users like I am might stumble across this message and I might
even be so bold as to propose that my contribution be made known and
available to them somehow.
As I see it the "PATH" problem is this: many people who use Cygwin are
developers and developers, more than ordinary users (is such a thing?)
often maintain multiple build environments (MinGW, Cygwin-DLL-based,
etc), add new tools, and may do all sorts of frequent changes. In order to
make such things easier there are diferent ways to go, I suppose. One could
umount and then re-mount to different points everything that one needs,
so that all the PATH-dependent processes unleashed by the hacker in a
typical working session find the right places. Another way is to re-adjust the
PATH list to point towards what one needs, precedence of course being of
the essence especially where there are multiple versions of executables
located in different branches on the filesystem.
Cygwin doesn't allow modification or unset on the PATH variable after
login, so it has to be set right from 'Doze before bash gets fired up, no? This
reality led me to concoct a little script to make setting up the PATH and
guaranteeing no unpleasant surprises a bit easier. Rather than repeatedly
typing in the needed SET commands every time before entering bash, I
have Perl do it (such a thing could probably be done another way using a
shell script but I am a Perl hacker .. not a `sed' wiz).
My script has a lot of points that one could single out and find a shortcoming
or debatable. I just offer it, I don't claim it's elegant or perfect.
One such point is that some may want there not to be a dependency on a
special Perl module that isn't part of standard core Perl and may need to be
installed via CPAN before this will work. That module is "Tie::IxHash" (G.
Sarathy, author) which allows one to employ the freak hybrid critter of a
Perl "order [precedence]-retaining hash" (a tie-ed 'IxHash') in one's
program. OTOH it's a simple install (no xs DLLs, simply copying the .pm file
to the right location will suffice in a pinch). I have decided to simply attach
the module to this message.
(PERL THEORY)This (use of such a module) is most desirable because the
use of a hash is a means of cleanly eliminating duplicate entries without
complex looping in one's script. At the same time, it is very good to be able
to preserve the order of the entries in $PATH so that precedence works in
one's favor.(/PERL THEORY)
Using this script one can "hard-code" paths which one needs to absolutely
be present first in the PATH, followed by paths that already exist in there
(like Windows/system[32]) and need to be retained -- but with no
duplication.
Another point which might irritate the picky user is that a short but
perceptible (on my system, maybe 1.5 sec) delay in accomplishing login is
introduced.
The script prints out to STDOUT a list of the resulting {Windows-style}
paths (and a user could want it to do more: to make a table showing both
the styles corresponding, that's maybe a TO-DO) and writes to a ".file.bat"
file (so named from the convention that a file beginning with a dot is a
system configuration file that is written to/read from by processes and
should be hidden most of the time) to accomplish the little trick of changing
the PATH from inside a process that then ends (Perl beginner FAQ: there is
no way [short of such hackery] to change the PATH from inside Perl so that
it remains changed after program exit ...).
In order to do this, this requires TWO scripts, not a single file: 1 .BAT script
which calls the perl and then reads-in the .file.bat after perl exists.
Script one ("cygwin.bat") follows:
----- script ---- watch for wrapping and low-flying owls ---
@ECHO OFF
D:\usr\local\bin\perl5.00503.exe D:\Cygwin\setpath.p
REM the next line sets the path from the file just written
REM by the Perl script above.
CALL D:\usr\.pathfix.bat
D:
SET CYGWIN=binmode tty ntea nontsec
@ECHO ON
\Cygwin\bin\bash --login -i
---- end script ----- cut here ---- use no hooks ----
Script two, the Perl script, follows:
---- start script -- watch for wrapping -----
#!D:\usr\local\bin\perl5.00503.exe -w # <-- user configuration
# Perl script "setpath.p"
# Copyright (c)2001 Soren Andersen <libertador AT flashmail DOT com>
# This is Free Software, it may be freely redistributed, modified,
# and copied, but this notice must be retained. NO warrantee,
# express or implied, is given; and the user assumes all risk from
# the use of this program.
use Tie::IxHash;
my ($HW, %Pash, $Pct, $Psep, @getP);
$HW = 'hardwired'; $Pct = 1;
chdir 'D:\\Cygwin'; # User conguration here and next several lines
my $ixH = tie( %Pash, Tie::IxHash,
q[D:\\Cygwin\\usr\\i686-pc-cygwin\\bin] => "$HW ". $Pct++,
q[D:\\usr\\local\\bin] => "$HW ". $Pct++,
q[D:\\Cygwin\\bin] => "$HW ". $Pct++,
);
die qq[\nFailure to tie IxHash: $!] unless $ixH;
if ($] =~m AT 5\.00503 AT i or $ENV{SHELL} =~m@/bin/sh/@) {
$Psep = ':';
@getP = map {my $wP = `bin/cygpath -paw $_`; $wP;}
split $Psep, qx'echo $PATH';
} else {
$Psep = ';';
@getP = split $Psep, $ENV{PATH};
}
for(@getP) {
chomp $_;
next if m@^\.$@; # Cygwin adds dot '.' to end anyway, don't duplicate.
$_ = ucfirst($_);
next if m AT D:\\ActivePerl\\bin\Z AT i; # user configuration req'd (*see bottom)
$Pash{$_} = $Pct++ unless not -d $_ or exists $Pash{$_};
}
print STDERR qq[\n\n],'_' x 16,' PATH VARIABLE ' ,'_' x 16, qq[\n\n];
open( BATF,q[> D:\\usr\\.pathfix.bat] ) or die $!; # user configuration req'd
print BATF qq[REM this file is generated automatically ],
qq[each time Cygwin.bat is run\nSET PATH=];
for (keys %Pash) {
if ($Pash{$_} =~m@^\d+$@) {
printf STDERR "%2u", $Pash{$_};
} else {
printf STDERR "%s", $Pash{$_};
}
printf STDERR "%s", qq[ ~ $_\n];
print BATF $_ , q[;];
}
print STDERR qq=The PATH has been adjusted for Cygwin use.\n=;
close(BATF);
__END__
Notes:
I think this script is mostly self-explanatory and anyway I am
too busy to write proper pod right now ;-). But a note about *:
The system setup I have is one in which several different
versions of Perl are present, and I usually have one (the
ActivePerl port) in use in my general 'Doze environment. But
I need to remove it so that my Cygwin Perl is found instead, so
the configuration of this script on MY system requires the use
of the regex to remove such a PATH item. Similarly, other users
(assuming adequate proficiency with perl regex's) could use the
marked section to 'filter out' any undesirable PATH entries
(as opposed to leaving them in but at low precedence).
---- end script ---- cut here ---- use no hooks -----
--Message-Boundary-18202
Content-type: text/plain; charset=US-ASCII
Content-disposition: inline
Content-description: Attachment information.
The following section of this message contains a file attachment
prepared for transmission using the Internet MIME message format.
If you are using Pegasus Mail, or any another MIME-compliant system,
you should be able to save it or view it from within your mailer.
If you cannot, please ask your system administrator for assistance.
---- File information -----------
File: IxHash.pm
Date: 20 Nov 1997, 16:59
Size: 13918 bytes.
Type: Text
--Message-Boundary-18202
Content-type: Application/Octet-stream; name="IxHash.pm"; type=Text
Content-disposition: attachment; filename="IxHash.pm"
#
# Tie/IxHash.pm
#
# Indexed hash implementation for Perl
#
# See below for documentation.
#
require 5.003;
package Tie::IxHash;
use integer;
require Tie::Hash;
@ISA = qw(Tie::Hash);
$VERSION = $VERSION = '1.21';
#
# standard tie functions
#
sub TIEHASH {
my($c) = shift;
my($s) = [];
$s->[0] = {}; # hashkey index
$s->[1] = []; # array of keys
$s->[2] = []; # array of data
$s->[3] = 0; # iter count
bless $s, $c;
$s->Push(@_) if @_;
return $s;
}
#sub DESTROY {} # costly if there's nothing to do
sub FETCH {
my($s, $k) = (shift, shift);
return exists( $s->[0]{$k} ) ? $s->[2][ $s->[0]{$k} ] : undef;
}
sub STORE {
my($s, $k, $v) = (shift, shift, shift);
if (exists $s->[0]{$k}) {
my($i) = $s->[0]{$k};
$s->[1][$i] = $k;
$s->[2][$i] = $v;
$s->[0]{$k} = $i;
}
else {
push(@{$s->[1]}, $k);
push(@{$s->[2]}, $v);
$s->[0]{$k} = $#{$s->[1]};
}
}
sub DELETE {
my($s, $k) = (shift, shift);
if (exists $s->[0]{$k}) {
my($i) = $s->[0]{$k};
for ($i+1..$#{$s->[1]}) { # reset higher elt indexes
$s->[0]{$s->[1][$_]}--; # timeconsuming, is there is better way?
}
delete $s->[0]{$k};
splice @{$s->[1]}, $i, 1;
return (splice(@{$s->[2]}, $i, 1))[0];
}
return undef;
}
sub EXISTS {
exists $_[0]->[0]{ $_[1] };
}
sub FIRSTKEY {
$_[0][3] = 0;
&NEXTKEY;
}
sub NEXTKEY {
return $_[0][1][$_[0][3]++] if ($_[0][3] <= $#{$_[0][1]});
return undef;
}
#
#
# class functions that provide additional capabilities
#
#
sub new { TIEHASH(@_) }
#
# add pairs to end of indexed hash
# note that if a supplied key exists, it will not be reordered
#
sub Push {
my($s) = shift;
while (@_) {
$s->STORE(shift, shift);
}
return scalar(@{$s->[1]});
}
sub Push2 {
my($s) = shift;
$s->Splice($#{$s->[1]}+1, 0, @_);
return scalar(@{$s->[1]});
}
#
# pop last k-v pair
#
sub Pop {
my($s) = shift;
my($k, $v, $i);
$k = pop(@{$s->[1]});
$v = pop(@{$s->[2]});
if (defined $k) {
delete $s->[0]{$k};
return ($k, $v);
}
return undef;
}
sub Pop2 {
return $_[0]->Splice(-1);
}
#
# shift
#
sub Shift {
my($s) = shift;
my($k, $v, $i);
$k = shift(@{$s->[1]});
$v = shift(@{$s->[2]});
if (defined $k) {
delete $s->[0]{$k};
for (keys %{$s->[0]}) {
$s->[0]{$_}--;
}
return ($k, $v);
}
return undef;
}
sub Shift2 {
return $_[0]->Splice(0, 1);
}
#
# unshift
# if a supplied key exists, it will not be reordered
#
sub Unshift {
my($s) = shift;
my($k, $v, @k, @v, $len, $i);
while (@_) {
($k, $v) = (shift, shift);
if (exists $s->[0]{$k}) {
$i = $s->[0]{$k};
$s->[1][$i] = $k;
$s->[2][$i] = $v;
$s->[0]{$k} = $i;
}
else {
push(@k, $k);
push(@v, $v);
$len++;
}
}
if (defined $len) {
for (keys %{$s->[0]}) {
$s->[0]{$_} += $len;
}
$i = 0;
for (@k) {
$s->[0]{$_} = $i++;
}
unshift(@{$s->[1]}, @k);
return unshift(@{$s->[2]}, @v);
}
return scalar(@{$s->[1]});
}
sub Unshift2 {
my($s) = shift;
$s->Splice(0,0,@_);
return scalar(@{$s->[1]});
}
#
# splice
#
# any existing hash key order is preserved. the value is replaced for
# such keys, and the new keys are spliced in the regular fashion.
#
# supports -ve offsets but only +ve lengths
#
# always assumes a 0 start offset
#
sub Splice {
my($s, $start, $len) = (shift, shift, shift);
my($k, $v, @k, @v, @r, $i, $siz);
my($end); # inclusive
# XXX inline this
($start, $end, $len) = $s->_lrange($start, $len);
if (defined $start) {
if ($len > 0) {
my(@k) = splice(@{$s->[1]}, $start, $len);
my(@v) = splice(@{$s->[2]}, $start, $len);
while (@k) {
$k = shift(@k);
delete $s->[0]{$k};
push(@r, $k, shift(@v));
}
for ($start..$#{$s->[1]}) {
$s->[0]{$s->[1][$_]} -= $len;
}
}
while (@_) {
($k, $v) = (shift, shift);
if (exists $s->[0]{$k}) {
# $s->STORE($k, $v);
$i = $s->[0]{$k};
$s->[1][$i] = $k;
$s->[2][$i] = $v;
$s->[0]{$k} = $i;
}
else {
push(@k, $k);
push(@v, $v);
$siz++;
}
}
if (defined $siz) {
for ($start..$#{$s->[1]}) {
$s->[0]{$s->[1][$_]} += $siz;
}
$i = $start;
for (@k) {
$s->[0]{$_} = $i++;
}
splice(@{$s->[1]}, $start, 0, @k);
splice(@{$s->[2]}, $start, 0, @v);
}
}
return @r;
}
#
# delete elements specified by key
# other elements higher than the one deleted "slide" down
#
sub Delete {
my($s) = shift;
for (@_) {
#
# XXX potential optimization: could do $s->DELETE only if $#_ < 4.
# otherwise, should reset all the hash indices in one loop
#
$s->DELETE($_);
}
}
#
# replace hash element at specified index
#
# if the optional key is not supplied the value at index will simply be
# replaced without affecting the order.
#
# if an element with the supplied key already exists, it will be deleted first.
#
# returns the key of replaced value if it succeeds.
#
sub Replace {
my($s) = shift;
my($i, $v, $k) = (shift, shift, shift);
if (defined $i and $i <= $#{$s->[1]} and $i >= 0) {
if (defined $k) {
delete $s->[0]{ $s->[1][$i] };
$s->DELETE($k) ; #if exists $s->[0]{$k};
$s->[1][$i] = $k;
$s->[2][$i] = $v;
$s->[0]{$k} = $i;
return $k;
}
else {
$s->[2][$i] = $v;
return $s->[1][$i];
}
}
return undef;
}
#
# Given an $start and $len, returns a legal start and end (where start <= end)
# for the current hash.
# Legal range is defined as 0 to $#s+1
# $len defaults to number of elts upto end of list
#
# 0 1 2 ...
# | X | X | X ... X | X | X |
# -2 -1 (no -0 alas)
# X's above are the elements
#
sub _lrange {
my($s) = shift;
my($offset, $len) = @_;
my($start, $end); # both inclusive
my($size) = $#{$s->[1]}+1;
return undef unless defined $offset;
if($offset < 0) {
$start = $offset + $size;
$start = 0 if $start < 0;
}
else {
($offset > $size) ? ($start = $size) : ($start = $offset);
}
if (defined $len) {
$len = -$len if $len < 0;
$len = $size - $start if $len > $size - $start;
}
else {
$len = $size - $start;
}
$end = $start + $len - 1;
return ($start, $end, $len);
}
#
# Return keys at supplied indices
# Returns all keys if no args.
#
sub Keys {
my($s) = shift;
return ( @_ == 1
? $s->[1][$_[0]]
: ( @_
? @{$s->[1]}[@_]
: @{$s->[1]} ) );
}
#
# Returns values at supplied indices
# Returns all values if no args.
#
sub Values {
my($s) = shift;
return ( @_ == 1
? $s->[2][$_[0]]
: ( @_
? @{$s->[2]}[@_]
: @{$s->[2]} ) );
}
#
# get indices of specified hash keys
#
sub Indices {
my($s) = shift;
return ( @_ == 1 ? $s->[0]{$_[0]} : @{$s->[0]}{@_} );
}
#
# number of k-v pairs in the ixhash
# note that this does not equal the highest index
# owing to preextended arrays
#
sub Length {
return scalar @{$_[0]->[1]};
}
#
# Reorder the hash in the supplied key order
#
# warning: any unsupplied keys will be lost from the hash
# any supplied keys that dont exist in the hash will be ignored
#
sub Reorder {
my($s) = shift;
my(@k, @v, %x, $i);
return unless @_;
$i = 0;
for (@_) {
if (exists $s->[0]{$_}) {
push(@k, $_);
push(@v, $s->[2][ $s->[0]{$_} ] );
$x{$_} = $i++;
}
}
$s->[1] = \@k;
$s->[2] = \@v;
$s->[0] = \%x;
return $s;
}
sub SortByKey {
my($s) = shift;
$s->Reorder(sort $s->Keys);
}
sub SortByValue {
my($s) = shift;
$s->Reorder(sort { $s->FETCH($a) cmp $s->FETCH($b) } $s->Keys)
}
1;
__END__
=head1 NAME
Tie::IxHash - ordered associative arrays for Perl
=head1 SYNOPSIS
# simple usage
use Tie::IxHash;
tie HASHVARIABLE, Tie::IxHash [, LIST];
# OO interface with more powerful features
use Tie::IxHash;
TIEOBJECT = Tie::IxHash->new( [LIST] );
TIEOBJECT->Splice( OFFSET [, LENGTH [, LIST]] );
TIEOBJECT->Push( LIST );
TIEOBJECT->Pop;
TIEOBJECT->Shift;
TIEOBJECT->Unshift( LIST );
TIEOBJECT->Keys( [LIST] );
TIEOBJECT->Values( [LIST] );
TIEOBJECT->Indices( LIST );
TIEOBJECT->Delete( [LIST] );
TIEOBJECT->Replace( OFFSET, VALUE, [KEY] );
TIEOBJECT->Reorder( LIST );
TIEOBJECT->SortByKey;
TIEOBJECT->SortByValue;
TIEOBJECT->Length;
=head1 DESCRIPTION
This Perl module implements Perl hashes that preserve the order in which the
hash elements were added. The order is not affected when values
corresponding to existing keys in the IxHash are changed. The elements can
also be set to any arbitrary supplied order. The familiar perl array
operations can also be performed on the IxHash.
=head2 Standard C<TIEHASH> Interface
The standard C<TIEHASH> mechanism is available. This interface is
recommended for simple uses, since the usage is exactly the same as
regular Perl hashes after the C<tie> is declared.
=head2 Object Interface
This module also provides an extended object-oriented interface that can be
used for more powerful operations with the IxHash. The following methods
are available:
=over 8
=item FETCH, STORE, DELETE, EXISTS
These standard C<TIEHASH> methods mandated by Perl can be used directly.
See the C<tie> entry in perlfunc(1) for details.
=item Push, Pop, Shift, Unshift, Splice
These additional methods resembling Perl functions are available for
operating on key-value pairs in the IxHash. The behavior is the same as the
corresponding perl functions, except when a supplied hash key already exists
in the hash. In that case, the existing value is updated but its order is
not affected. To unconditionally alter the order of a supplied key-value
pair, first C<DELETE> the IxHash element.
=item Keys
Returns an array of IxHash element keys corresponding to the list of supplied
indices. Returns an array of all the keys if called without arguments.
Note the return value is mostly only useful when used in a list context
(since perl will convert it to the number of elements in the array when
used in a scalar context, and that may not be very useful).
If a single argument is given, returns the single key corresponding to
the index. This is usable in either scalar or list context.
=item Values
Returns an array of IxHash element values corresponding to the list of supplied
indices. Returns an array of all the values if called without arguments.
Note the return value is mostly only useful when used in a list context
(since perl will convert it to the number of elements in the array when
used in a scalar context, and that may not be very useful).
If a single argument is given, returns the single value corresponding to
the index. This is usable in either scalar or list context.
=item Indices
Returns an array of indices corresponding to the supplied list of keys.
Note the return value is mostly only useful when used in a list context
(since perl will convert it to the number of elements in the array when
used in a scalar context, and that may not be very useful).
If a single argument is given, returns the single index corresponding to
the key. This is usable in either scalar or list context.
=item Delete
Removes elements with the supplied keys from the IxHash.
=item Replace
Substitutes the IxHash element at the specified index with the supplied
value-key pair. If a key is not supplied, simply substitutes the value at
index with the supplied value. If an element with the supplied key already
exists, it will be removed from the IxHash first.
=item Reorder
This method can be used to manipulate the internal order of the IxHash
elements by supplying a list of keys in the desired order. Note however,
that any IxHash elements whose keys are not in the list will be removed from
the IxHash.
=item Length
Returns the number of IxHash elements.
=item SortByKey
Reorders the IxHash elements by textual comparison of the keys.
=item SortByValue
Reorders the IxHash elements by textual comparison of the values.
=back
=head1 EXAMPLE
use Tie::IxHash;
# simple interface
$t = tie(%myhash, Tie::IxHash, 'a' => 1, 'b' => 2);
%myhash = (first => 1, second => 2, third => 3);
$myhash{fourth} = 4;
@keys = keys %myhash;
@values = values %myhash;
print("y") if exists $myhash{third};
# OO interface
$t = Tie::IxHash->new(first => 1, second => 2, third => 3);
$t->Push(fourth => 4); # same as $myhash{'fourth'} = 4;
($k, $v) = $t->Pop; # $k is 'fourth', $v is 4
$t->Unshift(neg => -1, zeroth => 0);
($k, $v) = $t->Shift; # $k is 'neg', $v is -1
@oneandtwo = $t->Splice(1, 2, foo => 100, bar => 101);
@keys = $t->Keys;
@values = $t->Values;
@indices = $t->Indices('foo', 'zeroth');
@itemkeys = $t->Keys(@indices);
@itemvals = $t->Values(@indices);
$t->Replace(2, 0.3, 'other');
$t->Delete('second', 'zeroth');
$len = $t->Length; # number of key-value pairs
$t->Reorder(reverse @keys);
$t->SortByKey;
$t->SortByValue;
=head1 BUGS
You cannot specify a negative length to C<Splice>. Negative indexes are OK,
though.
Indexing always begins at 0 (despite the current C<$[> setting) for
all the functions.
=head1 TODO
Addition of elements with keys that already exist to the end of the IxHash
must be controlled by a switch.
Provide C<TIEARRAY> interface when it stabilizes in Perl.
Rewrite using XSUBs for efficiency.
=head1 AUTHOR
Gurusamy Sarathy gsar AT umich DOT edu
Copyright (c) 1995 Gurusamy Sarathy. All rights reserved.
This program is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.
=head1 VERSION
Version 1.21 20 Nov 1997
=head1 SEE ALSO
perl(1)
=cut
--Message-Boundary-18202
Content-Type: text/plain; charset=us-ascii
--
Want to unsubscribe from this list?
Check out: http://cygwin.com/ml/#unsubscribe-simple
--Message-Boundary-18202--
- Raw text -