o Unicode 3.2.0
All charts has been updated to Unicode 3.2.0. This applies both to
the Unicode module as well as Pike-global functionality such as
upper_case/lower_case. unicode_to_string() also has support for
surrogate and byteorder make handling.

o foreach(X; Y; Z)
The foreach statement has been extended to allow iterations over
mappings, multisets and any object that implements the iterator
interface (see below). To make it possible to use this
conveniently, a new syntax has been added to get both the index
and the value in each iteration:
foreach (something; index-expr; value-expr) ...
This iterates over something, assigning in turn each index to
index-expr and each value to value-expr. The index and value
expressions can be declarations or lvalues, and they can also be
left out if the index and/or value part isn't interesting.
Note that it depends on the data type whether the iteration order
is well defined or not; arrays and multisets are iterated over
starting with the first element while mappings are visited in some
arbitrary order (each element is still visited only once, though).
o Iterators
As noted above, an iterator interface has been added that is now
used in various places to iterate over different data structures.
Not only the built-in data types are supported, but actually any
object that fulfills the interface for iterators:
When iterating over an object o, o->_get_iterator() is called to
get an iterator object. It should at least have two functions
index() and value() to get the index and value at the current
position, a function `+=(int steps) to advance the current
position the specified number of steps, and a `!() that returns
zero if the position hasn't reached the end of the data set.
Also, if the object o lacks a _get_iterator function, it's assumed
to be an iterator itself. This makes it possible to pass an
iterator explicitly to e.g. the foreach statement.
The built-in data types also have iterator classes with this
interface. They are found as Array.Iterator, Mapping.Iterator, etc
and can be used to iterate over these data types in some custom
fashion. This is especially useful for mappings and multisets,
which cannot be iterated over directly in any other way. For
example, to get some arbitrary index in a mapping m:
mixed any_index = Mapping.Iterator(m)->index();

o Access to hidden variables in surrounding scopes.
Include the names of the surrounding classes themselves in the lookup for
Foo::, to make it possible to adress hidden variables in the scopes of
surrounding classes, e.g:

o ::_indices(), ::_values().
There are now two "magic" functions ::_indices() and ::_values()
that can be used by an object to list all identifiers and their
values in itself. They are primarily intended when the _indices()
and _values() lfuns have been defined, to get the default
implementations. This is to complement the "magic" ::`->() and
::`->=() functions that exist in earlier releases.

The following changes are known to break compatibility. The old
behaviour is emulated in the compatibility layer that is activated by
adding the preprocessor directive "#pike 7.2" to your program or by
giving the argument "-V7.2" to the pike executable.
o "global" has become a reserved keyword.
o Changed lookup rule for ::.
Previously the identifier in front of :: was only looked up among
the preceding inherits. Now the lookup additionally includes the
names of the surrounding classes. The inherits inside a class
still take precedence over the name of the class, though.
o Using local:: on variables is an error.
Previously the construct local::foo could be used to access the
identifier "foo" in the class scope if it had been overridden by
an argument or function variable. That is however only a
side-effect of the real use for local::, namely to bind the
identifier statically at that point only, to avoid getting an
overridden version. In the case of variables this leads to
questionable semantics, which is the reason it's been made an
error in this version. Pike 7.2 didn't implement it correctly;
there local:: on variables had only the effect to access the class
scope. Now a proper way to access hidden identifiers has been
added, so all such uses of local:: should be replaced with
this_program::.

o dirname
Now correctly returns a directory instead of just stripping the
part after nearest directory seprator.
o LR
LR has been moved to Parser.LR and the API has been chnged.
FIXME: More about this?