
Changes in Pike 7.4.XX:
----------------------------------------------------------------------

o Symbolic constants for status codes in Protocols.HTTP.
o Don't crash when decoding broken maker specific data in
  Standards.EXIF.
o Fixed off-by-one bugs that could occur for the innermost line in
  backtraces when machine code is used.
o make.conf is now not used.
o Fixed "Illegal program pointer." error.
o Fixed spurious "Must return a value for a non-void function."
  errors.
o Fixed bug in argument checking that could cause segfaults when some
  C level functions that expect arguments were called without any.
o Renamed symbols that are keywords in C99.
o Fix to compile with FreeType >= 2.1.6.
o Added test to detect broken libtiff.
o Bugfixed test to detect broken GTK.

Changes in Pike 7.4.44:
----------------------------------------------------------------------

o Added Memory.shmat on Windows.
o Fixed bug in Function.defined.
o Mac OS X poll() fixes.
o Better optimization on Mac OS X on PPC G3 and newer.
o Bugfix to avoid reading zero bytes from a file to block on Windows.
o Bugfix to prevent races if Image.Font.load() is called in several
  threads.
o Fixed previously broken UTF7.5 encoding.
o Decoding of mask flag and mask default color in PSD images now
  works.
o Better checks for wide and binary strings in the Mysql module.
o Fixed bug in Stdio.Port.accept that could case it to fail if a
  signal arrived at the wrong time.
o Fixed bug in System.get_netinfo_property that could cause it to
  fail.
o Robustness fixes in the backend.
o Bugfix to prevent errors during backtraces due to destructed
  objects.
o SSL.sslfile bugfixed so that it doesn't do anything after calling a
  callback, since the file might be used in non-callback mode in
  another thread by then. This still doesn't fix the case when the
  read callback is called after the accept callback (this is however
  fixed in the development version of Pike). Also nothing is done
  after the file has been set to nonblocking mode, since the backend
  might already be using it by then, if it's in another thread.
o SSL.sslfile bugfixed to not call the write callback while still in
  handshake.
o Fixed a race in SSL.sslfile that could occur in set_nonblocking when
  it was called from another thread than the backend thread.
o Fixed several bugs in SSL.sslfile where I/O errors or close calls
  from within callbacks caused it to try to use a closed socket.
o Mac OS X support in Stdio.Terminfo.
o Web.Crawler no longer tries to fetch /robots.txt over protocols it
  doesn't recognize.
o `| on arrays now preserves the order of the left argument for common
  elements.
o Image.lay now ignore zero sized layers.
o Bugfixed Image.PNG grey scale decoding.
o _Roxen.http_decode_string now handles %u encoded characters.
o Fixed crash in GL.glGetString.
o The normal bunch of unspecified core fixes for rare problems
  discovered since the last release.

Changes in Pike 7.4.28:
----------------------------------------------------------------------

o Generation of LDSHARED bugfixed so that building of 3:rd party
  modules works.
o Bugfixes to String.Buffer.`+ and String.Buffer.`+=.
o Bugfix in String.Buffer wide string handling.
o is_absolute_path can now handle empty strings.
o Stdio.FakeFile works as Stdio.File when reading more than what is
  stored in the file.
o Bugfix in Standards.EXIF for Nikon 990/D1 cameras.
o The MIME module supports transport padding after delimiter.
o Buffer overflow fixed in _Roxen.
o Several iterator bugs fixed.
o Array.lyskom_sort_func bug fixed.
o Bug fixes in Microsoft Windows installation.
o Made -e and --execute work on IRIX for large pids.
o Fixed PSD decoding bug for images with small masks.
o Bugfix for ID3v2 tag decoding.
o Corrected Stdio.FakeFile API to be more like Stdio.File.
o Bugfixes in Web.Crawler.
o The fd flags are now cleared before calling callbacks on POLLERR and
  POLLHUP to prevent nonblocking I/O to hang on fds where errors have
  occured earlier.
o Several minor stability fixes (use less stack, better argument
  checking, etc) in some functions.
o The Foo::this implementation is reworked to work correctly with
  parent pointers through inherits.
o Better object file dumping.
o Removed an overoptimization that could cause some casts to disappear
  even when they might have effect.
o Fixed a bug that caused has_index((<1>),1) to return 0.
o Fixed a memory leak that appeared when doing `- or `& on a mapping
  or multiset.
o Fixed a core dump when doing `[]= on a string with invalid index.
o Fixed a bug that in rare cases would make identifiers disappear from
  programs.
o Fixed a bug that could cause the parser to hang when a tag callback
  returned the empty string and there's a data callback registered.
o Bugfix for handling of NUL in %{%} in sprintf.
o Added kludge to avoid race condition in syslog(2) in
  glibc/linuxthreads.
o Bugfix when iterators are used in foreach. They are now incremented
  after the loop instead of before it. This can have compatibility
  effects in code that uses iterators explicitly. E.g:
    String.Iterator iter = String.Iterator ("foo");
    foreach (iter; int ind; int val)
      werror ("%d %d\n", ind, iter->index());
  This will now write "0 0", "1 1", etc. In previous versions of 7.4
  it wrote "0 1", "1 2", etc since the iterator has already been
  incremented to point to the next element.
o Bugfixes in Calendar.Fraction, which prevously lost track of the
  fraction component in Fraction()->set_timezone() and always returned
  0.0 in Fraction()->fraction_no().
o Stdio.File()->grantpt() fixed to work with SysV systems.
o New function Stdio.File()->openpt() to portably get a pty master for
  use with grantpt().
o Raised the maximum allocation limit for the garbage collector. This
  fixes a problem with too frequent gc runs for large and busy
  processes.

Changes in Pike 7.4.20:
----------------------------------------------------------------------

o Bugfix in Parser.C. "!=" is now considered one token instead of two.
o Bugfixed loop over-optimization caused by faulty dependency
  analysis.
o Postgres 7.3+ correctly detected.
o Now function_object behaves as in Pike 7.2 again, returning zero if
  the argument is a constant in the parent class. In that case
  function_program() can be used to get the parent program.
o Added System.dumpable() which can be used on Linux to enable
  coredumping even for seteuid/setegid processes.
o Image.FreeType now selects the hopefully best character map when
  loading a font, instead of just picking a random one.
o Fixed a bug that made searching for 8 bit strings in wider strings
  fail.
o Fixed fencepost bug on overflow of the sprintf format info stack.
o Fixed bugs in float parsing code, preventing very large positive or
  negative floats from being turned into 1.0 or -1.0.
o More robustness has been added to dlinit() and __alldiv(), which
  fixes some start up crashes in Microsoft Windows when invoking Pike
  with the wrong path.
o Process.create_process()->set_priority now works on Microsoft Windows.
o SDL and GL now compile, link and work on Microsoft Windows.
o Produce real zeroes and not false function pointers when a local
  function with only a prototype is referenced. This was a compatibility
  problem; there's code that assumes that false values can't be
  function references.
o Fixed GTK issue where the new and old signal callback signature were
  randomly used for signals connected with signal_autoconnect(). This
  method now always uses the old method while a new method,
  signal_autoconnect_new() uses the new interface.
o Added missing GTK method set_style.
o Fixed a compatibility problem with Getopt, which caused Pike 7.4 to
  behave slightly different from previous versions when running in
  posix-me-harder mode.
o Fixed a bug in the code handling boundaries in multipart messages in
  the MIME module.
o Multiline tokens are now handled better in Parser.Pike when running
  in streaming mode.
o Fixed a bug in sscanf when using %[] with wide characters.
o Fixed a bug in low_backtrace where the backtrace itself could be
  reported as an argument to the top function if it was of varargs
  type.
o Fixed security hole with running next_object in a Pike with
  security.
o Fixes to make dumping work in a fakeroot environment.
o Line numbers for C programs are now shown in backtraces even without
  having to compile with rtldebug.
o It is possible to turn on only gc debug with trace(1,"gc").
o The aim for 20% garbage between gc runs was calculated on the wrong
  total amount of objects, so in effect the gc aimed for 16.7%
  instead.
o The decaying average calculation in the gc had a bug that caused the
  last reading (i.e. the last gc run) to be weighted very heavily.
  Thus a single "abnormal" gc run could cause the gc to schedule a
  fairly short or long gc interval the next time which might make it
  erratic.
o More solutions to new and fresh autoconf compatibility problems,
  willfully introduced by the autoconf team.
o Threads are disabled by default on OpenBSD/alpha <= 3.x.
o Java module now supports native method registration on alpha.
o Fixed floating point argument handling with native calls in Java module
  for Linux/PPC.
o Pike will now look for the master path in SOFTWARE\Pike\ in the
  registry on Microsoft Windows.
o Fixed icon transparency on Microsoft Windows.
o Fixed a bug that could cause wrong line numbers in backtraces when
  ia32 machine code is used.
o Fixed bug that could cause the stack to get out of synch when large
  64 bit negative integers were converted to bignum objects.
o Fixed bug in trampoline objects so that they can be indexed and
  printed as normal objects.
o Accesses from child objects to symbols in their parent objects will no
  longer pass through LFUN::`[]() and LFUN::`[]=().
o The object identifier index sorting order is no longer locale-dependent.
o The opcodes F_{INC,DEC}{,_NEQ}_LOOP are now aware that the upper limit
  not neccessarily is an integer.
o Fixed a bug in the dependency analyser. It didn't check arguments to
  side-effect free functions for written variables, which could cause
  overoptimization breakage.
o The initialization code no longer calls fpsetmask(0) on operating
  systems where this API call is broken (eg OpenBSD 3.2/alpha).
o Stdio.Stat()->size is now LARGEFILE aware.
o Clearing a read-callback on operating systems that use select(2) no
  longer leaves it active in the read fd set if there is a read
  out-of-band data callback.
o Fixed bug in Image.Image()->scale(0.5) where it could generate zero-
  size image objects.
o Fixed rounding bug in Image.Colortable that caused it to disregard
  exact matches near cubicle boundaries.
o Fixed Mac OS X memory allocation error when creating new threads.
o Fixed opcode level trace and debug (when compiled with
  --with-rtldebug).
o The Image module can now be compiled on SunOS 4.1.1_U1, whose
  assembler doesn't like long strings.
o The pseudo random sequences generated by random() should now be the
  same on 32 bit and 64 bit machines, given the same random_seed().
o Fixed handling of 64 bit file pointers on NT.
o Fixed handling of 64 bit file pointers in Stdio.File.truncate and
  file_truncate.
o Calendar.parse() now understands %f for sub-second precision. This
  was documented but unimplemented.
o Calendar.parse() no longer fails to generate times after 23:00 on
  dates lacking an hour due to a DST shift.
o map() could previously have been misoptimised when run on functions
  with external dependencies.
o configure no longer lies about Java being enabled when it is not under
  Microsoft Windows.
o Fixes to compile with --without-bignums. Not recommended, but it should
  work again now.
o Fixes to make the Mysql module load under Microsoft Windows even when
  compiled as a dynamically loadable module.
o Fixed a threading bug in Image.Image()->box().
o Added more consistency checks to detect thread problems. This is
  enabled with the new -dT argument (--with-rtldebug is not necessary).
o Fixed bug in foreach range optimization.

Changes in Pike 7.4.10 since 7.2.30:
----------------------------------------------------------------------

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

o New Hilfe
    The interactive pike environment you get when running pike without
    giving a program name, has been thoroughly rewritten. Most notably
    it now supports more of the common pike constructs, and is more
    extendable and configurable. Start it and type help for more info.

o AutoDoc
    The major parts of Pike now have some sort of documentation on
    class and function level thanks to the AutoDoc system which has
    been deployed during the last year. Manual dumps are published on
    http://pike.ida.liu.se/docs/reference/. Note that the manuals and
    the manual system are still work in progress.

o pike -x
    When starting pike with the -x parameter, the pike process will
    run the named script in Tools.Standalone, giving the rest of the
    arguments as command-line switches. This is a convenient way of
    running rsif (replace string in file) and pv (the image viewer
    you may be familiar with from Tools.PV).

o pike -e scope
    When running command line one-liners with pike -e you can now
    access the number of arguments, the actual arguments and the
    environment variables through the variables argc, argv and env.

o unbug
    Embryo of a Pike debugger. Neither stable nor finished.

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

o Extended random()
    random() now works on floats, arrays, multisets, mappings and
    objects in addition to integers.

o delay()/sleep()
    sleep() no longer busywaits, which it previously did for small
    values. The old behavior is available from the delay() function.
    (This has change been made in later Pike 7.2 releases too.)

o search(string, int) / has_value(string, int)
    Both of these methods now handle looking for both strings and
    integers (the unicode number for a single character).
    Examples: search("hi, ho!", '!'), has_value("Nope.", ' ')

o Expanded Charset module
    The character set module now has support for the character sets
    Shift_JIS, UTF-7.5, EUC, Big5, CP950, UTF-16, UTF-16BE, UTF-16LE.
    It is now also easier to get the right charset codec since the
    names are normalized internally.

o sprintf("%O", foo) is more descriptive
    If foo is a program or an object then Pike will try to find the
    resolved name instead of returning just "program" or "object".
    However, if an object contains an _sprintf function it will still
    be called in this case.

o basetype(foo)
    Returns a string with the basic type of foo as opposed to
    _typeof(foo) which returns the actual type. Also available as
    sprintf("%t", foo). Note that it is affected by _sprintf() in
    objects.

o getenv()/putenv()
    The environment variable functions getenv and putenv are both
    now case-insensitive on Microsoft Windows systems. This should
    make your programs more portable.

o Return value from catch blocks.
    The return value from catch blocks that exit normally has been
    changed from a normal zero (i.e. zero_type 0) to UNDEFINED (i.e.
    zero_type 1).

o SSL
    The Pike SSL implementation now supports TLS 1.0. Also the LDAP
    protocol and the methods in HTTP.Query now support secure transport
    over SSL/TLS.

o Better predefine handling
    It is now possible to change the predefined cpp() macros without
    forking a new Pike process. Use the master functions add_predefine()
    and remove_predefine() to add and remove defines.


Language additions:
-------------------

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. An iterator object 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 end of the data set hasn't been reached yet.

    Also, if the object lacks a _get_iterator function, it will be
    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();

    Other available iterators include the file line iterator,
    available from Stdio.File through the method line_iterator(), and
    the split iterator that iterates over the fragments of a splitted
    string, available as String.SplitIterator.

o Automap
    To perform per-element operations on arrays, there is now a convenience
    syntax for map(), that can make code more readable in some situations.
    Summing up two arrays element by element using automap looks like this:

        a[*] + b[*]; // the result has as many elements as the shortest array.

    Multiplying all elements in a by a constant:

        a[*] * 4711;

    Make an array of what sprintf("%O", a[n]) returns for all elements in a:

        sprintf("%O", a[*]);

o Implicit lambda
    A convenient way to embed code that needs pre- and/or post-
    initialization. If a statement starts with a function call
    followed directly by a brace block, then the block is transformed
    to a lambda function which is passed as the last argument to the
    function being called.

    The following example embeds OpenGL calls that modifies the matrix
    in an implicit lambda that will save the matrix before execution
    and restore it afterwards:

       void PushPop( function f )
       {
         glPushMatrix();
         mixed err = catch(f());
         glPopMatrix();
         if (err) throw(err);
       }

       void do_something()
       {
         PushPop() {
           glTranslate( (1.0-0.08)/2, 0.0, 0.0 );
           draw_stuff();
         };
       }

    Note that although useful, this feature has important
    disadvantages and will probably be obsoleted by a better
    alternative in the future. The problem is that the inner brace
    block becomes a completely separate function instead of remaining a
    block. The difference (apart from being slower) is shown by this
    example:

       void do_something()
       {
         PushPop() {
           if (glError()) return;
           glTranslate( (1.0-0.08)/2, 0.0, 0.0 );
           draw_stuff();
         };
         draw_more_stuff();
       }

    Since the inner block is a separate function, the return statement
    doesn't exit do_something() as one might expect, causing
    draw_more_stuff() to be called even when there's a GL error.
    Another effect is that break and continue can't be associated with
    statements outside the implicit lambda block.

    Another method that overcomes these problems will likely be
    implemented. The problem is that there can be compatibility issues
    to change old code that uses implicit lambdas to that one. For
    example, the implementor of PushPop above can't safely switch to
    such a new method since that would make return statements like the
    one in do_something behave differently without giving any sort of
    error.

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 address hidden variables in the scopes of
    surrounding classes, e.g:

       class Foo {
         int i;
         void create (int i) {Foo::i = i;}
       }

o global::
    Added new keyword global to be able to access identifiers on the
    top level of the compilation unit using global::foo.

o global.
    All top level modules (and other identifiers in that scope) can now
    be accessed with a "global." prefix. This is useful in cases where
    local identifiers overshadow the top level, for instance in the Image
    module, where the Image.Image class can occasionally block your view.

o this
    Added a magic identifier "this" that can be used instead of
    this_object(). Like this_program, it only exists when there's no
    other identifier with that name. The primary reason for adding
    this magic identifier is to make it possible to address the object
    of a surrounding class with Foo::this.

o The program type can be specialized
    It's possible to specialize a program variable by adding a program
    identifier, much like an object variable can be specialized. E.g:

       program(Stdio.File) fd_prog = Stdio.File;

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 for use 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.

o UNDEFINED
    To generate a 0 (zero) with a zero_type(var) == 1, you previously
    had to use constructs like ([])[0]. This is now available as the
    globally available symbol UNDEFINED.

o _m_delete
    A class can now define a function mixed _m_delete(mixed index) to
    make the objects work like mappings with respect to m_delete().
    (This feature has been added to later 7.2 releases too.)

o Constant objects
    An object can now be constant, allowing for better performance
    and better dumping. Used for example with Gmp.Bignum, Math.Matrix
    and Image.Color.

o Increased weakness granularity
    Instead of just declaring a mapping as weak, to avoid its
    references to be counted during garbage collection, it is now
    possible to declare only the indices or only the values as weak.
    To this end set_weak_flag() now takes a second argument to define
    the kind of weakness its first argument should have; Pike.WEAK,
    Pike.WEAK_VALUES or Pike.WEAK_INDICES. No second argument implies
    Pike.WEAK, which is both Pike.WEAK_VALUES and Pike.WEAK_INDICES.
    (This feature has been added to later 7.2 releases too.)


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

o ADT.History
    ADT implementation of a "leaking stack". Hilfe example:
      > object h=ADT.History(3);
      > for(int i=17; i<22; i++) h->push(i);
      Ok.
      > h->get_first_entry_num();
      (1) Result: 3
      > h[3];
      (2) Result: 19

o ADT.Relation.Binary
    Handles binary relations. Hilfe example:
      > object r=ADT.Relation.Binary("test");
      > r->add(1,2)->add(2,3)->add(3,5)->add(1,4)->add(4,5);
      (1) Result: ADT.Relation.Binary("test")
      > r->find_shortest_path(1,5);
      (2) Result: ({ /* 3 elements */
                      1,
                      4,
                      5
                  })
      > r->remove(1,4);
      (3) Result: ADT.Relation.Binary("test")
      > r->add(5,1);
      (4) Result: ADT.Relation.Binary("test")
      > r->find_shortest_path(1,5);
      (5) Result: ({ /* 4 elements */
                      1,
                      2,
                      3,
                      5
                  })

o Array
    The array module has quite a few new and handy methods.
    common_prefix() finds the longest common prefix of the arrays in
    an array of arrays. count() counts the number of occurences of an
    element in an array. greedy_diff() is a greedy version of the diff()
    algorithm. oid_sort_func() is an ordering function for
    sort_array() that sorts SNMP OID values correctly. arrayify() is a
    simple helper function that makes arrays out of non-arrays.
    uniq2(), unlike uniq(), works as the UNIX uniq command. Finally
    sum() sums the elements of an array using +.

o Audio.Codec and Audio.Format
    Contain decoders/encoders and format parsers for audio using
    Ffmpeg library. Currently WAV and MP3.
    Note: The API remains marked "unstable".

o Crypto.md4
    Hash used for NT Lanmanager passwords.

o Crypto.crypt_md5
    Convenience function to produce crypted $1$ style crypted
    passwords (commonly called MD5 passwords).

o Debug
    Many top level debug functions have been moved into the Debug module
    to keep the amount of top level functions less intimidating to new
    users and to make the debug functions easier to find.

o Debug.Tracer
    A class that when instantiated will turn on trace, and when
    destroyed will turn it off again.

o Debug.Subject
    This is a probe subject which you can send in somewhere to get
    probed (not to be confused with a probe object, which does some
    active probing). All calls to LFUNs will be printed to stderr.

o DVB
    Access to DVB (digital sat) resources. Controls tuner, MP2 audio
    and video decoders. Allows extract multiple channels at once.
    Note: Only old 0.9.4 DVB API is supported.

o Gmp.mpq and Gmp.mpf
    Support for GMP multi-precision fractions and multi-precision
    floats. Hilfe example:
      > Gmp.mpq(5,3);          
      (1) Result: 5/3
      > _->invert();
      (2) Result: 3/5
      > (float)_;
      (3) Result: 0.600000
      > Gmp.mpq(5,3)+Gmp.mpq(1,2);
      (4) Result: 13/6

o Gz.File
    Pike can now compress and decompress the Gzip file format.
    This is still a bit experimental but the basic functions
    should work just fine.

o Image.filled_circle() Image.filled_circle_layer()
    Return an Image/Layer object with a filled circle.

o Image.Dims
    Can extract the dimensions of an image with a minimal amount of
    data loading. Currently handles JPEG, GIF and PNG images. Hilfe
    example:
      > Image.Dims.get(Stdio.File("test.gif"));
      (1) Result: ({ /* 2 elements */
                      1412,
                      1120
                  })

o Image.DWG
    Decodes the thumbnail images embedded in AutoCAD drawings.

o Image.Fonts
    High level API for font handling. Should be used instead of
    accessing the FreeType, TTF and Image.Font modules directly.

o Image.Image 
    Added two new methods, blur() and grey_blur(), which are hard
    coded, MMX optimized versions of these common matrix operations.

o Image.JPEG
    Support for lossless transforms, such as rotating and rescaling
    the image, and handling of metadata.

o Image.PVR
    VQ compression/decompression added.

o Image.SVG
    Support for Structured Vector Graphics through the Gnome SVG
    library. Requires Gnome 2.

o Local
    All Pike modules and classes found in the directory hierarchies
    /usr/local/pike_modules, /opt/pike_modules, /opt/share/pike_modules,
    /usr/local/share/pike_modules, $HOME/pike_modules, and
    $PIKE_LOCAL_PATH (a :-separated list of directories) are available
    with the prefix "Local.". Local.add_path() and Local.remove_path()
    respectively adds and removes entries from the list of paths to
    inspect when resolving Local.* symbols.

o Locale.Language
    Support for time formatting, counting and more for various
    languages. Currently supported languages are Catalan, Croatian, Czech,
    Dutch, English, Finnish, French, German, Hungarian, Italian,
    Japanese, Maori, Norwegian, Polish, Portuguese, Russian, Serbian,
    Slovenian, Spanish and Swedish.

o Math.Matrix
    Methods sum(), max(), min(), convolve() and dot_product() added.
    
o Math.Transforms
    Glue for supporting FFT and iFFT via libfftw and librfftw.

o Math
    Added the IEEE float constants inf and nan.

o MIME
    Added method ext_to_media_type, which returns the MIME media type for
    a given extension. The module currently knows of 469 different file
    extensions.The MIME.Message class has also been extended with a "guess"
    mode that parses input more forgivingly.

o Oracle
    The Oracle database glue now supports CLOBs and BLOBs.

o Parser
    Added a few methods: get_xml_parser(), which returns a Parser.HTML
    set up to parse XML, parse_html_entities() and
    decode_numeric_xml_entity(), which decode XML and HTML entities
    respectively.

    Examples:
      Parser.decode_numeric_xml_entity("#x7a") => "z"
      Parser.parse_html_entities("&gt;")       => ">"

o Parser.Python
    Splits Python source code into text tokens.

o Parser.RCS
    Extracts data from RCS or CVS repositories.

o Parser.XML.NSTree
    This is an extended version of Parser.XML.Tree that can handle
    namespaces according to the W3C namespace specification.

o Pike.Backend and Pike.DefaultBackend
    It is now possible to start several backends, and to start the
    default backend without having to return negative from main().

    Example:
      while(things_to_do) {
	mixed err;
	if (err = catch{
	  while(things_to_do) {
	    Pike.DefaultBackend(3600.0);
	  } }) {
	  master()->handle_error(err);
	}
      }

o Pike.Security
    If Pike has been compiled with security support, the security
    related stuff can now be found in this module.

o Protocols.XMLRPC
    Implements most features of the XML-RPC standard.

o Protocols.HTTP
    All methods in Protocols.HTTP that take a header mapping can now
    handle array values (signifying multiple headers of that type).

o Protocols.HTTP.Server
    A simple HTTP Server.

o Protocols.SNMP
    Extended to support both SNMP v1 and v2c. A simple SNMP agent with
    support for Get requests has also been added.

o Protocols.X
    Support for the X11 XTEST extension has been added.

o SDL
    Wrapper for a subset of Simple DirectMedia Layer
    functionality. Useful for writing games, movie players and other
    graphically intensive applications.

o Shuffler
    The shuffler module is what in aspect oriented and component based
    programming is called a connector. This connector provides an easy
    way to connect a data source to a file socket and transfer data
    between them until the data source runs dry, at which point the
    connection will be closed. The transfer can be throttled according
    to arbitrarily complex rules. All this with a minimum of attention.
    Currently the shuffler can use ordinary 8-bit wide strings,
    System.Memory objects, normal files, network sockets, named pipes,
    stdin and pike objects adhering to the Stdio.File API as connector
    sources.

o Standards.CIFF
    Experimental module to read Canon Camera Image File Format data.

o Standards.EXIF
    Support for the EXchangeable Image file Format for digital still
    cameras version 2.2. Support for maker notes for cameras from
    Nikon, Canon, Fuji Film, Olympus, Sanyo and Casio.

o Standards.FIPS10_4
    "The Federal Information Processing Standard for Countries,
    Dependencies, Areas of Special Sovereignty, and their Principal
    Administrative Divisions" = american standard for countries and
    country division codes.

o Standards.ID3
    ID3 tag decoder/encoder. Supports versions: 1.0, 1.1, 2.2-2.4.
    Frequently used in MP3 files for encapsulating metadata.

o Standards.ISO639_2
    This module has been updated with the map_to_639_1() method to
    convert from ISO 639-2/T to ISO 639-1. With the new methods
    convert_b_to_t() and convert_t_to_b() it is possible to convert
    between ISO 639-2/T and ISO 639-2/B.

o Standards.RDF
    Represents an RDF domain and allows you to perform searches in its
    relations. Currently only serializes/deserializes to N-triple
    format.

o Stdio
    Two higher order filesystem methods has been added to Stdio,
    simplify_path() and file_equal(). The first returns a canonic
    representation of its argument without "/./", "/../", "//" and
    similar path segments. The second is a speedy way to compare if
    two files have identical content.

    Finally the get_all_active_fd() function has been moved from
    spider to Stdio in our strive to deprecate the spider module.

o Stdio.FakeFile
    Wraps a string in an object that exports a Stdio.File interface.

o Stdio.File
    This object has received a few additions; With the sync() method
    the file object can be synchronized with the disk. It is now
    possible to open UNIX domain sockets with the connect_unix()
    method. Finally grantpt() can allocate a VTY on systems with
    /dev/ptmx support.

    Minimal example:
      fd = Stdio.File("/dev/ptmx", "rw" );
      Stdio.File fd2 = Stdio.File( fd->grantpt(), "rw" );
      Process.create_process( ({ "/bin/bash" }), ([
        "stdin":fd2,  "stdout":fd2, "stderr":fd2, "setsid":fd2, 
      ]) );

o Stdio.FILE.set_charset()
    It is possible to set the charset of a FILE object to get
    streaming and transparent charset conversion of data to and from
    the object.

o String
    Added a few new methods: int2char(), int2hex(), int2roman(), int2size(),
    which convert integers into different string representations, and
    expand_tabs(), which converts tabs to spaces.

    Examples:
      String.int2char(42)   => "*"
      String.int2hex(42)    => "2a"
      String.int2roman(42)  => "XLII"
      String.int2size(4200) => "4.1 kb"

   A soundex() method has also been added, which normalizes names according
   to the soundex algorithm. The algorithm in itself is not very useful,
   but some databases support it.

o String.Buffer
    A buffer used for building strings very fast.

o String.Elite
    Contains methods that transfer ordinary readable text into
    leet-speak. A fairly good argument could be laid out for putting this
    in Crypto as a one way cipher...

o String.HTML
    Contains methods that help in generating HTML.

o System
    The following methods have been added: normalize_path(), which works
    on NT style paths. get_netinfo_property(), which queries a NetInfo
    server on MacOS X. gettimeofday(), which uses the system gettimeofday
    to retrieve the time. nanosleep() and usleep(), which calls the
    system nanosleep and usleep functions.

o System.Time
    Used to get the current time with sub-second precision.

o System.Timer
    Measures the time between two calls.

o System.Memory 
    Handles read/write from mmap'ed or allocated memory.

o Tools.PV
    Convenience tool that sets up a canvas with GTK, presents a
    picture on it and delivers a number of image inspection and
    manipulation options. This is a great tool for image work in
    Hilfe.

      > object i=Image.Image(32,32)->random();
      > Tools.PV(i);

    The Pike Viewer tool is also accessible via "pike -x pv".

o Web.Crawler
    A generic asynchronus web crawler that supports the /robots.txt
    standard.


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

Several general optimizations and tuning of algorithms and
implementations in Pike have been done since Pike 7.2. Much of the work
has been to get a general speed up in the compiler and interpreter,
but some targeted work has also been done to make common code
constructions execute faster. A comparison between Pike 7.2.440 and
Pike 7.4.1 done on an IA32 machine running Red Hat Linux:

  	      Pike 7.2.440  Pike 7.4.1
   ackermann:         5.98  	  4.96
  	ary3:        10.60  	  6.53
  	fibo:         8.64  	  6.58
  	hash:         5.93  	  5.13
    heapsort:        10.88  	  6.65
       lists:         7.12  	  6.20
    methcall:         8.23  	  8.45
  nestedloop:        52.75  	 11.24
     objinst:         6.39  	  5.27
      random:         7.47  	  4.64
       sieve:        10.63  	  6.72
      strcat:         3.22  	  2.25

These tests use standard tests straight from The Great Computer Language
Shootout. If the lists test and the strcat tests are slightly modified
to use arrays in the first case and normal strings in the second case,
Pike will yield an even better result.

o Machine code generation
    On systems with IA32, SPARC or PPC32 processors Pike can use
    native machine code as byte code. This byte code can then be
    executed directly outside the virtual machine and give a ~30%
    performance boost compared to the old byte code.

o Improved module dumping
    More modules than ever can now be dumped successfully into object
    files, making the Pike startup time less than ever.

o Deferred backtraces
    Most of the information in backtraces is now calculated on demand
    for the backtrace information and not when the backtrace is
    generated. This improves the performance of catched errors.


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

The following changes are known to break compatibility. The old
behavior 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 shadowed identifiers has been
    added, so all such uses of local:: should be replaced with
    this_program::.

o Identifier lookup
    The search algorithm for finding identifiers from inherited classes
    has been changed to look for the most recent definition in the most
    recent inherit. In Pike 7.2 and prior, it looked up the last
    definition regardless of inherit depth, unless there was a
    definition in the current program. (This actually changed more than
    once during 7.3 - between 7.3.23 and 7.3.32, it looked up the most
    recent definition with the least inherit depth.) This example shows
    what the lookup strategies would find:

    class A {
      int foo() {}
    }

    class B {
      int foo() {}
      inherit A;
    }

    class C {
      inherit B;
    }

    class D {
      inherit B;
      inherit C;
    }

    Lookup of identifier "foo" in D():

    D-+-B-+-foo          (Pike 7.3.23 --- Pike 7.3.32)
      |   |
      |   +-A---foo
      |
      +-C---B-+-foo      Pike 7.3.33 --- (present day)
              |
              +-A---foo              --- Pike 7.3.22

    Lookup of identifier "foo" in C():

    C---B-+-foo          Pike 7.3.23 --- (present day)
          |
          +-A---foo                  --- Pike 7.3.22

    Lookup of identifier "foo" in B():

    B-+-foo              All versions of Pike
      |
      +-A---foo

o Individual parent object pointers are now only kept when needed
    In Pike 7.0 and 7.2 all objects kept a pointer to the surrounding
    object. This led to an excess of circular datastructures, which
    ment that the garbage collector had to kick in more often. In Pike
    7.4 parent object pointers are only kept if the object actually
    refers to identifiers in the parent. This change however affects
    the behaviour of object_program() and function_object().

    Examples:

      >  class A {
      >>   int q;
      >>   class B {
      >>     int inq(){return q++;}
      >>   }
      >>   class C {
      >>     int q;
      >>     int inq(){return q++;}
      >>   }
      >> }
      > indices(A);
      (1) Result: ({ /* 1 element */
                      "C"
                  })

      C doesn't refer to variables in surrounding classes, and is thus
      constant.

      > object a = A();
      > object b = a->B();
      > object c = a->C();
      > function_object(object_program(b));
      (2) Result: HilfeInput()->A()
      > function_object(object_program(c));
      (3) Result: HilfeInput()->A
      > function_object(object_program(b)) == a;
      (4) Result: 1
      > function_object(object_program(c)) == A;
      (5) Result: 1

      The b object has an intact parent object pointer, while the c
      object only has a parent program pointer.

o __pragma_save_parent__
    To change the default parent object pointer behaviour to the
    Pike 7.0/7.2 default it is possible to
    add_constant("__pragma_save_parent__", 1).

o #pragma save_parent
    To get the Pike 7.0/7.2 parent object pointer behaviour for a
    single compilation unit use the #pragma save_parent.

o #pragma dont_save_parent
    To restore the default Pike 7.4 parent object pointer behaviour from
    #pragma save_parent or __pragma_save_parent__ for a single compilation
    unit use the #pragma dont_save_parent.

o Thread.Condition()->wait()
    This function takes a mutex lock to unlock while it waits on the
    condition. That argument was previously optional, but not any
    more. The reason is that any code that leaves it out will always
    contain a race; it doesn't work to e.g. rely on the internal
    interpreter lock in this case.

o Protocols.LDAP.client()
    The return code from all methods has been changed to follow Pike's
    logic better. 0 is now a failure. The old behavior is emulated in
    a compatibility layer.

o dirname()
    Now correctly returns a directory instead of just stripping the
    part after the nearest directory separator.

o default_yp_domain()
    The EFUN default_yp_domain() is now only available as
    Yp.default_domain().

o clone()/new()
    The functions clone() and new() have been removed. Instead of doing
    clone(x) or new(x), now do x() if x is a program and ((program)x)()
    if x is a string.

o LR
    The LR module has been moved to Parser.LR and the API has been changed
    slightly to conform to current API practices, e.g. regarding casing
    of symbols.

o wmml documentation removed
    Use the documentation in the refdoc directory instead.

o .build_lobotomize_crypto removed
    Use the Makefile target lobotomize_crypto to lobotomize Pike.
    Should preferably be executed in an unused tree straight from CVS.


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

The following changes were considered bugfixes and have no backwards
compatibility layer.

o enum and typedef have implicit local binding
    Symbols defined by enum and typedef now always have static binding.
    In 7.2 they could sometimes be dynamically bound.

o Image.Layer modes modified
    Alpha channel handling for modes add, subtract, multiply, divide,
    modulo, invsubtract, invdivide, invmodulo, difference, max, min,
    bitwise_and, bitwise_or, bitwise_xor, screen and overlay modified so
    that the source layer alpha channel copied to the destination layer
    alpha channel rather then mixed with the current layer alpha channel:

    aD=aS

    rather then the behavior before:

    aD=(aL+(1-aL)*aS)

    (which is the behavior of the 'normal' mode.)


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

o Some global symbols have been renamed to avoid name clashes.
    sp           -> Pike_sp
    fp           -> Pike_fp
    fatal        -> Pike_fatal
    empty_string -> empty_pike_string

o C-module symbols not available from other modules.
    To avoid clashes between modules the symbols of dynamically loaded
    modules are now no longer available to each other. Modules that
    used this relied on a predefined load order of dynamic modules to
    work, so any such module could have failed to load unpredictedly.

o Pike valgrinded
    Pike has been the subject to some Valgrind scrutiny. Some specific
    Valgrind enhancements have been made to Pike to improve markup of
    forbidden memory areas. While all Valgrind issues are not yet
    resolved, partially due to Valgrind breakage, our confidence in
    the quality of Pike has been reassured.

o Some gdb helpers.
    If Pike is compiled with --with-rtldebug there's a function
    gdb_backtraces that can be called from gdb (using the "call"
    command) to print all Pike thread backtraces. It doesn't do any
    destructive changes of the memory structures (besides the stack)
    and it tries to be tolerant wrt inconsistencies.

    --with-rtldebug also makes a dummy function _gdb_breakpoint
    available in Pike. It doesn't do anything and is intended to be
    used by setting a gdb breakpoint on the C level counterpart
    pike_gdb_breakpoint and then use _gdb_breakpoint at the
    appropriate place in the Pike code to enter gdb at that point.


Bugs fixed:
-----------

To browse all bug tickets, visit http://pike.ida.liu.se/development/bugs/

o Reworked trampolines to cause less circular references. (solves 1937)

o It is now possible to inherit Pike programs from C programs.

o Now supports Autoconf 2.50 & Autoconf 2.52

o Modules with the constant dont_dump_mode will not be dumped, as a
  workaround for modules that can not yet be dumped.

o And many many more.


  Enjoy!

     The Pike Team
