Changes since Pike 7.6:
----------------------------------------------------------------------

This is a high level list of changes between Pike 7.6 and Pike 7.8.
General bug fixes, build fixes and optimizations are not mentioned
here. For a complete list of changes, please consult the CVS changelog
either directly or through Code Librarian.


New / improved language functionality
-------------------------------------

o New syntax to index from the end in range operations.

  A "<" can be added before an index in the [..] operator to count
  from the end instead. This is convenient to e.g. chop off the last
  element in an array: a[..<1].

o New `[..] operator function.

  Range operations have been separated from the `[] operator function
  and are now handled by the new `[..] which provides greater control
  for how the range bounds are specified. For compatibility, if there
  is no `[..] then `[] is still called for range operations.

  FIXME: Describe relation with Pike.INDEX_FROM_BEG/END & OPEN_BOUND.

o Generalized this and this_program.

  It is now possible to refer to inherits in objects. Example:

    class A {
      int a;
      void foo() { werror("A\n"); }
    }
    class B {
      inherit A;
      int b;
      void foo() { werror("B\n"); }
      A::this_program get_a() { return A::this; }
    }

  In the above B()->get_a() will return an object with two symbols,
  'a' and 'foo', but B()->get_a()->foo() will still write "B\n".

o Added support for getters and setters.

  It is now possible to simulate variables with functions. Example:

    class A {
      private int a;
      int `b() { return a; }		// Getter for the symbol b.
      void `b=(int c) { a = c; }	// Setter for the symbol b.
      int c()
      {
        return b;			// Calls `b().
      }
    }

    object a = A();
    a->b = 17;				// Calls `b=(17).
    werror("%d\n", a->b);		// Calls `b().

o Casting to derived types.

  It is now possible to call a value of type type to perform the
  corresponding value cast. eg:

    typedef string MyString;

    return MyString(17);		// Casts 17 to "17".

o Unicode escapes.

  Pike now understands the common way to escape unicode chars, using
  \uxxxx and \Uxxxxxxxx escapes. These escapes works both in string
  and character literals and in the preprocessor. The latter means
  that unicode escapes can be used in identifiers, which is useful if
  they contain characters that can't be represented raw in the source
  code charset.

o Stricter type checker for function calls.

  The type checker for function calls is now based on the concept of
  currification. This should provide for error messages that are more
  easily understood. It also is much better att typechecking function
  calls utilizing the splice (@) operator. The mechanisms used by the
  typechecker are also made available as Pike.get_first_arg_type(),
  Pike.low_check_call() and Pike.get_return_type().

o Added generic attributes for types.

  Provides a method to hook into the type checker, so that it is
  possible to make custom type checking.

o Stricter typing of strings.

  The string type may now have an optional value range.

    string(0..255) bytes;

o Support for having multiple different active backend implementations.
  FIXME: example?

o cpp

  The preprocessor now supports macro expansion in the #include and #string
  directives.

    #include USER_SETTINGS

o Destruct reason passed to lfun::destroy.

  lfun::destroy now receives an integer flag that tells why the object
  is being destructed, e.g. if it was an explicit call to destroy(),
  running out of references, or reaped by the garbage collector.

  These integers are defined in the new Object module as
  DESCTRUCT_EXPLICIT, DESTRUCT_NO_REFS, DESTRUCT_GC and
  DESTRUCT_CLEANUP.

o Improved support for mixin.

  The Pike compiler now supports mixin for symbols that have been
  declared static.
  
  FIXME: Explain in one or two sentences what a mixin is and what it's
  good for.

o Implicit and explicit create().

  The compiler now supports defining classes with both an implicit
  and an explicit create().

o Warnings for unused private symbols.

  The compiler now checks that all symbols that have been declared
  private actually are used.

    class A (int i)
    {
      protected string j;
      protected void create(string j)
      {
        A::j = reverse(j);
      }
    }

o Warnings for unused local variables.

  The compiler now checks that all local variables are used.

o Unicode

  Case information and the Unicode module are updated to Unicode
  5.1.0.

o The keyword protected

  The modifier protected is now an alias for the modifier static.
  NOTE: In next release static will be deprecated.

o extern declared variables
  
  Variables can now be declared as 'extern'. This means that
  inheriting classes must have them. They can be used like normal
  variables in the base class.

  Example: 
    class A
    {
	extern int a;
	int dummy() { return ++a; }
    }

o __attribute__ and __deprecated__

  It's now possible to set custom attributes on types. This is
  currently used to improve the argument checking for sprintf()
  and related functions, and for marking symbols as deprecated.
  eg:

    __deprecated__ mixed obsolete_function();
    __deprecated__(mixed) obsolete_return_value();
    mixed fun(__deprecated__(mixed) obsolete_arg);
    __deprecated__(mixed) obsolete_variable;

 FIXME: syntax for __attribute__

o __func__

  The symbol __func__ now evaluates to the name of the current
  function. Note that this name currently can differ from the
  declared name in case of local functions (ie lambdas). Note
  also that __func__ behaves like a litteral string, so implicit
  string concatenation is supported. eg:

    error("Error in " __func__ ".\n");

o __dir__

  FIXME

o #pragma {no_,}deprecation_warnings

  Warnings for use of deprecated symbols can be turned off for a
  segment of code with

    #pragma no_deprecation_warnings

  and turned on again with

    #pragma deprecation_warnings

o 7.4::blaha FIXME

o Iterator->next() no longer optional. FIXME


Extensions and New Functions
----------------------------

o exit()

  Exit now takes optional arguments to act as a werror in addition to
  exiting the process.

    exit(1, "Error while opening file %s: %s\n", path, strerror(errno()));

o getenv()/putenv()

  getenv() and putenv() are now accessing and modifying the real
  environment.

o undefinedp()/destructedp()

  undefinedp() and destructedp() have been added as more readable
  alternatives to zero_type().

o limit()

  The new toplevel function limit(a, x, b) is a convenience function
  that works like min(max(a,x),b).

o sprintf() and sscanf()

  - sprintf() now attempts to lookup the name of the program when
    formatting types of objects and programs.

  - The new formatting directive %H can be used to format a string as
    a binary hollerith string.

      > sprintf("%2H", "Hello");
      (1) Result: "\0\5Hello"

  - The new formatting directive %q can be used to format a atring as
    a quoted string, quoting all control character and non-8-bit
    characters as well as quote characters. Like %O but always on one
    line.

      > sprintf("%q", "abc \x00 \" \' \12345");
      (1) Result: "\"abc \\0 \\\" ' \\u14e5\""

o encode/decode value and programs

   --with-portable-bytecode is now the default. Pike programs that have
   been dumped on one architecture now can be decoded on another.

o sscanf %H %[^-X] (!= %[^X-]) %[X-X]  FIXME

o gethrtime, gethrvtime, gauge

  Added support for POSIX style timers using clock_gettime(3). Notably
  this fixes nice high resolution thread local cpu time and monotonic
  real time on reasonably modern Linux systems.

  There are new constants CPU_TIME_* and REAL_TIME_* in the System
  module to allow pike code to query various properties of the CPU and
  real time clocks in use.

o ADT.BitBuffer
 
  Added read() method that reads whole bytes from the buffer and
  returns as a string.

o ADT.Queue

  It is now possible to use sizeof() and values() on a Queue object to
  get the size of the queue and all elements in the queue as an array.

o ADT.Stack

  Stack objects can now be cast to arrays to get all elements on the
  stack.

o ADT.Struct

  - New Item class SByte, SWord and SLong represents a signed byte,
    word and longword respectively.

  - The Item classes int8, uint8, int16, uint16, int32, uint32, int64
    and uint64 are aliases for already existing Item classes.

  - sizeof() now works for empty Struct objects.

  - sizeof() can be used on individual Item objects.

  - Struct objects can now be used as Items in other Structs.

    class Pair
    {
      inherit ADT.Struct;
      Item id = uint8();
      Item val = uint64();
    }

    class File
    {
      inherit ADT.Struct;
      Item magic = Chars(4);
      Item one = Pair();
      Item two = Pair();
    }

o Array

  - New function combinations() returns all combinations of a
    specified length with elements from a given array.

  - Added push(), pop(), shift() and unshift() functions for Perl
    weirdos.

o Calendar

  - Added new calendar Badi, used in the Baha'i religion.

  - Fixed bugs in discordian, where the year() was off by 1166 and
    now() was off 5 month per year.

  - Time objects now handle * and / with floats. A split() method has
    been added for more advanced splitting. FIXME: Example

  - A new formatting method format_ext_time_short() has been added to
    Time objects.

  - Timezones are now read from /etc/localtime, if available.

o CompilerEnvironment & CompilerEnvironment()->PikeCompiler

  The Pike compiler has been refactored to be more object-oriented
  and more transparent. It is now possible to customize the compiler
  by overloading functions in the above two classes.

o Debug

  The new function count_objects() will return the different kinds of
  objects existing within the Pike process. Useful when trying to
  pinpoint a leak of Pike objects.

o DefaultCompilerEnvironment

  The CompilerEnvironment object used by Pike internally.

o Error

  The new function mkerror() will normalize any thrown value into a
  proper error object (or 0).

o Filesystem

  Traversion has been extended with two new create arguments. The
  first one is a flag to supress errors and the other is a sorting
  function which will be applied to the entries in every directory.
  This callback can also be used to filter the directory entries.

o Float

  The function isnan() can be used to check if a float is Not a
  Number.

    > Float.isnan(Math.inf/Math.inf);
    (1) Result: 1

o Gdbm

  Gdbm databases can be opened in synchronous mode or locking mode by
  adding "s" or "l" respectively in the mode parameter to the create
  method.

o Geography.Position

  It is now possible to encode Position objects with encode_value().

o GLUE

  - The default event callback will now exit both on Exit and Escape
    events.

  - The texture, list and light id generators will now be created
    after we are sure that GL has been initialized, to prevent crashes
    on several systems.

  - BaseTexture and BaseDWIM now supports clamped textures.

o Gz

  - Added compress() and uncompress() functions as an simpler and more
    efficient but non-streaming interface.

  - Support for RLE And FIXED compression method, if supported by
    zlib.

  - Added support for configurable compression window size.

o Image.Colortable

  - The new method greyp() can be used to query if the color in the
    color object is grey.

  - Partial support for serializing color objects. Dithering type and
    lookup mode is not currently saved.

o Image.Dims

  Support for parsing out the dimensions of TIFF files has been added.

o Image.FreeType

  - Added support for handling monochrome (bitmap) fonts.

o Image.Image

  - Image object can now be serialized and deserialized with
    encode_value() and decode_value().

  - It is possible to convert the colors in an image object to and
    from YUV (YCrCb) with the new rgb_to_yuv() and yuv_to_rgb()
    methods.

o Image.Layer

  - It is now possible to get the raw bitmap data of a layer by
    casting the layer object to a string.

o Image.PNG

  - Properly decode cHRM (chrome), sBIT (sbit), gAMA (gamma), pHYs
    (physical), oFFs (offset), tIME (time) chunks.

  - The compression level and strategy when compressing PNG images can
    be controlled by passing "zlevel" and "zstrategy" options to the
    encode() method. Available strategies are filtered, huffman, rle
    and fixed.

      Image.PNG.encode( img, ([ "zlevel":9, "zstrategy":Gz.RLE ]) );

o Image.TIFF

  Added support for little endian TIFF files.

o Int

  Int.inf is an object that can be used as an infinitly large integer.

o Locale.Charset

  FIXME: Rewrite
  Remapped and documented the use of the private character space.
  ISO-IR non-spacers are now converted into combiners.
  Added some support for pluggable character sets.
  Added GB18030/GBK
  UTF-EBCDIC
  unicode prefix, e.g. unicode-1-1-utf-7
  CP949
  GBK (cp936)
  DIN-31624 (ISO-IR-38)
  ISO-5426:1980 (ISO-IR-53)
  ISO-6438:1996 (ISO-IR-39, ISO-IR-216)
  ISO-6937:2001 (ISO-IR-156)

  Added typed encode and decode error objects
  (Locale.Charset.EncodeError and Locale.Charset.DecodeError) to make
  it possible to catch such errors in a better way.

o Math

  - Matrix multiplication was bugged and gave B*A instead of A*B,
    which is now fixed.

  - Matrix objects now have xsize() and ysize() methods to query their
    dimensions.

  - To ease your logarithmic needs log2() and logn() have been added.

o MIME

  - Added remapping variants of the encode words functions with
    encode_word_text_remapped(), encode_word_quoted(),
    encode_words_quoted_remapped() and
    encode_words_quoted_labled_remapped().

  - Added workaround for a bug in Microsoft Internet Explorer where it
    forgets to properly quote backslashes in the Content-Disposition
    field.

  - Fixed a bug that could occur when casting MIME.Message objects to
    strings.

o Mysql

  Unicode support. FIXME: mast Document in more detail. C.f. check-in
  1.25 of lib/modules/Sql.pmod/mysql.pike.

o Odbc

  FIXME: Rewrite
  Now supports UnixODBC properly.
  Fixed various issues with Unicode.
  FreeTDS fixes

o Oracle

  - The module has been updated to work with Oracle 10.

  - An approximation of the number of rows in a result object can be
    queried from the new function num_rows().

o Parser.HTML

  FIXME
  Allow string and array as argument to _set_*_callback
  
o Parser.Pike and Parser.C

  - Parser.Pike and Parser.C have been rewritten in C for increased
    performance.

  - The #string directives should be handled correctly now.

o Parser.RCS

  - The RCS parser has been rewritten to handle broken RCS data
    better.

o Parser.XML.NSTree

  - Added add_child_before() and add_child_after() methods to the
    NSNode object.

  - Fixed crash bug.

o Parser.XML.Simple

  FIXME
  autoconvert() moved to top level
  Several correctness fixes.
  Added Simple.Context

o Parser.XML.Tree

  FIXME: Rewrite
  Added rendering of DTD ENTITY nodes.
  The renderer now knows about the internal_subset attribute for the
    DOCTYPE tag.
  Added rendering of DTD ELEMENT nodes.
  Added functions to inser new childe node.
  Moved parser code into the nodes allowing for extendability.
  set_tag_name()
  simple-stuff
  AbstractSimpleNode, VirtualNode, SimpleNode.
  Node.zap_tree

o Postgres

  Added affected_rows.
  Made big_query() streaming.
  Added streaming_query() alias to indicate support.
  Support bindings natively on big_query().
  Automatic binary or text transfer for queryarguments and resultrows.
  Return correct UNDEFINED instead of 0 values for NULL values in resultsets.
  Fix raceconditions.

o Pike

  - A new function count_memory() has been added which can calculate
    the memory consumed by arbitrary data structures. Useful when
    implementing memory caches.

  - A new function get_runtime_info() has been added which returns
    information about current ABI, if automatic bignums are enabled,
    what bytecode method is used, the size of native floats and
    integers and the native byte order.

  - The constants INDEX_FROM_BEG, INDEX_FROM_END and OPEN_BOUND has
    been added for use with the `[..] operator API.

  - The functions low_check_call(), get_return_type() and
    get_first_arg_type(). FIXME!

o Process

  - The new function spawn_pike() will spawn a Pike process similar to
    the current one, using the same binary file, master and module
    paths.

  - The new function run() is an easy interface that will run a
    process and return a mapping with all the outputs and exit code.

  - Process.popen is now able to run in nonblocking mode. If a second
    argument is provided a file object will be opened with that mode
    and return, enabling two way communication with the new process.

  - The system() function has been extended to be able to pass stdin,
    stdout and stderr arguments to the spawn() call it performs.

o Protocols.DNS

  - Added support for NAPTR (RFC 3403) records.

  - The gethostbyname() function now returns IPv6 addresses too, if
    available.

  - Fixed bugs in IPv6 record parsing.

o Protocols.Bittorrent

  - Support for gzipped and compact tracker responses.

  - 30% faster hashing of files.

  - Many performance and bug fixes.

o Protocols.HTTP

  - Added support for httpu and httpmu requests.

  - Queries will now throw an exception in case of an errno condition.

  - A new function, do_async_method(), has been added to allow access
    to low level asynchronous HTTP calls.

  - The http_encode_string() function now knows how to encode UCS-2
    characters.

o Protocols.HTTP.Server

  - If accept() fails on the open port, the Port object will continue
    trying, to support servers with high load.

o Protocols.HTTP.Query

  - Added unicode_data() method that will return the payload decoded
    according to the charset described in the Content-Type header.

  - Many fixes for bugs in asynchronous mode.

  - A query will not silently downgrade to http from https anymore if
    there is no crypto support.

  - Fixes for keep alive.

o Protocols.LDAP

  Added more resilience to UTF-8 encode errors. A new flag
  Protocols.LDAP.SEARCH_RETURN_DECODE_ERRORS may be used to avoid
  throwing errors when this happens.

  FIXME: Many changes

o Protocols.SNMP

  The readmsg() method in the protocol object now takes an optional
  timout argument.

o Protocols.XMLRPC

  The new AsyncClient class implements an asynchronous XMLRPC client.

o Regexp.PCRE.Widestring

  - Replace matches in a string, with support for backreferences, now
    possible from replace_positional().

      > Regexp.PCRE.Plain("my name is ([a-zA-Z]+)")->
      >> replace_positional("hello, my name is john.",
      >> "%[0]s is my name");
      (1) Result: "hello, john is my name."

  - Regexp.PCRE.Widestring is now reported in the basic feature list
    (pike --features).

o Sql

  - Bugfixes in listing Postgres fields.

  - If ENABLE_SPAWN_RSQLD is defined, rsqld will be spawned when
    needed to complete rsql queries.

  - Added streaming_query() method to Sql objects which enables larger
    result sets than available memory.

  - It is possible to iterate over the result object from big_query()
    queries directly in foreach.

  - Support for ODBC DSN files. FIXME: Example from grubba?

      Sql.Sql db = Sql.Sql("dsn://user:pass@host/database");

  - Support for the TDS protocol, used by Sybase and Microsoft SQL
    server.

      Sql.Sql db = Sql.Sql("tds://user:pass@host/database");

  - Support for the SQLite database added. A raw interface is
    available throug hthe SQLite module. FIXME: Syntax?

      Sql.Sql db = Sql.Sql("sqlite://path/to/file");

  - Sql.pgsql.  New driver for native PostgreSQL network protocol support.
    It implements a superset of the existing Postgres driver.
    Current features: no library dependencies (no libpq), native binding
    support, streaming support, NOTIFY/LISTEN support (fully eventdriven,
    no polling), binary support for integer, float and string datatypes,
    COPY FROM/TO STDIN/STDOUT support, multiple simultaneous streaming queries
    on the same connection (i.e. multiple PostgreSQL-portal-support),
    automatic precompilation and caching of often-used
    long-compile-time-needing queries, extended columndescriptions,
    accurate error messages under all circumstances, SSL-support,
    SQL-injection protection since it will ignore everything after the
    first semicolon terminating the first command in the query, integrated
    statistics, _reconnect callback for sessions that use temptables.

    Performance tuned, with the helperclass _PGsql.PGsql it currently
    is around 21% faster than the old libpq based Postgres driver
    for smaller queries; for large bytea blobs and large texts, it
    speeds up even more.

  FIXME: mysql

o SSL

  FIXME: client certificates: examples?

o Standards.IIM

  Some bugfixes in parsing Photoshop headers and DOS EPS Binary
  Headers.

o Standards.ISO639_2

  Updated with the latest ISO639-2 languages.

o Standards.URI

  - Updated to conform to RFC 3986.

  - Added methods get_query_variables(), set_query_variables(),
    add_query_variable() and add_query_variables() to give a better
    API to to handle query variables.

  - The new method get_http_query() returns the query part and
    get_http_path_query() returns both the path and the query, both
    coded according to RFC 1738.

o Standards.UUID

  - Added support for UUID version 5; name based with SHA hash, which
    can be generated from the make_version5 function.

  - An UUID object can now be used as namespace in the second argument
    to make_version3 as well as the new make_version5.

o Standards.XML.Wix

  FIXME

o Stdio

  - Stdio.cp can now work recursively in a directory tree. It will
    also keep the permissions of files it copies.

  - Added Stdio.recursive_mv which works on every OS and also when the
    destination isn't on the same filesystem as the source.

  - Added more symbolc default termcap/terminfo bindings to
    Stdio.Readline.

  - Improved support for Terminfo on NetBSD.

  - read_file(), read_bytes(), write_file() and append_file() will may
    now throw exceptions on uncommon errors such as when write_file is
    unable to write all its data.

  - Stdio.File->openat() opens a file relative to an open directory.

  - Stdio.FILE->unread() allows pushing back binary strings into the
    input stream, as opposed to ungets() which pushes back lines.

o String

  - The function int2size has been rewritten to fixpoint as well as
    using the more common abbreviation of "B" for byte.

  - String.secure marks a string as "secure" which currently only
    means that the memory is cleared before it is freed.

o System

  FIXME

  resolvepath() enabled on more OSes and falls back to realpath(3C) if
  resolvepath(2) doesn't exists.

  setproctitle()

  - Added support for POSIX style timers using clock_gettime(3) to
    allow for high resolution thread local cpu time and monotonic real
    time on reasonable modern Linux systems for gethrvtime() and
    gauge(). Added CPU_TIME_RESOLUTION, CPU_TIME_IMPLEMENTATION,
    REAL_TIME_IS_MONOTONIC, REAL_TIME_RESOLUTION and
    REAL_TIME_IMPLEMENTATION constants to singal the system
    capabilities.

o Tools.Hilfe

  - Added support for tab-completion on modules, global and local symbols and
    operators.
  - Added support for file/directory completion within strings
  - Added doc command and F1 key to print documentation on anitem if available
    (currently only works for modules and classes written in pike)

o Tools

  FIXME

o Web.Crawler

  - Bugfix to support robots.txt created on windows.

  - User Agent change to "Mozilla 4.0 (PikeCrawler)"

o Web.RDF

  - Added add_statement() method which allows new relations to be
    added to an RDF set.


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

o Fuse

  FUSE (Filesystem in USErspace) provides a simple interface for
  userspace programs to export a virtual filesystem to the Linux
  kernel (and some other OS:es). FUSE also aims to provide a secure
  method for non privileged users to create and mount their own
  filesystem implementations.

  This module implements the needed interfaces to make it possible to
  write a FUSE filesystem in Pike.


o ADT.List

  A simple linked list of values.

o ADT.Trie

o ADT.Set

  ADT.Set implements a datatype for sets. These sets behave much
  like multisets, except that they are restricted to containing only
  one instance of each member value.

  From a performance viewpoint, it is probably more efficient for a
  Pike program to use mappings to serve as sets, rather than using an
  ADT.Set,so ADT.Set is mainly provided for the sake of completeness
  and code readability.

o Arg

  The new argument parser module allows for Getopt style arugment
  parsing, but with a much simpler and object oriented API.

    class Parser
    {
      inherit Arg.Options;
      Opt verbose = NoOpt("-v")|NoOpt("--verbose")|Env("VERBOSE");
      Opt name = HasOpt("-f")|HasOpt("--file")|Default("out");
      Opt debug = MaybeOpt("-d")|MaybeOpt("--debug");
    }
  
    void main(int argc, array(string) argv)
    {
      Parser p = Parser(argv);
      werror("name: %O, verbose: %O, debug: %O\n",
             p->name, p->verbose, p->debug);
    }

  A more simplistic interface is also available for smaller hacks and
  programs.

    void main(int argc, array(string) argv)
    {
      mapping opts = Arg.parse(argv);
      argv = opts[Arg.REST];
    }

o GSSAPI

  Implements Pike access to GSS-API v2 as specified in RFC 2743. This
  API is used to authenticate users and servers, and optionally also
  to encrypt communication between them. The API is generic and can be
  used without any knowledge of the actual implementation of these
  security services, which is typically provided by the operating
  system.

  The most common implementation is Kerberos, which means that the
  main benefit of this API is to allow clients and servers to
  authenticate each other using Kerberos, thereby making single
  sign-on possible in a Kerberized environment.

o GTK2

  Wrapper for the GTK2 library. Not yet 100% completed, but usable.

o Kerberos

  FIXME

o Protocols.DNS_SD

  This module provides an interface to DNS Service Discovery. The
  functionality of DNS-SD is described at <http://www.dns-sd.org/>.

  Using the Proctocols.DNS_SD.Service class a Pike program can
  announce services, for example a web site or a database server, to
  computers on the local network.

  When registering a service you need to provide the service name.
  service type, domain and port number. You can also optionally
  specify a TXT record. The contents of the TXT record varies between
  different services; for example, a web server can announce a path
  to a web page, and a printer spooler is able to list printer
  features such as color support or two-sided printing.

  The service is registered on the network for as long as the instance
  of the Service class is valid.

o Bittorrent.Tracker

  Bittorrent tracker with support for scraping and UDP extension.

o Protocols.HTTP.Server.Proxy

  A simple HTTP proxy.

o Standards.TLD

  Country domains and other TLDs according to IANA. Useful when
  parsing log information or providing live information about clients
  connecting to your server.

o Tools.Shoot

  Several new tests have been added to benchmark and improve on
  various aspects of Pike. ReplaceParallel and ReplaceSerial measure
  the times it takes to replace multiple substrings of a string in a
  single call to replace and with subsequent calls.

  TagRemoveArraySscanf, TagRemoveDivide, TagRemoveLoop,
  TagRemoveParserHTML, TagRemovePCRE, TagRemoveSearch and
  TagRemoveSscanf measure different methods of completing the same
  task; to remove XML tags from a string.

o Web.CGI

  Provides a CGI interface on the callee side. Retrieves information
  from environment variables and populates the variables in the
  Request object.


Deprecations
------------

o The keyword nomask has been deprecated. It was functionally
  equivivalent with the keyword final.

o Stdio.File->set_peek_file_before_read_callback() is deprecated.


Incompatible changes
--------------------

  These incompatible changes can be solved by adding #pike 7.6 to your
  source file or starting Pike with -V7.6.

o main() environment

  The main() method will no longer be given the environment as a
  mapping as third argument. Use an explicit call to getenv() instead.

o Array.transpose_old

  This function has been removed.

o _Charset

  The parts of this internal module that were written in Pike
  have moved to Locale.Charset.

o Crypto

  The old crypto functions from Pike 7.4 have been removed. These
  functions produced a warning when used in Pike 7.6.

o Debug.describe_program

  The API for this debug function has changed.

o Image.Image

  The functions select_colors(), map_closest(), map_fast() and
  map_fs() has been removed. Use Image.Colortable operations instead.

o Parser.XML

  The XML parsers are now stricter in verifying the correctness
  of the XML. The function compat_allow_errors can be called in the
  create method of the Parser.XML.Simple and Parser.XML.Validating
  (with "7.6" as argument for 7.6 compatibility). Parser.XML.Tree can
  be created with PARSE_COMPAT_ALLOW_ERRORS_7_6 as flag.

o Protocols.LDAP.client

  The "dn" field wasn't properly utf-8 decoded in 7.6 and earlier. If
  your application does it yourself, you need to use the compatibility
  version of this class.

o spider.XML

  The spider module no longer contains the XML parser. The functions
  isbasechar(), iscombiningchar(), isdigit(), isextender(),
  isfirstnamechar(), ishexchar(), isidiographic(), isletter(),
  isnamechar() and isspace() have also been moved to the Parser module.

o Sql.Sql

  Pike will no longer create a .column entry in SQL query responses if
  there is no table name.

o Standards.UUID

  Functions new() and new_string() have been removed. Use
  make_version1(-1)->encode() and make_version1(-1)->str() instead.

o Stdio

  The functions read_file(), read_bytes(), write_file() and
  append_file() now always throw errors on error conditions,
  to allow easier use as errno doesn't have to be checked.
  read_file() and read_bytes() still return 0 if the file
  does not exist.

o The modules Mird, Perl and Ssleay have been removed.


C level module API
------------------

o Improved support for embedding.

  Several declarations and definitions (most notably the debug and
  runtime flags) have moved from main.h to pike_embed.h, in an attempt
  to add support for embedding.

o Major compiler API cleanups.

  The Pike compiler is now executing in a pike function context
  (rather than in an efun context), and it is possible to customize
  some of its behaviour via inherit (rather than via handler objects).
  As a consequence the compiler is now much closer to being thread-safe.

o The global variable next_timeout is no more. It has been replaced by
  a backend-specific variable. Added backend_lower_timeout() for accessing
  the new variable. This fixes issues GTK, GTK2 and sendfile had with the
  new backend implementation.

  NOTE! C-API incompatibility!
  NOTE! Changed the argument for backend callbacks!

  The argument is now a struct Backend_struct * when called
  at entry (was NULL).
  The argument is now NULL when called at exit (was 1).

o Pike_fp->context

  Pike_fp->context is now a pointer to the current struct inherit
  rather than a copy of it. This allows for easier access to
  inherited symbols in C-code.

o Inherit level argument added to several object handling functions.

  In order to implement subtyping of objects, an extra argument
  "inherit_level" has been added to many object indexing related
  functions.

o .cmod:

  Voidable pointer types are no longer promoted to mixed.

o Support for class symbols with storage in parent scope.
  Also added support for aliased symbols.

o Machine code backend for PPC64 FIXME

o Objectiv-C embedding framwork FIXME

o Added %c and %C to get_all_args to get char * without
  NUL characters (no 0 valued characters inside the string).

  %c: char *	      Only narrow (8 bit) strings without NUL.
      This is identical to %s.

  %C: char * or NULL  Only narrow (8 bit) strings without NUL, or 0


Building and installing
-----------------------

o Added ABI selection.

  It's now possible to select whether to compile in 32bit or 64bit
  mode at configure time by using the --with-abi option.

o MinGW build possible. FIXME


New simplified method to write external C/C++ modules
-----------------------------------------------------

  It's now suggested that you do not use the fairly complex 'pike
  internal' style of external modules (configure.in with
  AC_MODULE_INIT etc).

  It's also no longer required that you have a configure script to use
  pike -x module.

  Instead simply locate the includefiles using 'pike -x cflags', and
  convert .cmod to .c files using 'pike -x precompile'.

  An example rather minimal 'pike -x module' compatible Makefile,
  without a configure script, using .cmod format files for a simple
  local module:

  | CC=gcc
  | CFLAGS := -O9 -fweb -shared -Wall $(CFLAGS) $(shell $(PIKE) -x cflags) -g
  | LD=$(CC) -shared -lGL
  | 
  | all: Spike.so
  |
  | install: Spike.so
  | 	cp $< $(MODULE_INSTALL_DIR)
  | 
  | Spike.so: Spike.o
  | 	$(LD) -o Spike.so Spike.o $(LDFLAGS)
  | 
  | Spike.o: Spike.c
  | 
  | Spike.c: Spike.cmod
  | 	$(PIKE) -x precompile $< > $@

  It's usually OK not to use pike -x module at all, but it will pass
  on a few extra variables to your make (and configure script):

   PIKE: How to start the pike interpreter used running pike -x module
   MODULE_INSTALL_DIR: Where modules goes
   LOCAL_MODULE_PATH: Alternative (user local) module location


-------------------- NOTES------------

2004/04/26 00:13:30


----
modules/_Charset


New lib:
Protocols.LDAP module.pmod
-x test_pike


src:
files: FIXME
gmp: FIXME
java: FIXME
mysql: FIXME



DLL for Windows?


libpike.so

Wix

valgrind_hilfe and valgrind_just_verify

New malloc on Windows.

poll/epoll
