 | |
 | 
|
| This document outlines the changes since Pike 7.4.
|
|  | | |
|
 | fewer magical hacks
| | Several Pike modules have been cleaned up from old hacks and
workarounds for problems which now have proper solutions. This
should reduce size, and improve performance, dumpability and
readability of the affected code. In addition lots of internal
types in Pike have been tightened up and several more files now
use the pragma strict_types, which has helped locating and fixing
some previously undiscovered bugs.
| | garbage collection strategy is now configurable
| | The garbage collector can now be configured to take both the amount
of garbage and the cpu time spent in the gc into account. Automatic
garbage collections can also be disabled in critical regions. (Use
the function Pike.gc_parameters for this.)
| | hash() modified
| | The string hash functions are now byte-order independent. The old
hash function is available as hash_7_4 or as hash when running in
7.4 compatibility mode or lower.
| | --help
| | The Pike --help message has been improved, and it is possible to
retrieve further information about options and environment
variables. In addition, most of the tools and build scripts now
accept --help and describes what they do and what options they
take.
| | INT64
| | On 64 bit architechtures Pike will now use full 64 bits integer
before resorting to Gmp.mpz objects for large numbers.
| | IPv6
| | Networking code in Pike has been updated to work with IPv6. This
includes both low-level fixes in the socket handling as well as
high-level changes such as IP parsing and protocol additions such
as AAAA records in Protocol.DNS.
| | module system improved
| | Both dynamic and static modules now appears as objects, and they both
support having an identifier _module_value, which will then be
what is presented by the resolver as the module. _module_value can
be a constant, which will prevent the program from being automatically
cloned.
| | mysqls
| | The Mysql glue can operate over SSL, providing additional data
security. Use the "mysqls://" protocol in the Sql.Sql module to
access this feature.
| | reworked codec
| | The codec for serialization of Pike data types has been updated
and has a significally improved success rate at encoding modules.
(See the encode_value and decode_value functions.)
| | sort() is portable
| | Sort is now locale and platform independent. In other words,
strings are now compared only according to the unicode value of
every character.
| | sort() is stable
| | Unlike previous releases, sort() will keep the original order
of elements that are equal. At first, we considered keeping the old
sort function in parallel with the new one, as a "faster but
unstable" alternative, but it turned out that there was no noticable
different in speed between the new and the old function.
| | trace() can trace all threads
| | The configure option --without-thread-trace has been removed, but
instead the trace() function has been extended to make it possible
to set the trace level in all threads simultaneously.
| | unbug
| | The Pike debugger unbug has been significtly optimized.
| | Unicode
| | Pike 7.6 uses the Unicode 4.0.1 tables for case info and
normalization.
| | upper_case() and lower_case() extended
| | The built-in functions upper_case and lower_case now also works on
single characters represented as integers.
| | #warning
| | A new The Pike preprocessor directive #warning has been added. It
simply writes the rest of the line to stderr.
|
|
|  | | |
|
| The new option --dumpversion prints out the Pike version in a more
easily parsed way than --version. | | The master now supplies argv to the started application, so it can
use the create() method for execution. Some people find it a more
elegant solution than having a main function. | | The "-e" flag to Pike has been improved with a number of convenience
wrappers. When compiling code with "pike -e", the macro NOT(X) will
expand to !(X) and CHAR(X) to 'X', making it easier to solve quote
problems from a shell. If the return from a pike -e statement is a
positive integer it will be used as pikes exit code. If the return
value is a string it will be output (with a "\n" added, if the string
didn't already end in "\n"). Finally there is a predefined variable
env that contains the environment variables as a string:string mapping.
|
|
|  | | |
|
| To simplify the process of building Pike source distributions it is
now possible to bundle less common libraries such as Nettle with
Pike. The bundles, found in the "bundles" directory, will be compiled
and statically linked if no matching library is found on the system. | | The Pike build process no longer builds a bootstrap pike, used to
run various small programs to generate source files. This means that
in order to build Pike from CVS you need the latest major version of
Pike installed on your system. Pike source distributions contain
these generated files, and are not affected. | | By default, pike want to build a documentation source file, i.e.
"make && make doc && make install". This makes it
possible for third
party modules to integrate its documentation into the system Pike
documentation. If you do not want to build a documentation source
file, use "make install_nodoc" instead of "make install". |
|
|  | | |
| | benchmark
| | A set of benchmarks is available in the benchmark tool. They are
based on the Great Computer Language Shootout, but have been
modified to make more sense in the context of Pike, and to test
various aspects of Pike we suspect (or at least at one time
suspected) to have bad performance.
|
| cgrep
| | Context sensitive grep is very helpful when you are looking for
substrings that are common. The implemented search modes are:
| Complete token | | Part of a token | | Complete string literal | | Part of a string literal | | Part of a comment |
Example:
$ cd Pike/7.6/src
$ grep or * | wc -l
18907
$ pike -x cgrep -T or * | wc -l
14
| | dump
| | Dumps Pike .pike and .pmod module files to precompiled .o files
for shorter load times. Previously available as
src/dumpmodule.pike in the Pike source tree, but moved into the
Pike builtin tools to facilitate dumping of external modules.
| | extract_locale
| | Locale extractor utility used to extract localizable strings from
an application into an xml format, to later be used by the Locale
module.
| | monger
| | A new utility to download, install and otherwise manage external
modules from the Fresh Pike project (modules.gotpike.com).
| | rsif
| | rsif can now work recursively in a file structure if given the
flag -r or --recursive. Example:
pike -x rsif -r 7.4 7.6
|
|
|  | | |
|
| ADT.BitBuffer
| | When operating on data formats that are defined on bit level, the
ADT.BitBuffer presents a convenient interface. It operates as a
FIFO buffer on bit level, which allows you to read and write bits
and bytes.
> ADT.BitBuffer b=ADT.BitBuffer();
> b->put1(2);
(1) Result: ADT.BitBuffer(11)
> b->put0(15);
(2) Result: ADT.BitBuffer("À\0"0)
> b->drain();
(3) Result: "À\0"
> sizeof(b);
(4) Result: 1
| | ADT.CircularList
| | This is an circular list implemented as a C wrapper around an
array. It has a constant time complexity for pop and push. It has
a limited max size but it can be increased manually by calling the
allocate() method. It supports pushing, popping and peeking at both
ends of the list, as well as removing and insering elements at any
position in the list.
| | ADT.Sequence
| | The sequence work similar to an array but has the ability to
insert and remove elements at any position. It also has functions
to retrieve iterators for forward and backward iteration over the
elements in the sequence.
| | ADT.Struct
| | This module makes it possible to work with binary formats of the
"packed struct" type. Simply create a class inheriting ADT.Struct,
specify its members in order, create an object with a file object
as argument, and then read the decoded values from the object as
ordinary variables. An example, reading ID3 metadata headers from
an MP3 file:
class ID3 {
inherit ADT.Struct;
Item head = Chars(3);
Item title = Chars(30);
Item artist = Chars(30);
Item album = Chars(30);
Item year = Chars(4);
Item comment = Chars(30);
Item genre = Byte();
}
Stdio.File f = Stdio.File("foo.mp3");
f->seek(-128);
ADT.Struct tag = ID3(f);
if(tag->head=="TAG") {
write("Title: %s\n", tag->title);
tag->title = "A new title" + "\0"*19;
f->seek(-128);
f->write( (string)tag );
}
| | Array
| | The Array module has been extended with Array.all and Array.any
which determine if all or any of the elements in an array meet a
given condition. The function Array.partition has also been added,
which divides the elements of an array into two arrays, selected
according to a given condition.
| | Bz2
| | Support for the compression format used by the bzip2 program. The
module interface is almost identical to that of the Gz module.
| | Calendar module
| | The %S format was added to Calendar.parse() to parse seconds since
the Epoch. The TimeRange class is extended with a format method
format_commonlog(), a tzname_utc_offset (+HHMM) and
tzname_location(), which, when available, returns zone names like
"Europe/Stockholm". The database has been updated with Swedish
pre-1901 namedays and Finnish namedays.
| | Crypto/Nettle
| | The crypto module has been almost completely rewritten, and now
uses libnettle as backend instead of the built-in crypto
algorithms that Pike had before. This way Pike will benefit from
the more active development and optimization work in the Nettle
project. The most common hash and cipher methods are already
written in assembler for several platforms. As an example SHA1 is
about 40% faster than before on Intel platforms.
|
| With the new nettle support comes support for two new cipher
algorithms, Blowfish and Serpent, and the new NIST hash algorithm
SHA256. Note that the new Crypto module has renamed its
identifiers to be consistent with the rest of Pike, and in some
cases to clarify or correct bad names. The old names still work,
but produce a warning unless Pike is run in compatibility mode.
Compatibility outside compatibility mode will be removed in the
future.
|
| The interfaces for the hash and cipher algorithms have been
improved, and no longer only conform to predefined interfaces,
but actually inherits Hash/HashState and Cipher/CipherState. Every
algorithm is in itself a module in the Crypto module, and inherits
the Hash/Cipher class. This module contains instance non-specific
methods such as digest_size or key_size. By calling the `() method
in the module a HashState/CipherState object is returned, which is
a hash/cipher instance which can be used for streaming operations.
|
| Examples:
Crypto.MD5.hash("Hash this string");
Crypto.MD5()->update("Hash this ")->update("string")->digest();
The confusing and hard-to-use Crypto.randomness has been obsoleted
by the Nettle implementation of the Yarrow random generator. The
Nettle implementation of Yarrow uses AES and SHA256. The
Crypto.Random module acts as a frontend before system crypto
sources, and ensure that almost no matter how bad your OS is, you
will still get cryptographically strong random data.
| | Crypto.PGP
| | The start of a PGP/GPG toolkit. It still cannot handle all types
of signatures nor generate any, but it is useful to verify
selfsigned code and data.
| | Debug.Wrapper
| | A simple litte wrapper that can be placed around another object to
get printouts about what is happening to it. Only a few LFUNs are
currently supported.
> object x=Debug.Wrapper(Crypto.MD5());
Debug.Wrapper is proxying ___Nettle.MD5_State()
> x->name();
___Nettle.MD5_State()->name
(1) Result: "md5"
> !x;
!___Nettle.MD5_State()
(2) Result: 0
|
| Error
| | The root of the Pike exception hiearchy. Even though it is work
in progress, it is already usable.
> mixed err = catch( 1/0 );
> err;
(1) Result: Error.Math("Division by zero.\n")
> object_program(err)==Error.Math;
(2) Result: 1
|
| EXIF
| | The EXIF module is now much more robust than before, and can handle
some of the erroneous EXIF tags some cameras procduce. Extended
support for Nikon cameras.
| | Filesystem.Traversion
| | The Filesystem.Traversion iterator is a handy way to descend into
a directory structure (depth first) and perform actions on all or
some of the files.
|
| Example:
foreach(Filesystem.Traversion("."); string dir; string file)
if(file[-1]=='~' || file=="core") rm(dir+file);
| | Float
| | Here constants and functions that deal specifically with the
float data type is stored. Currently, it only contains various
constants that describe the precision and limitations of the float
type with which Pike was compiled.
| | Function
| | The Function module has been extended with the fixpoint combinator
"Y", useful when writing recursive lambdas, a curry function, to
partially evaluate a function call, and a callback caller function
that protects the caller from exceptions in the callback function.
|
| Geography
| | The Geography.Position object can now also convert to and from the
Swedish RT38 (Rikets Triangulering 1938) position format.
| | GLUE
| | The GL Universal Environment is a GL toolkit that makes
implementing GL applications in Pike really simple. GLUE has
several orthogonal components like object oriented encapsulation
of GL, drawing primitives, texture handling and text generation.
The most fundamental part is however an abstract interface to a
GL area driver, like GTK or SDL.
int main() {
GLUE.init();
draw_frame();
return -1;
}
void draw_frame() {
call_out(draw_frame, 0.02); // 1/(50 fps)
do_gl_code();
GLUE.swap_buffers();
}
|
| Image.NEO
| | Support for one of the major image formats on Atari ST/STE,
including decoding of color cycling. The C bitmap and palette
handler can be used to implement other atari image formats.
| | Int
| | The Int module contains a few functions and constants that deal
specifically with the integer data type. Currently it contains
parity and byte swapping functions, and constants for the system
maxint and minint.
| | Pike.Security
| | Functions and classes that deal with the Pike security system
(requires Pike to be compiled with --with-security to be present)
are stored in this module. Beware that the Pike security system is
still very experimental.
| | Process.Process
| | The Process.Process class is extended to handle a time-out
callback and a read callback, to make it easier to manage
processes in an asynchronous way.
| | Protocols.Bittorrent
| | This is a Pike implementation of the client side of the popular
Bittorrent protocol. Both creating torrent files and seeding as
well as downloading and verifying files are supported. There are
also several functions to retreive auxillary information such as
identifying the other peer clients.
| | Protocols.HTTP.Session
| | Handles an HTTP connection as a session, with cookies, redirects,
HTTP keep-alive, etc.
| | Protocols.LMTP/Protocols.SMTP
| | Protocols.LMTP implements a server for the Local Mail Transfer
Protocol, LMTP, as specified in RFC2033. This module has been well
tested against Postfix clients. Protocols.LMTP is based on a new
server implementation in Protocols.SMTP.
| | Protocols.OBEX
| | An implementation of the IrDA(R) Object Exchange Protocol. OBEX is
a protocol for sending and receiving binary objects to mobile
devices using transports such as IR and Bluetooth.
| | Regexp.PCRE added to give libpcre support
| | Are you a closet perler? For those who missed the richer flora of
regexp syntax that Perl supports, the Perl Compatible Regular
Expression module is the answer. If you compile libpcre with UTF-8
support you will also get transparent wide string support. Several
convenience functions are also added to the Regexp module to
enable easier access to regular expressions.
| | SSL
| | Large parts of the SSL module have been rewritten, either as part
of the rewrite of the Crypto module or in an attempt to fix various
issues regarding blocking/nonblocking files, threads, etc.
| | Standards.IDNA
| | Internet Engineering Task Force (IETF), RFC 3490. Your most likely
application of this will be the encoding and decoding of punycode.
Example:
Standards.IDNA.zone_to_unicode("www.xn--rksmrgs-5wao1o.org");
| | Thread
| | Thread.Fifo and Thread.Queue have been extended with try_*
varieties of all functions that can block, and with functions that
make them both implement the same interface. Both also have
fallbacks for running in nonthreaded mode.
| | Web.RDF/RDFS/OWL/RSS
| | Pike now has support for the W3C semantic web formats OWL, RDF
and RDFS, which are used for expressing structure and metadata
information. There is also some support for the syndication
format RSS (which happens to be a simple application of RDF).
|
| This sample program reads an OWL file, parses the dataset
contained in it, and then lists the data classes in that
dataset:
int main(int argc, array argv)
{
object owlset = Web.OWL();
string input = Stdio.read_file(argv[1]);
owlset->parse_owl(input);
write("Classes:\n");
foreach(owlset->find_statements(0,
owlset->rdf_type,
owlset->owl_Class);
array statement)
write("- %O\n", statement[0]);
return 0;
}
|
|
|  | | |
|
| Instantiation and destruction of pike classes is now significantly
faster. | | Handling of bignums has been optimized, especially conversion
to/from normal integers. | | String case conversion is now five times faster than before on
average. |
|
|  | | |
|
| Incompatible changes have been in ADT.Heap, Array.diff3_old,
Crypto, Locale.Charset, Protocols.SMTP, SSL, Sql.sql,
Standards.ASN1, Standards.PKCS, Stdio.File, Thread.Mutex and
rusage(). Please refer to the 7.4 namespace in the compatibility
section of the documentation for a complete description of these
changes. Using #pike 7.4 or starting Pike with -V7.4 activates the
compatibility layer, which should make it possible to run old code
with newer pikes. |
|
|  | | |
|
| Module ABI changed
| | The pike_frame struct has a new member, which makes modules compiled
with Pike 7.4, and earlier versions of Pike, incompatible with
Pike 7.6.
|
|
|  | | |
|
| The security.h include file is renamed to pike_security.h | | The testsuite has three new, handy macros: cond_resolv,
test_program_eq and test_program_equal, all defined in mktestsuite. A
testsuite test that produces a warning, unless it is a test_warning
test, will now be considered an error. The test program can now run
testsuites in forked processes. By default every testsuite file will
now be run in a forked process. If a directory named extra_tests
exists on the top level of the Pike source directory, that directory
will also be recursed for testsuite.in files. | | The cmod API has been extended in many details, making it easier to
work with. Variable declarations may now use the object(programname)
syntax. Void in parameters may be 0. Varargs and optional arguments
are now typechecked properly. It is possible to INHERIT a program
into a PIKECLASS. It is possible to set attributes on a PIKEVAR. A
program may be flagged as a prototype, which will make the function
bodies to be ignored. It is also possible to set program flags, such
as PROGRAM_DESTRUCT_IMMEDIATE. See bin/precompile.pike for
documentation. | | The make file has a few new targets that should be self explanatory:
gdb_hilfe, valgrind_hilfe and valgrind_verify. | | The header file module_magic.h is deprecated. Use the
PIKE_MODULE_INIT and PIKE_MODULE_EXIT macros in your modules
instead. | | The backend has a new interface to handle references from backend
objects to callbacks in files. |
|
| | | |
