path: root/Changes

Changes to perl
---------------

Apart from little bug fixes, here are the new features:

Perl can now handle binary data correctly and has functions to pack and
unpack binary structures into arrays or lists.  You can now do arbitrary
ioctl functions.

You can do i/o with sockets and select.

You can now write packages with their own namespace.

You can now pass things to subroutines by reference.

The debugger now has hooks in the perl parser so it doesn't get confused.
The debugger won't interfere with stdin and stdout.  New debugger commands:
	n		Single step around subroutine call.
	l min+incr	List incr+1 lines starting at min.
	l		List incr+1 more lines.
	l subname	List subroutine.
	b subname	Set breakpoint at first line of subroutine.
	S		List subroutine names.
	D		Delete all breakpoints.
	A		List line actions.
	< command	Define command before prompt.
	> command	Define command after prompt.
	! number	Redo command (default previous command).
	! -number	Redo numberth to last command.
	h -number	Display last number commands (default all).
	p expr		Same as \"print DBout expr\".

The rules are more consistent about where parens are needed and
where they are not.  In particular, unary operators and list operators now
behave like functions if they're called like functions.

There are some new quoting mechanisms:
	$foo = q/"'"'"'"'"'"'"/;
	$foo = qq/"'"''$bar"''/;
	$foo = q(hi there);
	$foo = <<'EOF' x 10;
	Why, it's the old here-is mechanism!
	EOF

You can now work with array slices (note the initial @):
	@foo[1,2,3];
	@foo{'Sun','Mon','Tue','Wed','Thu','Fri','Sat'} = (1,2,3,4,5,6,7);
	@foo{split} = (1,1,1,1,1,1,1);

There's now a range operator that works in array contexts:
	for (1..15) { ...
	@foo[3..5] = ('time','for','all');
	@foo{'Sun','Mon','Tue','Wed','Thu','Fri','Sat'} = 1..7;

You can now reference associative arrays as a whole:
	%abc = %def;
	%foo = ('Sun',1,'Mon',2,'Tue',3,'Wed',4,'Thu',5,'Fri',6,'Sat',7);

Associative arrays can now be bound to a dbm or ndbm file.  Perl automatically
caches references to the dbm file for you.

An array or associative array can now be assigned to as part of a list, if
it's the last thing in the list:
	($a,$b,@rest) = split;

An array or associative array may now appear in a local() list.
	local(%assoc);
	local(@foo) = @_;

Array values may now be interpolated into strings:
	`echo @ARGV`;
	print "first three = @list[0..2]\n";
	print "@ENV{keys(ENV)}";
	($" is used as the delimiter between array elements)

Array sizes may be interpolated into strings:
	print "The last element is $#foo.\n";

Array values may now be returned from subroutines, evals, and do blocks.

Lists of values in formats may now be arbitrary expressions, separated
by commas.

Subroutine names are now distinguished by prefixing with &.  You can call
subroutines without using do, and without passing any argument list at all:
	$foo = &min($a,$b,$c);
	$num = &myrand;

You can use the new -u switch to cause perl to dump core so that you can
run undump and produce a binary executable image.  Alternately you can
use the "dump" operator after initializing any variables and such.

Perl now optimizes splits that are assigned directly to an array, or
to a list with fewer elements than the split would produce, or that
split on a constant string.

Perl now optimizes on end matches such as /foo$/;

Perl now recognizes {n,m} in patterns to match preceding item at least n times
and no more than m times.  Also recognizes {n,} and {n} to match n or more
times, or exactly n times.  If { occurs in other than this context it is
still treated as a normal character.

Perl now optimizes "next" to avoid unnecessary longjmps and subroutine calls.

Perl now optimizes appended input: $_ .= <>;

Substitutions are faster if the substituted text is constant, especially
when substituting at the beginning of a string.  This plus the previous
optimization let you run down a file comparing multiple lines more
efficiently. (Basically the equivalents of sed's N and D are faster.)

Similarly, combinations of shifts and pushes on the same array are much
faster now--it doesn't copy all the pointers every time you shift (just
every n times, where n is approximately the length of the array plus 10,
more if you pre-extend the array), so you can use an array as a shift
register much more efficiently:
	push(@ary,shift(@ary));
or
	shift(@ary); push(@ary,<>);

The shift operator used inside subroutines now defaults to shifting
the @_ array.  You can still shift ARGV explicitly, of course.

The @_ array which is passed to subroutines is a local array, but the
elements of it are passed by reference now.  This means that if you
explicitly modify $_[0], you are actually modifying the first argument
to the routine.  Assignment to another location (such as the usual
local($foo) = @_ trick) causes a copy of the value, so this will not
affect most scripts.  However, if you've modified @_ values in the
subroutine you could be in for a surprise.  I don't believe most people
will find this a problem, and the long term efficiency gain is worth
a little confusion.

Perl now detects sequences of references to the same variable and builds
switch statements internally wherever reasonable.

The substr function can take offsets from the end of the string.

The substr function can be assigned to in order to change the interior of a
string in place.

The split function can return as part of the returned array any substrings
matched as part of the delimiter:
	split(/([-,])/, '1-10,20')
returns
	(1,'-',10,',',20)

If you specify a maximum number of fields to split, the truncation of
trailing null fields is disabled.

You can now chop lists.

Perl now uses /bin/csh to do filename globbing, if available.  This means
that filenames with spaces or other strangenesses work right.

Perl can now report multiple syntax errors with a single invocation.

Perl syntax errors now give two tokens of context where reasonable.

Perl will now report the possibility of a runaway multi-line string if
such a string ends on a line with a syntax error.

The assumed assignment in a while now works in the while modifier as
well as the while statement.

Perl can now warn you if you use numeric == on non-numeric string values.

New functions:
	mkdir and rmdir
	getppid
	getpgrp and setpgrp
	getpriority and setpriority
	chroot
	ioctl and fcntl
	flock
	readlink
	lstat
	rindex			- find last occurrence of substring
	pack and unpack		- turn structures into arrays and vice versa
	read			- just what you think
	warn			- like die, only not fatal
	dbmopen and dbmclose	- bind a dbm file to an associative array
	dump			- do core dump so you can undump
	reverse			- turns an array value end for end
        defined                 - does an object exist?
        undef                   - make an object not exist
	vec			- treat string as a vector of small integers
	fileno			- return the file descriptor for a handle
	wantarray		- was subroutine called in array context?
	opendir
	readdir
	telldir
	seekdir
	rewinddir
	closedir
	syscall
	socket
	bind
	connect
	listen
	accept
	shutdown
	socketpair
	getsockname
	getpeername
	getsockopt
	setsockopt
	getpwnam
	getpwuid
	getpwent
	setpwent
	endpwent
	getgrnam
	getgrgid
	getgrent
	setgrent
	endgrent
	gethostbyname
	gethostbyaddr
	gethostent
	sethostent
	endhostent
	getnetbyname
	getnetbyaddr
	getnetent
	setnetent
	endnetent
	getprotobyname
	getprotobynumber
	getprotoent
	setprotoent
	endprotoent
	getservbyname
	getservbyport
	getservent
	setservent
	endservent

Changes to s2p
--------------

In patterns, s2p now translates \{n,m\} correctly to {n,m}.

In patterns, s2p no longer removes backslashes in front of |.

In patterns, s2p now removes backslashes in front of [a-zA-Z0-9].

S2p now makes use of the location of perl as determined by Configure.


Changes to a2p
--------------

A2p can now accurately translate the "in" operator by using perl's new
"defined" operator.

A2p can now accurately translate the passing of arrays by reference.