Changes since Pike 7.6.6
----------------------------------------------------------------------

Changes in Pike code:

o Fixed a cyclic resolver problem when running Pike with -V7.4
o Fixed #if constant so it doesn't rethrow a compilation error when
  #if constant failes to to compilation error.
o Better sslfile backward compatibility.
o Fix to prevent Regexp from throwing an error when PCRE isn't
  installed.
o Fixed pop() in ADT.Priority_queue.
o Fixes in Calendar.dwim_day for better accuracy.
o Major fixes and extensions of Parser.XML.Tree.
o Protocols.LMTP now displays correct error information.
o Content-type can now be set manually in Protocols.HTTP.Session.
o Protocols.LDAP now support paged searches. Fixed bugs related to
  dequoting and escaping values in filters.
o Fixed memory leak in Protocols.LysKOM.
o Fixed argument order in Remote.Client->provide.
o Fixed setting DES and DES3 keys.
o SSL now falls back to TLS 1.0 when accessed with SSL 3.2 (TLS 1.1).
o Fixed bug in decoding SSL2 hello messaged that caused incorrect
  padding of client challenges longer than 16 bytes. This caused some
  clients, typically based on OpenSSL, to fail to connect.
o Fixed an SSL bug that caused the session cache from working.
o Fixed an SSL bug where calls to the read callback could get lost
  when frequent switches between callback and non-callback mode
  occurs.
o Added EXIF kludge to handle broken FUJIFILM MakerNote.
o Fixed close in Stdio.FakeFile.
o Fixed Stdio.exist.
o Ensure that errno() is relevant if recurse_rm returns with an error.
o Fixed a type parser bug in Hilfe.
o rdf:ID and rdf:about now takes xml:base into account in Web.RDF.
o Fix for Protocols.DNS on MacOS X.

Changes in C code:

o Fixed bug in profiling support.
o Backend and UDP fixes for poll and AIX.
o Fixed bug in f_exit when called with multiple arguments.
o Fix for segmentation fault in random_string with negative argument.
o Added mprotect workaround.
o Avoid default usage of machine code on OpenBSD.
o Improved handling out-of-stack errors.
o find_external_context() now supports objects being destructed.
o Fixed copy_mapping_recursively().
o Fixed indices() and values() on objects to hide hidden items.
o rusage fix for system without 64 bit integer support.
o Fixes in create_process().
o Fixed memory leak when createing tuned boxed images.
o MMX no longer used for `* and `+ image object operators because of
  precision problems.
o New module: Kerberos
o Mysql module support Mysql 4.1.3.
o Bugfix in dbdate_cast() in the Oracle module.
o Several bugfixes in Shuffler.
o Added Stdio.Port()->bind_unix().
o Several bugfixes for rare array probles.
o Several cpp fixes to ensure that #if constant never interrupts
  compiliation. Use --show-all-cpp-warnings to see such failures.
o cpp expressions are now short-circuited.

Other chages:

o Several fixes in the Pike package generation to make them work with
  GNU tar 1.14.
o Preliminary support for local variable extraction in unbug.
o New installer system for Microsoft Windows.


Changes since Pike 7.4:
----------------------------------------------------------------------

New/improved functionality:
---------------------------

o 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.

o 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.)

o 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.

o --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.

o INT64
    On 64 bit architechtures Pike will now use full 64 bits integer
    before resorting to Gmp.mpz objects for large numbers.

o 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.

o 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.

o 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.

o 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.)

o 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.

o 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
    difference in speed between the new and the old function.

o 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.

o the debug trace system is more configurable
    In addition to the trace levels set by the trace function or by
    the command line argument -t, trace can now be turned on and off
    for the individual subsystems. All trace levels have also been
    increased by one to make room for gc only messages at level 1.

o unbug
    The Pike debugger unbug has been significtly optimized.

o Unicode
    Pike 7.6 uses the Unicode 4.0.1 tables for case info and
    normalization.

o upper_case() and lower_case() extended
    The built-in functions upper_case and lower_case now also works on
    single characters represented as integers.

o #warning
    A new The Pike preprocessor directive #warning has been added. It
    simply writes the rest of the line to stderr.


The Pike master:
----------------

o The new option --dumpversion prints out the Pike version in a more
  easily parsed way than --version.

o 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.

o 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.


Building and installing pike:
-----------------------------

o 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.

o 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.

o 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".


Changes and additions to -x utilities:
--------------------------------------

o 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.

o cgrep
    Context sensitive grep is very helpful when you are looking for
    substrings that are common. The implemented search modes are:
      o Complete token
      o Part of a token
      o Complete string literal
      o Part of a string literal
      o Part of a comment

    Example:
      $ cd Pike/7.6/src
      $ grep or * | wc -l
      18907
      $ pike -x cgrep -T or * | wc -l
      14

o 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.

o 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.

o monger
    A new utility to download, install and otherwise manage external
    modules from the Fresh Pike project (modules.gotpike.com).

o 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



New modules / classes / methods added:
--------------------------------------

o 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

o 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.

o 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.

o 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 );
      }

o 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.

o Bz2
    Support for the compression format used by the bzip2 program. The
    module interface is almost identical to that of the Gz module.

o 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.

o 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.

o 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.

o 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


o 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

o 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.

o 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);

o 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.

o 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.

o Geography
    The Geography.Position object can now also convert to and from the
    Swedish RT38 (Rikets Triangulering 1938) position format.

o 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();
      }

o 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.

o 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.

o 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.

o 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.

o 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.

o Protocols.HTTP.Session
    Handles an HTTP connection as a session, with cookies, redirects,
    HTTP keep-alive, etc.

o 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.

o 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.

o 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.

o 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.

o Standards.IDNA
    This module implements various algorithms specified by the
    Internationalizing Domain Names in Applications (IDNA) memo by the
    Internet Engineering Task Force (IETF), RFC 3490. Your most likely
    application of this will be the encoding and decoding of punycode:

      Standards.IDNA.zone_to_unicode("www.xn--rksmrgs-5wao1o.org"); 


o 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.

o 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;
     }  


Optimizations:
--------------

o Instantiation and destruction of pike classes is now significantly
  faster.

o Handling of bignums has been optimized, especially conversion
  to/from normal integers.

o String case conversion is now five times faster than before on
  average.


Compatibility changes:
----------------------

o Incompatible changes have been made 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.


Compatibility changes without backward compatibility:
-----------------------------------------------------

o 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.


C level/development changes:
----------------------------

o The security.h include file is renamed to pike_security.h

o 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.

o 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.

o The make file has a few new targets that should be self explanatory:
  gdb_hilfe, valgrind_hilfe and valgrind_verify.

o The header file module_magic.h is deprecated. Use the
  PIKE_MODULE_INIT and PIKE_MODULE_EXIT macros in your modules
  instead.

o The backend has a new interface to handle references from backend
  objects to callbacks in files.
