pike.git / CHANGES

version» Context lines:

pike.git/CHANGES:32:       | inherit Foo;    |    | // Override the Bar inherited from Foo.    | class Bar {    | // Bar is based on the implementation of Bar in Foo.    | inherit ::this_program;    | // ...    | }    - o Actually implemented the variant keyword. + o Implemented the variant keyword.    -  +  The keyward 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"; }
pike.git/CHANGES:91:    vs       | request_id && request_id->user && request_id->user->misc    | && request_id->user->misc->x      o Added the '?:' operator for compatibility with other C-like    languages. It is identical to '||' in pike, and this is not /really/    needed.      o The && operator changed, when doing A && B, and A is false, keep A -  instead of pushing 0. +  instead of returning 0.       This is especially useful then A is not actually 0, but an object    that evaluates to false, or UNDEFINED.      o Added new syntax that can be used to return an object as if it was a    class you are inheriting, X::this where X is the inherited class.      o Support for ", ##__VA_ARGS__" cpp feature.      o The preprocessor can now be run with a cpp prefix feature.
pike.git/CHANGES:127:    | lambda( string name, string ... code )    | {    | string type = type_of( code );    | string aggregate = aggregate_of( code );    | string format = format_of( code );    | code -= ({ 0 });    | return replace( base_metric_class,    | (["ID":(string)next_metric_id++,    | "NAME":stringify(name),    | "TYPE":type, -  | "AGGREGATE":aggregate, -  | "FORMAT":format, +  | "AGGREGATE":aggregate, +  | "FORMAT":format,    | "CODE":make_value_function(code), -  | ])); +  | ]));    | });          That is, a macro that needs does some calculations, and rewrite the    code more than is possible in normal macros..       This one expands something along the lines of       | METRIC("requests", Summarize, PerSecond,    | floating_average_diff(requests));
pike.git/CHANGES:168:   Optimizations   -------------      o New significantly faster block allocator    The free in the old one was O(n^2), which means that as an example    creating a lot of objects and then free:ing them mainly used CPU in    the block allocator.       This fix changed the ordo of one of the tests that did that very    thing (binarytrees) from O(n^2) to O(n), and as such is more than a -  simple percentual speedup. +  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       The main feature with the x86-32 edition is that it is now using
pike.git/CHANGES:197:    PIKE_T_INT is now type #0, which makes certain things significantly    faster.       As an example, clearing of object variables is now done    automatically when the object is created since all object memory is    set to 0.       The same thing happens when clearing values on the stack.      o string(x..y) (constant) types -  | > typeof("foo"); -  | (1) Result: string(102..111) -  also used to optimize lower_case/upper_case search and -  string_has_null etc. +        The strings now keep track of the min/max values in addition to two    new flags: all-uppercase and all-lowercase.    -  +  | > typeof("foo"); +  | (1) Result: string(102..111) +  +  This is used to optimize certain operations, +  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    least pike -x benchmark more than 5%. -  +     + A lot of opcodes implemented in machinecode 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, fast_branch_if_zero and -  fast_branch_if_non_zero were added that map directly to three +  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.      o Faster hash-function for strings    + Also siphash24 was added and is used in case the string hash table    becomes inefficient    -  + Removed features and modules + ----------------------------    - Deprecated features and modules - ------------------------------- -  +    o Removed facets    The optional (and not enabled by default) support for facet classes    has been removed, since it was only partially done and not really    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   
pike.git/CHANGES:405:    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    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 -  +     Low-level wrapper for struct tm.       This can be used to do (very) simple calendar operations. It is,    as it stands, not 100% correct unless the local time is set to    GMT, and does mirror functionality already available in gmtime()    and localtime() and friends, but in a (perhaps) easier to use API.    -  + o decode_value now throws the error object Error.DecodeError.    - --- UNSORTED +  Useful to catch format errors in the decode string.    - o SDL.Music added to SDL. -  Allows the playback of audio/music files. -  Requires the SDL_mixed library. + o Process.daemon    - o decode_value now throws the error object Error.DecodeError. -  Useful to catch format errors in the decode string. +  The daemon() function is for programs wishing to detach themselves +  from the controlling terminal and run in the background as system +  daemons.      o Debug.pp_object_usage() -  Pretty print debug information, useful to get debug information +  +  Pretty-print debug information, useful to get debug information    about object counts and memory usage in pike applications.       Uses the new _object_size lfun, if present in objects, to account    for RAM-usage in C-objects that allocate their own memory.      o Mysql - Support more modern client libraries (incl. MariaDB)      o Standards.PEM: Added some support for encrypted PEM files      o Nettle refactored
pike.git/CHANGES:460:      o Stdio.UDP    + added ipv6 multicast support    + added set_buffer      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 sprintf("%H") and sscanf("%H") (new) sscanf("%n") (now documented, existed before (%!<X> modifier, used by optimizer)) -  +    o Image.JPEG.exif_decode    - o Process.daemon -  The daemon() function is for programs wishing to detach themselves -  from the controlling terminal and run in the background as system -  daemons. + 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.PGP - support more hash functions. -  +    o String.levenshtein_distance()    That 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    from one string to the other.       The algorithm 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 Unicode databases updated to 6.2.0 + o System.sync() +  Synchronizes the filesystem on systems where this is possible +  (currently windows and unix-like systems).    -  + o System.getloadavg() +  Return the current load average. +  + o Unicode databases updated to 6.2.0   o Timezone databases updated to tzdata2013d    - o System.sync() - o System.getloadavg() +    o Stdio.File()->send/receive[_fd]   o The Search module has seen several fixes   o Standalone tools added:    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.    pv Pike image viewer (diet).      o Lots of GTK2 fixes   o Crypto.crypt_hash()