pike.git / CHANGES

version» Context lines:

pike.git/CHANGES:44:    |    | // Override the Bar inherited from Foo.    | class Bar {    | // Bar is based on the implementation of Bar in Foo.    | inherit ::this_program;    | // ...    | }      o Implemented the variant keyword.    -  The keyward was present before, but did not actually do anything +  The keyword was present before, but did not actually do anything    useful.       This is used to do function overloading based on the argument types.       As an example:    | class Test1 { int b(); }    | class Test2 { int a(); }    |    | class Foo    | {    | variant string foo( object q ){ return "Genericfoo"; }    | variant string foo( Test1 x ) { return "Test 1"; }    | variant string foo( Test2 x ) { return "Test 2"; }    |    | variant string bar( int(0..0) s ) { return "0"; }    | variant float bar( int(1..1) s ) { return 1.0; }    | variant int bar( int(2..2) s ) { return 2; }    | }    -  A common usecase is functions that return different types depending +  A common use-case is functions that return different types depending    on the arguments, such as getenv:       | string|mapping(string:string) getenv( string|void variable );       can now be rewritten as       | variant string getenv( string variable );    | variant mapping(string:string) getenv( );    -  which gives siginificantly better typechecking. +  which gives significantly better type-checking.    - o The typechecker has been rewritten. + o The type-checker has been rewritten.       Mainly it is now much better at finding type errors, and most error    messages are more readable.      o Allow '.' to be used as an index operator in the few places it did    not work before.      o "Safe" index    Copied from a popular extension to other C-like languages.   
pike.git/CHANGES:129:    happen if you pass an empty argument, nor does it happen if the    token preceding ‘##’ is anything other than a comma.      o The preprocessor can now be run with a cpp prefix feature.    This is currently used by the precompiler to avoid two levels of    preprocessing, one using "#cmod_" as the prefix and the other "#".      o Dynamic macros    You can now add programatic macros. There is currently no syntax    that can be used to define these while compiling code, but you can -  add them from one program before compiling plugins/modules. +  add them from one program before compiling plug-ins/modules.       The main use is macros like DEBUG(...) and IFDEBUG() that would    expand to something if a debug setting is enabled in the module but    nothing otherwise, or, to take an actual example from the Opera    Mini source code:       | add_predefine( "METRIC()",    | lambda( string name, string ... code )    | {    | string type = type_of( code );
pike.git/CHANGES:197:    thing (binarytrees) from O(n^2) to O(n), and as such is more than a    simple percentual speedup in some cases, but it always improves the    performance some since the base speed is also faster.      o Power-of-two hashtables are now used for most hashtables       This speeds up mappings and other hashtables a few percent, and also    simplifies the code.      o Significantly changed x86-32 and an entirely new AMD64/x86-64 -  machinecode compilation backend +  machine-code compilation backend       The main feature with the x86-32 edition is that it is now using    normal function call mechanics, which means that it now works with    modern GCC:s.       The x86-64 backends has been rewritten so that it is easier to add    new instructions (x86-64) and opcodes (pike) to it.      o Svalue type renumbering   
pike.git/CHANGES:236:    lower_case, upper_case, search and string_has_null for now.    It could be added to other places in the future as well.       The fairly common case where you are doing lower_case or upper_case    on an already lower or uppercase strings is now significantly    faster.      o Several other optimizations to execution speed has been done    + object indexing (cache, generic speedups)    + lower_apply, changes to apply in general -  Taken together these individuallt small optimizations speeds up at +  Taken together these individually small optimizations speeds up at    least pike -x benchmark more than 5%. -  + A lot of opcodes implemented in machinecode for x86-64 +  + A lot of opcodes implemented in machine-code for x86-64    This speed up the loop benchmarks close to a factor of 3. But then    again, most real code is nothing like that benchmark.    + Several new opcodes added    As an example an observation was that most branch_if_zero is    followed by an is_eq, is_lt or is_gt or similar. Those opcodes    always return 1 or 0. So, two new opcodes, quick_branch_if_zero    and quick_branch_if_non_zero were added that map directly to three    x86-64 opcodes, there is no need to check the types, do a real    pop_stack etc.   
pike.git/CHANGES:280:    used.      o It is no longer possible to compile pike without libgmp.    Bignums are now a required language feature      o The old low-level 'files' module has been renamed to _Stdio      o 'GTK' is now GTK2, not GTK1 unless the system has no GTK2 support.      o Locale.Charset -  The charset module is now available on the toplevel as 'Charset' +  The charset module is now available on the top level as 'Charset'      New modules   -----------      o Pike.Watchdog    A Watchdog that ensures that the process is not hung for an extended    period of time. The definition of 'hung' is: Has not used the    default backend.       To use it simply keep an instance of the watchdog around in your
pike.git/CHANGES:346:      o Serializer    APIs useful to simplify serialization and deserialization of    objects Mainly it allows you to easily iterate over the object    variables, including the private ones.       + Serializer.Encodable    A class that can be inherit to make an object easily serializable    using encode_value.    - o Filesystem.Monitor and the lowlevel System.Inotify + System.FSEvents + o Filesystem.Monitor and the low level System.Inotify + System.FSEvents    Basic filesystem monitoring.       This module is intended to be used for incremental scanning of a    filesystem.       Supports FSEvents on MacOS X and Inotify on Linux to provide low    overhead monitoring; other systems currently use a less efficient    polling approach.      o Mysql.SqlTable
pike.git/CHANGES:415:   o Image.JPEG    + decode now supports basic CMYK/YCCK support    + exif_decode is a new function that will rotate the image    according to exif information      o String.Buffer    String.Buffer can now add the storage from a different String.Buffer    object with the add() method.       It is possible to add sprintf-formatted data to a String.Buffer -  object by claling the sprintf() method. This function works just as +  object by calling the sprintf() method. This function works just as    the normal sprintf(), but writes to the buffer instead.       The new method addat() allows for writing into the buffer at any    position.      o SDL.Music added to SDL.    Allows the playback of audio/music files.    Requires the SDL_mixed library.      o System.TM
pike.git/CHANGES:471:   o Thread.Farm now might work      o Cmod precompiler.    + inherit "identifier"    -- inherit the program returned by calling master()->resolve() on    the specified identifier. Useful to inherit code written in pike.      o String.levenshtein_distance()    The function calculates the Levenshtein distance between two    strings. The Levenshtein distance describes the minimum number of -  edit operations (insert, delete or substitue a character) to get +  edit operations (insert, delete or substitute a character) to get    from one string to the other.       This can be used in approximate string matching to find matches    for a short string in many longer texts, when a small number of    differences is expected.      o System.sync()    Synchronizes the filesystem on systems where this is possible -  (currently windows and unix-like systems). +  (currently windows and UNIX-like systems).      o System.getloadavg()    Return the current 1, 5 and 15 minute system load averages as an array.      o glob()    The glob function has been extended to accept an array of globs as    the first (glob pattern) argument.       In this case, if any of the given patterns match the function will    return true, or, if the second argument is also an array, all    entries that match any glob in the first array.      o Stdio.UDP(): -  + added ipv6 multicast support +  + added IPv6 multicast support    + added set_buffer      o Stdio.File():    + send_fd and receive_fd    These functions can be used to send and receive an open -  filedescriptor over another filedescriptor. The functions are +  file-descriptor over another file-descriptor. The functions are    only available on some systems, and they generally only work -  when the file the descriptors are sent over is a unix domain +  when the file the descriptors are sent over is a UNIX domain    socket or a pipe.       + Changed internally to remove one level of indirection.    The Stdio.File object no longer has a _Stdio.Fd_ref in _fd. They    are instead directly inheriting _Stdio.FD.       _fd is still available for compatibility, but internally it is gone.      o Unicode databases updated to 6.3.0 from 5.1.0    This is the latest released Unicode database from unicode.org.
pike.git/CHANGES:535:       + Fixes for queries where the same world occur multiple times    ('foo and bar and foo')      o pike -x benchmark    + Output format changed    + Also added support for JSON output.    + The results should be more consistent.    + Added options to allow comparison with a previous run.    - o New standalone tools added to make it possible to build + o New stand-alone tools added to make it possible to build    documentation without the pike build tree    + autodoc_to_html    AutoDoc XML to HTML converter.    + autodoc_to_split_html    AutoDoc XML to splitted HTML converter.    + git_export_autodoc    Exports a stream of autodoc.xml suitable for git-fast-import.    Used on pike-librarian.      o Readline tries to set the charset to the terminal charset
pike.git/CHANGES:563:    + draw_pixbuf can now be passed width and height -1, which makes it    take the size from the passed image.    + GDKEvent no longer crash when you extract strings from them    + accelerators now work    + Fixed RadioToolButton    + signal_connect can now connect a signal in front of the list    + Several fixes to Tree related objects    + GTK2.SourceView added    + GTK2.Spinner added    - o A few issues were fixed that were found by coverity + o A few issues were fixed that were found by Coverity    + Fixed memory leak in Math.Transform    + Fixed two compares that were written as assignments (errno    checks for EINTR for sockets)      o System.get_home + System.get_user -  (mostly) Cross-platform ways to get the username and home directory. +  (mostly) Cross-platform ways to get the user name and home directory.      o System.AllocConsole, System.FreeConsole and System.AttachConsole for NT    These are useful to create or close the console window that is    shown for pike programs.      o Process - forkd    Forkd can be used to more cheaply create new processes on UNIX like    systems.       This is done by first starting a sub-process that is then used to
pike.git/CHANGES:640:    (aka TDS 565) 225 (SR 14111:1998), 197/209 (sami) 208 (IS 434:1997)    207 (IS 433:1996), 204,205 and 206 (aka 8859-1, 8859-4 and 8859-13    with euro) 201, 200, 138 (ECMA-121) 198 (ISO 8859-8:1999) 182, 181,    189 (TCVN 5712:1993, aka VSCII) 167, 166 (aka TIS 620-2533 (1990)),    164, 160, 151 (NC 99-10:81), 68 (APL), 59 (CODAR-U), 202 (KPS    9566-97). Fixed CSA_Z242.4      o Several fixes to Protocols.HTTP    + Improved Protocols.HTTP.Query.PseudoFile    (significantly better Stdio.Stream simulation) -  + Do not use hardcoded Linux errno:s +  + Do not use hard coded Linux errno:s    + Case insensitive handling of header overrides in do_method    + Fixed broken check for URL passwords when querying    + Add more descriptive HTTP responses along with a mostly complete    list of codes    + Handle non-standards compliant relative redirects    + Cleaner handling of async DNS failures    + Handle chunked transfer encoding correctly when doing async    queries    + Fixes for the proxy client support    + Several keep-alive handling fixes    + Server:    - More forgiving MIME parsing for MSIE    - Fixed range header handling    - Fixed parsing of broken multipart/form-data data    - Added optional error_callback to attach_fd    - The response processor (response_and_finish) now treats the    reply mapping as read-only.    - Support if-none-match (etag:s)    - Ignore errors in close when destroying the object    - o dtrace support (on macosX) + o dtrace support (on MacOSX)    Pike now supports dtrace events on function enter and leaving (and    when stack frames are notionally popped, for functions doing    tailrecursion).      Crypto and SSL   --------------      o SNI client extension support for SSL (Server Name Indicator)      o Standards.PEM
pike.git/CHANGES:696:      o Blowfish and Serpent support fixed in Nettle      o Crypto.PGP       Added support for SHA256, SHA384 and SHA512 as hash functions.    Expose the used hash and key types in the out data      o Crypto.CAMELLIA    -  The 128/256 bit cipher CAMELLIA is now availble as block cipher in +  The 128/256 bit cipher CAMELLIA is now available as block cipher in    Crypto. In addition the following cipher suites have been added to    SSL:       TLS_rsa_with_camellia_128_cbc_sha    TLS_dhe_dss_with_camellia_128_cbc_sha    TLS_dhe_rsa_with_camellia_128_cbc_sha    TLS_rsa_with_camellia_256_cbc_sha    TLS_dhe_dss_with_camellia_256_cbc_sha    TLS_dhe_rsa_with_camellia_256_cbc_sha