o Added new syntax that can be used to return the current object as if
it was a class it is inheriting
The syntax is X::this, where X is the inherited class.
The returned object will not include any symbols not available in
the class X, but your overloaded methods (and other identifiers)
will be the ones returned when the object is indexed.

o Added new syntax for literal-string constats
#{, #( and #[ starts a literal string, and it is ended by the
corresponding end marker: #}, #) and #] respectively.
No character is modified at all inside the literal string, including
newlines, \ " and '.
So, the string #["\n\'##] will be equivalent to "\"\\n\\'#".
The main usecase is to write code in code:
| string code = #[
| void main(int c, array v) {
| string x = "";
| foreach( v[1..], string elm )
| x += reverse(elm)+",";
| write("Testing: %s\n", reverse( x ));
| #];
The three different start/end markers might be useful if you write
code in code in code, since there is no way to quote the start/end
markers.

o Added a shorthand syntax for integer rages: xbit, where x is a
number between 1 and 31. This can be used as an example to indicate
that a string is 8 bits wide only: string(8bit)
This is equivalent to the range (0..255) but can be easier to parse.
Similarily int(1bit) is an alias for 'bool', and int(12bit) is
the same as int(0..4095).

This makes the ‘##’ token paste operator have a special meaning
when placed between a comma and a variable argument. If you write
| #define err(format, ...) f(debug)werror("ERROR: "+format, ##__VA_ARGS__)

and the variable argument is left out when the err macro is used,
then the comma before the ‘##’ will be deleted. This does not
happen if you pass an empty argument, nor does it happen if the
token preceding ‘##’ is anything other than a comma.

o Dependency declarations
It is now possible to use the CPP directive #require to specify a
condition that must be true for the file to be seen by the resolver.
This would typically be the inherited C part of a module or a system
call.
| #require constant(__WebKit)
| inherit __WebKit;

o Svalue type/subtype setting changed
This halves the number of instructions used to push a value on the
stack in most cases.
The speedup is not large, but noticeable.
o And on a related note, we now lie to the compiler about the
const:ness of the Pike_interpreter_pointer variable.
This significantly simplifies the code generated by the C-compiler
for stack manipulation functions, the stack pointer is now only
loaded once per code block, instead of once per stack operation.
This saves a lot of code when using the stack multiple times in a
function, and should be safe enough, albeit somewhat unconventional.
If nothing else the binary size shrunk by about 5%.

+ Demacroified some code, resulting in smaller code-size
This makes things faster, it is often better to branch to a small
block of code than to have it inlined in a lot of different
locations on modern architectures.

o decode_value can no longer decode programs using the 'old style'
program encoding.
Since the format has been deprecated since feb 2003, and those
programs could not be decoded anyway due to other issues it is not
much of a loss.

An important and useful side-effect of this class is that the
process will start to respond to kill -QUIT by printing a lot of
debug information to stderr, including memory usage, and if pike is
compiled with profiling, the CPU used since the last time kill -QUIT
was called.

APIs useful to simplify serialization and deserialization of
objects Mainly it allows you to easily iterate over the object
variables, including the private ones.
+ Serializer.Encodable
A class that can be inherit to make an object easily serializable
using encode_value.

This module is intended to be used for incremental scanning of a
filesystem.
Supports FSEvents on MacOS X and Inotify on Linux to provide low
overhead monitoring; other systems currently use a less efficient
polling approach.

This class provides some abstractions on top of an SQL table.
At the core it is generic for any SQL database, but the current
implementation is MySQL specific on some points, notably the
semantics of AUTO_INCREMENT, the quoting method, knowledge about
column types, and some conversion functions. Hence the location in
the Mysql module.

This is a parser for line oriented data that is either comma,
semi-colon or tab separated. It extends the functionality
of the Parser.Tabular with some specific functionality related
to a header and record oriented parsing of huge datasets.

ZXID is a library that implements SAML 2.0, Liberty ID-WSF 2.0
and XACML 2.0.
This module implements a wrapper for ZXID. The interface is similar
to the C one, but using generally accepted Pike syntax.

This module contains special values used by various modules, e.g.
a Val.null value used both by Sql and Standards.JSON.
In many ways these values should be considered constant, but it is
possible for a program to replace them with extended versions,
provided they don't break the behavior of the base classes defined
here. Since there is no good mechanism to handle such extending in
several steps, pike libraries should preferably ensure that the
base classes defined here provide required functionality directly.

It implements a Stdio.File like API, including support for the same
iterator API that Stdio.File has, allowing for convenient line
iterations over BZ2 compressed files.
| foreach( Bz2.File("log.bz2")->line_iterator(); int n; string line )

It is possible to add sprintf-formatted data to a String.Buffer
object by calling the sprintf() method. This function works just as
the normal sprintf(), but writes to the buffer instead.
The new method addat() allows for writing into the buffer at any
position.

Low-level wrapper for struct tm.
This can be used to do (very) simple calendar operations. It is,
as it stands, not 100% correct unless the local time is set to
GMT, and does mirror functionality already available in gmtime()
and localtime() and friends, but in a (perhaps) easier to use API.

Pretty-print debug information, useful to get debug information
about object counts and memory usage in pike applications.
Uses the new _object_size lfun, if present in objects, to account
for RAM-usage in C-objects that allocate their own memory.

The function calculates the Levenshtein distance between two
strings. The Levenshtein distance describes the minimum number of
edit operations (insert, delete or substitute a character) to get
from one string to the other.
This can be used in approximate string matching to find matches
for a short string in many longer texts, when a small number of
differences is expected.

The glob function has been extended to accept an array of globs as
the first (glob pattern) argument.
In this case, if any of the given patterns match the function will
return true, or, if the second argument is also an array, all
entries that match any glob in the first array.

o Added client and server support for TCP_FASTCONNECT
To connect using this TCP extension simply pass the data as the
fifth argument to connect.
The server support is automatically enabled if possible when a
Stdio.Port object is bound to a port.

These functions can be used to send and receive an open
file-descriptor over another file-descriptor. The functions are
only available on some systems, and they generally only work
when the file the descriptors are sent over is a UNIX domain
socket or a pipe.

+ Added support for padded blobs. This improves performance when
incrementally growing blobs. This feature is only enabled if
Search.Process.Compactor says this is OK, see the documentation
for more information.
+ Several locking optimizations, specifically, avoid locking and
unlocking for every single iteration when merging and syncing
blobs.
+ Charset conversion fixes
+ Fixes for queries where the same world occur multiple times
('foo and bar and foo')

If your main process is large, this is significantly faster than
using the normal create_process, and does not risk running out of
memory for the forked (temporary) copy of the main process that is
created.

+ Support OS/2 path conventions
+ Fixed multiple issues with search_path()/locate_binary()
- locate_binary() is now more reliable on Windows
- Now invalidates the cached path is PATH is changed
- Uses locate_binary to scan the path
- spawn_pike() now uses search_path()
+ You can now optionally have System.spawn_pike pass predefines,
program and include path to the spawned pike, in addition to the
module path.

o Multiple threads can now call the Backend `() function (the function
that waits for events).
The first thread will be the controlling thread, and all callbacks
will be called in it, the other threads will wake when the
controlling thread is done.

o Standards.JSON.encode can now get the initial indentation level
specified.
This is rather useful for recursive calls encode in pretty print
mode (common for objects with encode_json methods).
o Added Pike.identify_cycle(x)
Checks to see if x contains any circular structures.
This can be useful while optimizing to identify reference cycles in
Pike data structures, so that the need for garbage collection can be
reduced.
o Most math functions (log, pow, exp sin, cos etc) can now take
integers as arguments in addition to a floating point number.
The result will still be a float, the argument will be converted.

o The random(), random_string() and random_seed() might be more random
On computers with a hardware pseudo random generator random() can
return significantly more random numbers, however, this means that
random_seed is a no-op on those machines.
A side-effect of this is that random_string is now actually
significantly faster on at least x86 cpu:s with rdrnd.
Note: If you want cryptographically random data please use
Crypto.Random.random_string unless you know for sure the random data
returned by the RDRND instruction is random enough.

o Crypto.SALSA20 and Crypto.SALSA20R12
The 128/256 bit cipher SALSA20 is now available as a stream cipher
in Crypto. SALSA20R12 is SALSA20 reduced to just 12 rounds.
o Crypto.SHA3_224, Crypto.SHA3_256, Crypto.SHA3_384 and Crypto.SHA3_512
The SHA-3 secure hash algorithm has been added in multiple variants.

o Crypto.GOST94 and RIPEMD160
The lesser used hash functions GOST R 34.11-94 (RFC 4357) and
RIPEMD160 have been added.
o Crypto.RSA and Crypto.DSA
The key generation for RSA and DSA are now done by Nettle. This

now a single make_selfsigned_certificate() method for both RSA and
DSA, though it takes the same arguments. In addition a hash function
and serial number can be supplied. The hash function defaults to
SHA-2-256.

Incompatible C-level API changes
--------------------------------
o New svalue layout
The most obvious change is that the macros TYPEOF() and SUBTYPEOF()
are now actually needed to directly access the type and subtype of
an svalue, the svalues no have 'type' and 'subtype' members.
There are also a few additional macros used to set both the type and
subtype of an svalue at the same time:
SVAL_SET_TYPE_SUBTYPE(sval,type,subtype) and
SVAL_SET_TYPE_DC(sval,type)
(these are only neede if you do not use the usual push_* macros)
They are useful because they (usually) compiles to significantly
more compact code, especially if the type and subtype are
compiletime constants. The _DC variant will either leave the subtype
unchanged or set it to 0, useful when you do not care about the
actual subtype (which is, really, most of the time).
o get_storage() returns void*
There is no need for casts in non-C++ code.

This means that PMOD_EXPORT is now actually needed on systems like
Linux and MacOSX. It also means that the binary is slightly smaller
and faster.
o clang compilation fixes (bignum overflow checks, misc)

o foreach( arr[-two()..], string x), where two() returns 2 will no
longer iterate over the first element in the array three times or
crash.
o Fixed a typo from 2001-05-05 that caused a lot of countries to
recide on the continent ',Europa' instead of "Europa" in
Geography.Countries.
Obviously the continent is not that often checked.
o Fixed interresting bug in the constant number parsing for octal
numbers in escapes.
For whatever reason 8:s were accepted for every location except the
first in octal numbers, so 078 was considered an alias for 0100.
This could cause issues at times, and will result in string parsing
being somewhat different:
| Pike v7.8 release 700 running Hilfe v3.5 (Incremental Pike Frontend)
| > "\078";
| (1) Result: "@"
| Pike v8.0 release 3 running Hilfe v3.5 (Incremental Pike Frontend)
| > "\078";
| (1) Result: "\a8"