January 28, 2021

Version 3.4.6 released

The parser has a built-in web server, activated when started with the option -p <port number> from the command line. In web server mode, requests are processed by the main method of the httpd class, which is added to the configuration auto.p and which implements the logic of the web server.

64-bit bit version of the parser for Windows is available.

Method ^image::measure[] now supports measuring of files in tiff, bmp, webp formats and with the $.video(true) option also mp4 (mov).

Method ^image::measure[] accepts options for XMP and EXIF load, $.xmp(true) and $.exif(true). Incompatible change: EXIF is no longer loaded by default as it is resource intensive.

Method for converting numbers from one base to another ^math:convert[] now supports arbitrary precision, it is possible to set your own alphabet, bases greater than 16 are now supported.

Methods for converting to base64 and back accept options $.wrap(false) to remove line breaks, $.url-safe(true) to use a modified alphabet (instead of “+” and “/” use “-” and “_”).

Method ^memory:auto-compact(N) is added to enable automatic garbage collection mode.

Method ^table.rename[column name from; column name to] is added to rename a column or multiple columns.

With the option $.http_version[2] you can tell curl protocol to use when connecting to a site.

Method ^file:copy[] accepts option $.append(true) to append a file to the end of another file.

Method ^[key;value](bool-condition)[options] is added (similar to ^[]) and method ^hash.reverse[] is added, which returns a hash with elements in reverse order.

^table.hash[] now supports unnamed tables, unnamed columns are not ignored.

The method for getting the date at beginning of the day ^date::today(N) accepts an optional parameter to shift by an arbitrary number days.

Method ^math:uuid[] accepts options $.lower(true) and $.solid(true) to get the GUID in lowercase and to exclude “-” from the result.

The ability to sequentially connect to several servers (if the first ones are unavailable) is implemented in the mysql driver, you can list servers in connection string, mysql://user:password@host1,host2,.../database.

Connection options config_file and config_group are added to the mysql driver for my.cnf load, multi_statements has been implemented.

As was done a long ago for hash, a whitespace string is now considered a valid argument for a table parameter, equivalent to an empty table.

When parser is used with fcgiwrap, fewer environment variables are required.

For large files $response:download[ $.file[] ] is now several times faster, partial file downloads (Range Requests) are processed correctly.

Method ^use[file] can be called with the $.main(true) option to load auto.p files from web server root to the directory with the file.

In the config method @conf[] you can set $.LOCALS(true) to make all variables local by default.

^xdoc::create[] supports parsing of very large files (using XML_PARSE_HUGE mode).

Exceptions in SQL are unified, now they all show the query that led to an error.

Diagnostics about ^curl:load[] and ^file::load[] methods errors is improved.

Libraries in use are updated: garbage collection gc (8.0.4), regular expressions pcre (8.43), xml (2.9.9), xslt (1.1.34).

Testing coverage of the parser source code has significantly increased.

Incoming emails parsing (-m command line option) supports gmime library version 3.X.

A number of bugs were fixed:

In 32-bit mode, parser now works correctly with files larger than 4Gb.

Looping in recursive class inheritance when using @autouse[] fixed.

Long e-mail headers are now split into multiple lines.

In Windows version the -f and -d methods now work correctly with Russian filenames in UTF-8.

In the Windows version, the error of moving directories ending with / has been fixed.

Assigning $result as the last action in the method is no longer failing to define the use of $result.

The calls ^return{code} and ^return(expre+ssion) work correctly.

The message length in $exception.comment is not limited to 1024 characters.

April 28, 2017

Version 3.4.5 released

Optimizations that accelerated access to variables, output of results and processing of expressions were carried out. In tests, the total acceleration is up to 15%.

The ^reflection:create[ $.class[class name] $.constructor[name of the constructor] $.arguments[hash of arguments] ] call is implemented, in which a variable number of arguments is supported.

^reflection:mixin[$source;options] method is added to copy fields and methods from one class to another. By default it copies to the class from which the method is called, that can be changed using $.to[where]. You can skip methods copying using $.methods(false) or the fields copying using $.fields(false). If you need to overwrite existing methods or fields when copying, you need to specify $.overwrite(true).

Using the new ^reflection:stack[] method it is possible to see the call stack in runtime. Unlike the exception stack, ^reflection:stack[] returns only the methods written in the parser. It is possible to see the parameters using $.args(true) and local variables using $.locals(true).

The object model was slightly changed. Now it’s more correct to say that “an object has a prototype class” then “an object is an instance of a class”. The difference is only when working with the static class properties from an object. By analogy with JavaScript — when reading $self.class_field, the class_field in the class is accessed, but when writing $self.class_field[value], the entry goes to the object and subsequent calls to $self.class_field read the value from the object.

It is now possible to work effectively with the object as with a hash using ^reflection:fields_reference[$o]. You could write $h[^hash::create[$o]] before, but fields_reference does not create a new hash with the same keys as the fields in the object, but creates a special linked hash, directly associated with the object. For example, if ^h.delete[name] called, the field name is removed in the associated object.

The operator ^return[] (^return[result]) is implemented, it exits the method when called.

The ^break[] and ^continue[] operators now have an optional parameter with the condition of their execution. Now, instead of ^if($condition){ ^break [] }, you can write ^break($​​condition).

Using the $ syntax, you can find out the name of the method.

Windows version now uses the Unicode API to work with files, so you can work with Russian file names not only in the Windows-1251 encoding, but also in UTF-8.

Limit on the size of file to be read by parser is added (by default 512MB). Under Windows ^file::stat[] now works correctly with files larger than 4 gigabytes.

Parameter $.from-charset[encoding] is added in ^file::create[]. Now the parser can be used to transcode data in any direction, not just to the specified encoding, as before.

With ^hash.contains[_default] you can check whether the default value was set in the hash.

A subtle point was associated with the _default key — not only the developer could set such a value. If the keys of the hash ware received from an external source, then the user could also pass _default, which could lead to incorrect code execution. Now _default is only perceived if it is written in the parser code.

The hash, in which only _default is specified, is now considered defined (def $h).

Hash write lock during hash elements iteration was removed.

It is possible to create a hash based on the file properties using ^hash::create[$file].

^reflection:method[$method;$object] call is added. When the result is called, $method will work in the context of $object ($self would be $object). This way, you can add or override the method in a specific object.

^reflection:filename[class or object or method] method is added to get the name of the file in which the class or method was defined.

To get information about the method reference, the ^reflection:method_info[$junction] call is supported.

With the new ^reflection:tainting[$string] method, you can see what transformations a string requires.

The result of ^reflection:methods[class name] call is now sorted in in reverse to the order of adding methods. With the optional $.reverse(false) option, you can specify a direct order.

When modules are used with @USE, the ^use[] operator is now called. It can be redefined and own logic for loading modules can be implemented. The parser implementation of the logic used in the parser ^use[] looks like this.

$.encloser[] option is added to ^table::create[] (similar to existing one in ^table::load[]).

The access to $string.something is now allowed (does not cause an exception) not only for empty strings, but for whitespace strings as well.

When local variable result is defined, the optimization is turned on, which removes all whitespace characters during compilation. Now in this mode you can use non-whitespace characters as well — earlier this led to an exception, now these characters are output to the result.

When the date is printed in the ISO 8601 format (^date.iso-string[]), $.colon(true/false) option was added to exclude the colon in the time zone, $.ms(true) option to add milliseconds (always .000) and $.z(false) option for the UTC time zone to be recorded as +00:00. When parsing a date the format of the time zone +hhmm is now understood.

In the date constructor with an enumeration of fields, an additional parameter in which you can specify a time zone is added.

Some date fields (year, month, day, hour, minute, second) can be changed, $date.year(2017).

In the configuration method @conf[], you can set the limit of iterations in cycles and the maximum depth of recursion. $LIMITS[ $.max_loop(20000) $.max_recoursion(1000) ] - the default values.

If $response:status is set to less than 100, it will be returned as the exit code of the parser process.

The new implementation of $caller has fixed some errors and allows you to get the calling method using $caller.method.

When sending messages (^mail:send[]), the multipart splitter is made random, the obsolete error-to header is removed.

In ^table.hash[] method you can now dynamically set not only the key, but also the value, ^table.hash {...;...}

^curl:load[] returns a hash tables with tables of all headers by analogy with ^file::load[].

A number of bugs were fixed.

April 28, 2016

The updated website is launched

To the day of the fourteenth “Parser” birthday the updated website is launched. Solutions for different tasks are grouped by tags in new “Library” section. Registered users have the possibility by their own add their sites to the “In action” section.
November 18, 2015
Version 3.4.4 released

Date range supported by date class is now extended. Dates from 0000-00-00 00:00:00 to 9999-12-31 23:59:59 are now supported.

Tables now can be edited. Now it is possible to change a cell value and to insert a row ($[value] and ^t.insert{row}).

Appended table row can be specified as a hash (^table.append[ $.a[string] $.b[string] ]).

Table and hash now have method search priority when a method is called (^table.count[]) and methods won’t be returned at all when a field is accessed ($table.count). Before there was method search priority in a table and field search priority in a hash regardless of access way, leading to issues when there was foreach key in a hash.

^hash.keys[], ^hash.count[], ^[...] methods are added to hash class in addition to existing methods, starting with _.

date class now supports a subset of ISO 8601 format, it is now possible to work with dates in any time zone (^date::create[2015-09-08T18:24:52+03:00]).

It is now possible to set the default time zone when server time zone differs from desired web-site time zone, ^date:roll[TZ;MSK-3].

Supported number range is now extended from 32 to 64 bits for ^math:convert[...] function and when a number is specified in hexadecimal form (0XNN).

Support for IDNA (international domain names) is now implemented when using HTTP file load and as separate encoding and decoding methods (^string.idna[] and ^string:idna[encoded string]).

Methods to work with DNS are added: ^inet:name2ip[name; $.ipv[4|6|any] $.table(true) ] to resolve a name into an IP address and ^inet:ip2name[ip; $.ipv[4|6|any] ] for reverse resolving.

$var.CLASS and $var.CLASS_NAME usage is now optimized and processed during compilation.

Hash now can be sorted using string ^hash.sort[key;value]{string-key-maker}[[asc|desc]] or number ^hash.sort[key;value](numeric-key-maker)[[asc|desc]] expression.

^hash.delete[] (without parameters) now clears existing hash.

$request:headers, $request:method, $request:field are added (before this information was available only using $env).

A header in $response:fields can be deleted by specifying an empty value.

HTTP method PUT is now supported.

^curl:info[...] method is added. It returns information about the last request.

$.response-charset options can be specified in ^file::load[...] call (to be used if the service returns incorrect charset).

^string.left(-1) now returns the whole string.

^string.trim[set] call is now supported and is equivalent to ^string.trim[both;set] call.

^string:js-unescape[...] now returns “dirty” string.

^string:unescape[[js|url];escaped; $.charset[charset] ]] method is added.

^json:string[...] method name now can be passed in $._default parameter, and if a method with this name exists in a object, it will be called for the object serialization.

^json:string[...] output format for undefined values can now be set either as empty string ($.void[string]) or as null ($.void[null], by default).

^json:parse[...] error reporting is now improved, json fragment is now included in the exception and separate messages for common mistakes are added.

^json:parse[...] now has option $.int(false) to disable json integers conversion to parser numbers, leaving them as strings.

^reflection:def[;name] method is added to check class existence.

^reflection:class_by_name[class_name] method is added to get class by its name.

^reflection:is[element_name;class_name] method is added. It extends is operator functionality and allows to check if $element_name is junction.

^table.count[columns] now works for nameless tables.

^[...] now can return not only value, but key or key-value pair as well.

double class variable no longer can have NaN or Inf value, ^math:sqrt(-1) calculation will throw an exception.

Compile-time exceptions structure is now unified with run-time exceptions.

Garbage collection library libgc is updated from version 7.2d to version 7.2f and regular expressions library pcre is updated from version 8.33 to version 8.37.

libgc memory limit under Windows is increased and no dialog is shown if memory exception occurs.

A number of bugs were fixed.
November 01, 2013
Version 3.4.3 released

Class curl now has option $.ipresolve(0|1|2). Also, the default is changed from IPv6(2) to IPv4(1).

Method ^curl:load[] now parses incoming cookies and stores them in a field cookies that contains table with columns name, value, expires, max-age, domain, path, httponly and secure.

Now it is possible to get a list of all server’s environment variables with their values using $env:fields.

The second parameter of method ^file:list[] now can be a hash. In this case a filter should be specified as $.filter[string or regex-object].

Method ^file:list[] now returns a table with columns name, dir, size, cdate, mdate and adate. Values for name and dir are always returned (dir value 1 means that the record is a directory). To get information about directory entries’ sizes and dates the option $.stat(true) should be specified.

Method ^file:delete[] now accepts option $.exception(false) that can be used to suppress exception in case of file deletion is failed.

Methods ^file:delete[] and ^file:move[] how accept option $.keep-empty-dirs(true) that can be used for keeping empty directories in place after deleting or moving all files in these directories.

Constructor ^file::load[] now accepts option $.response-charset[] that can be used to force remote charset encoding. Unfortunately, in real world some servers report incorrect charset encoding in HTTP response headers so this option is a solution for such cases.

Method ^json:string[] now accepts option $.indent as a bool as well as user predefined indent’s prefix string.

Method ^json:string[] now prints all characters in range 0×01-0×1F except allowed ones (\b \f \n \r \t) as \u00XX.

Method ^math:digest[md5|sha1|sha256|sha512;string or file; $.format[hex|base64] $.hmac[key]] added.

Class memcached how has method ^memcached.release[] that can be used for closing connection to a server.

Method ^reflection:method_info[] for user defined methods now also returns $.call_type, $.max_params and $.extra_param.

Class table now has method ^table.csv-string[[nameless;] $.encloser["] $.separator[,] ] that is very similar to existing method ^[].

Class table how has method ^table.foreach[rownum;value]{code}[[separator]] that is similar to method ^hash.foreach[]. Note that value variable will contain the same table object with modified row postion set.

Now the exception occurs in case of loading class if the class with the same name is already loaded. It can be switched off by specifying a new $.replace(true) option in operators ^use[] and ^process{}

@SET_DEFAULT and @GET_DEFAULT now work with static classes as well.

Double numbers now printed with higher precision (16 vs 5).

An ability to receive email is restored.

Methods ^[], ^string.double[] and ^string.bool[] were optimized.

Oracle SQL driver now sets environment variables prior client’s library loading.

PgSQL SQL driver now accepts a new option standard_conforming_strings=1 that can be used for switching off char ’\’ escaping to conform SQL standards.

JSON library replaced by another one that is under GPL.

The latest versions of libraries are included: GC (7.2d), PCRE (8.33), libxml2 (2.9.1) and libxslt (1.1.28).

The process of building Parser3 under *nix is redesigned. A single „buildall” script should be used.

Under windows operation system libraries , libxml2 and libxslt now are linked statically. It means that the only one executable file and SQL drivers dll-s are needed.

A number of bugs were fixed.

June 29, 2012
Version 3.4.2 released
Class curl supports three new options: verbose, stderr and maxfilesize.

Added constructor ^date::today[] that creates date object for today’s midnight (00:00:00).

Method ^date.sql-string[] supports options “datetime”, “date” and “time”. It returns date + time, date only and time only respectively.

Constructor ^file::create[...] supports binary format as well.

Constructor ^file::create[...] now also supports another format: ^file::create[string or file[;$.name[file name] $.mode[text|binary] $.content-type[...] $.charset[...]]].

Constructor ^file::create[text;...;content] normalizes end of lines (EOLs) in the content. While creating binary objects the EOLs normalization does not occur.

Methods ^file:dirname[filespec], ^file:basename[filespec], ^file:justname[filespec] and ^file:justext[filespec] handle filespecs in windows format.

Methods ^file:dirname[filespec] and ^file:basename[filespec] work exactly as *nix commands of the same names.

Constructor ^file::load[...;http://...] parses incoming cookies and stores them in a field cookies—table with columns name, value, expires, max-age, domain, path, httponly and secure.

Constructor ^file::base64[encoded;options] and method ^string:base64[encoded;options] accept an option $.strict(true). If the option is specified the exception will be thrown if decoding all characters is not possible. Without this option they return the only characters that were decoded successfully. While base64-decoding memory usage is reduced.

In the body of ^hash.foreach method it is possible to call some methods of iterated hash (such as ^hash._count[], ^hash._keys[], ^hash.contains[key] and ^hash._at[...]). It does not cause an exception “hash flocked” any longer.

Method ^json:string[object;options] searches method that was specified using $.class-name[$method] option through all the ancestors as well.

Method ^json:string[object;options] can serializes objects of class xdoc. Parameters for converting xdoc into string can be passed into $.xdoc[] option.

Method ^json:string[object;options] accepts value stat in addition to values text and base64 as a content of $.file[] option.

Method ^json:string[object;options] accepts an option $._default[$method]. Using this option you can specify user-defined method that will be used for serializing all objects of user-defined classes.

Method ^json:parse[json-string;options] accepts an option $.array[$method] that will be used for processing all arrays.

Method ^json:parse[json-string;options] accepts an option $.taint[transformation type]. The specified transformation type will be applied for every string in resulting hash.

Method ^json:parse[json-string;options] parses all numbers as double.

The range for ^math:convert[...] has been increased. Overflowing during convertion causes an exception.

Parser has native memcached servers support (using libmemcached library).

Added method ^reflection:uid[object] that returns a unique object’s identifier.

Added method ^reflection:delete[class or object;field name] that can be used for deleting object’s field (the method has the same functionality as ^hash.delete[key], but works with user-defined classes and objects).

Methods ^reflection:method[class or object;method name] and ^reflection:field[class or object;field name] are added. Using these methods you can access method or field of class or object.

Method ^string.match[] handles unicode properties in character classes \w etc if worked in UTF8.

Method ^string.replace[...] can be called with two parameters: “search string” and “replace string”.

Method ^table.count[] accepts options. Called with an option columns it returns a number of columns in the named table (works as: $c[^table.columns[]]^c.count[]). Called with an option cells it returns a number of cells in the current row. Called with an option rows it returns a number of rows in the table (works exactly as ^table.count[]).

Method ^[options] accepts negative values in $.offset option. In this case the rows are counted from the end of the table (-1 means the last row).

DOM-methods createElement, createElementNS, createAttribute, createAttributeNS, createEntityReference, getAttribute, getAttributeNS, setAttribute, setAttributeNS, removeAttribute, removeAttributeNS, getAttributeNode, getAttributeNodeNS, hasAttribute, hasAttributeNS, getElementById, getElementsByTagName, getElementsByTagNameNS validate incoming parameters.

Method ^xdoc.file[options] accepts a new option $.name[file name].

Methods ^xdoc.string[options] and ^xdoc.file[options] accept a new option $.charset[] that works exactly as an option $.encoding[]. You can not specify both of these options however.

If a ^switch or a ^case have bool value they will be compared as bool (they were compared as double before).

Calling operators ^break[] and ^continue[] outside of cycles throws exceptions “parser.break” and “parser.continue” respectively instead of “parser.runtime”.

By specifying $STRICT-VARS(true) in configuration method of MAIN (@conf[]) you can switch strict vars mode on. In this mode the access to uninitialized variables will cause an exception.

Transformation type file-spec does not replace “&apos;” (apostrophe) character any longer (it was replaced by “_26” before).

MySQL driver accepts a new option local_infile=1 that can be used for switching on the support of LOAD DATA LOCAL if MySQL server was compiled without —enable-local-infile option (more details).

The latest versions of libraries are included: PCRE (8.30) and libxml2 (2.8.0).

A number of bugs were fixed.

February 24, 2011
Version 3.4.1 released

Now Parser3 has native JSON support.

Now Parser3 is able to load files from external HTTP/HTTPS servers using libcurl library.

Now Parser3 tries to search files loaded in @USE/^use[] relatively from the file where these @USE/^use[] are written.

Now user defined methods can handle variable number of parameters: @method[arg;*args] (a hash with numeric keys will be in a variable $args.

Acceptable call types now can be defined for user methods. In meta-command @OPTIONS parameter dynamic or static can be specified (default — any), which will influence to all methods of the file. Particular methods can be declared as statical: @static:method[params].

A special default setter (@SET_DEFAULT[name;value]) can be defined in user classes. This setter will be called during writing to unknown fields of the class/object.

Operator if now can have several “elseif” sections, for example: ^if(a>0){1}(a==0){0}{-1}.

User defined classes do not inherit method @auto[] any longer.

Class void now has all methods available for class string. This means that strings’ methods can be called for undefined variable as well.

Class hash now has a new method ^hash._at($index) (or ^hash._at[first|last]) that can be used for accessing element by its index (hashes’ elements are ordered since version 3.4.0).

Operator ^apply-taint[[transformation-type]][...] was added. This operator applies inplace transformation to all tainted parts of the string. Parts within undefined transformation type will be processed using specified transformation type (as-is by default).

Method for converting numbers from one base to another was added.

Method ^[options] now supports options $.limit(X) and $.reverse(true|false).

Method ^string.match[...] now can supports four parameters. The value of fourth parameter is returned if nothing was found in the string.

Unknown ^string.match[...] options now cause an exception.

Method ^string:js-unescape[...] now also decodes \uXXXX-encoded symbols.

Constructor ^file::base64[encoded] now also supports another format: ^file::base64[text|binary;file-name;enoded[;$.content-type[...]]].

An option $.content-type[...] now can be specified during creation of file’s object.

Method ^reflection:copy[$src;$dest] was added.

Options $.encloser[#] and $.separator[#] now switch the automatics comments removing off while loading table or file.

Parser3 now ignores white-space characters that are written between methods’ definitions.

Parser3 now ignores trailing white-space characters in @META commands (@USE, @CLASS, @BASE, @OPTIONS) and their values.

Unsafe Parser3 version do not have restrictions to environment variable names passed to executed scripts any longer.

The third option of method ^image.replace(color-from;color-to)[poligon] is not compulsory any longer. If not specified the color will be replaced in whole image.

A text file, which is loaded without $.charset option specified, that contains a BOM code, will be transcoded from UTF-8 to $request:charset automatically.

In a field $.inherited method ^reflection:method_info[class-name;method-name] now returns the name of class where the method is actually defined.

In a field $.overridden method ^reflection:method_info[class-name;method-name] now returns the name of ancestor’s class where the overridden method is defined.

In a field $.file method ^reflection:method_info[class-name;method-name] now returns the full file specification where the method is defined.

Using $request:post-body now it is possible to get POST-request body as a file.

Latest versions of libraries are included: PCRE (8.12) and libxml2 (2.7.8).

A number of bugs were fixed.

July 08, 2009
Version 3.4.0 released

Now Parser3 can be compiled as 64-bit executable. However, keep in mind that it will use more memory than 32-bit version.

Many optimizations were done. Now Parser3 uses much less memory and executes faster.

Method @GET[] now can be defined with a parameter. Context type is passed in this parameter, so the method’s code might distinguish calls in different contexts.

Classes can not be derived from system classes any longer.

Now regular expressions are studied after the compilation. In some cases it makes search faster.

New class regex was added. You can reuse once created regex-pattern and use it many times.

New class reflection was added. Using this class it is possible to get detailed information about classes and their methods.

Now constructor ^file::load[mode;http://server/] is able to send files to the remote HTTP servers.

Now hash knows the order of its elements. Methods ^hash.foreach[...]{...} and ^hash._keys[...] process the elements in this order.

Now the normalization of EOLs is occured after base64-decoding data into a string.

Now ^taint[js][...] converts characters with code \x0D to “\r”.

New taint-transformation parser-code was added.

Now the body of operator process is subject to untaint-transformation with parser-code type. This means that Parser3 code that came from untrusted sources (file, DB, cookies, form, etc) will not be executed any longer. To fix it you have to replace ^process{...} with ^process{^untaint[as-is]{...}}.

Constructor ^file::create[...] now can accept three parameters. In the third parameter an option $.charset[encoding] can be specified for creating file in the required encoding.

Objects of class file now have a new field mode.

Rows of nameless tables now are available as a hash.

The third parameter of method ^image.font[...] is not mandatory any longer. If not specified, the space width will be equal to image width. Also, now it can be specified as a hash with options $.space(space width), $.width(character witch), $.spacing(distance between characters).

Now constructors are also inherited from ancestors so they should not be defined right into class as before.

Access to undefined class now triggers the execution of @autouse[name]. In the operator’s body the lazy class loading can be implemented.

Now it is possible to define the encoding during saving of file or string.

Now HTTP and mail headers are capitalized.

Now Parser3 escapes international characters in sending emails using base64 instead of uue (you still able to use option $.format[uue] to use uue escape method).

Now base64 and uue encoding use less memory.

Now ^rem{...} operator is removed during compilation instead of dummy-execution.

Latest versions of libraries are included: GC (7.1), PCRE (7.9), libxml2 (2.7.6) and libxslt (1.1.26).

Plenty of bugs were fixed.

September 04, 2008
Version 3.3.0 released

Parser3 now encodes cookies in a different way (%uXXXX instead of %XX). This allows to work with cookies encoded by Parser3 on client-side using JavaScript.

User defined classes now can have method @GET[] which is executed during accessing the object in scalar context: ^if($oMyObject){...}.

User defined classes now can have default getter (@GET_DEFAULT[name]) — a special getter which is executed during reading unknown classes fields.

Additional methods can also be added to an existing class using a new meta-command @OPTIONS with a value partial.

All variables in a file can be declared as locals using a new meta-command @OPTIONS with a value locals.

All method’s variables can be declared as locals using just one keyword locals instead of listing all of them.

Several classes now can be defined in one file.

Constructor ^hash::sql{...} now accepts a new option $.type[hash|table|string] with the same meaning as the same option of method ^table.hash[...].

Objects of class file which were loaded locally have fields $.adate, $.mdate and $.cdate straight away.

Now try operator has finally section.

Now the encoding of incoming POST requests can be gotten from $request:post-charset. This encoding is used for transcoding incoming request from instead of $response:charset.

New methods to convert IP address to int and vice-versa were added.

Constructor ^file::sql{...} now accepts options $.limit and $.offset.

New constructor ^date::create[date-object] was added.

Method ^str.pos[substr] now can also accept the beginning search position as a second parameter.

The body ot case statement now can be specified as an expression.

Symbols @ and # now can be added at the beginning of lines using the common Parser3 escaping sybmol ^.

New methods ^str.js-escape[] and ^string:js-unescape[encoded] were added. They are equivalent to JavaScript functions escape and unescape.

A new version of PCRE library brings plenty of features including named sub-patterns, recursions and many others.

Parser3 now knows more EXIF tags (including GPS-related).

Option $.limit(0) in SQL queries is not ignored any longer.

SQL drivers were updated. The new version of Parser3 is not working with the old drivers.

Format of ODBC driver’s options has changed. Now it is the similar to other drivers formats.

SQLite, ODBC and PostgreSQL drivers now accept option autocommit=0.

Oracle’s driver now uses Oracle’s specific and modifies SQL queries. In some cases you would like to disable this behaviour using new options DisableQueryModification=1.

ODBC driver now accepts new option SQL=MSSQL|Pervasive|FireBird. It can be usable for forcing the driver to speedup queries execution by modifying them in a specified manner.

Path to DB file for SQLite driver now should be specified related to document-root.

SQL drivers were optimized and the changes is especially notable in Oracle and ODBC drivers.

Methods of class string, such as ^str.length[], ^str.left(len), ^str.right(len), ^str.mid(from;len), ^str.pos[substr] and ^str.match[...] now work with strings in UTF-8 encoding correctly.

Some bugs were fixed.

Latest versions of libraries are included: PCRE (7.7), libxml2 (2.6.32) and libxslt (1.1.24).

April 10, 2008
Version 3.2.3 released

Bugs which were introduced in version 3.2.2 were fixed.

Latest versions of xml/xslt libraries included.

Few new methods added: ^hash.contains[], ^date:last-day(year;month), ^date.last-day[], ^date.gmt-string[].

December 27, 2007
Version 3.2.2 released

Lots of bug fixes and new features: check out documentation, look for [3.2.2] version-marks.

In short:

Driver for SQLite was released (thanks to Niko and Creator).

Locks on unix were fixed.

Latest versions of xml/xslt libraries included.

Many new file methods added like: copy, md5, base64, crc32.

And many others improvements and bug fixes.

March 17, 2006
Versions 3.1.6sp2 and 3.2.1sp2 released

Error with $.encloser[] in was fixed;

Security issue in mail:send was fixed;

^string:base64[encoded] didn’t work in version 3.2.1.

December 29, 2005
Version 3.1.6 released

Fixed long-hiding error which occured when working with XML via DOM properties/methods.

December 29, 2005
Version 3.2.1 released

Completely rewritten DOM inteface with XML, now Parser does that without gdome library (and glib too);

Compiling Parser (with XML!) from source code on Unix became trivial. Now one can download/unpack Parser source code and run one shell script. See INSTALL for details.

Some compiler error messages (in hard cases) made clearer.

December 08, 2005
Version 3.1.5 released

Lots of bugfixes and new features: check out documentation, look for [3.1.5] version-marks.

December 08, 2005
Version 3.2.0 released

Introducing properties.

This version is compiled with latest XML and memory management libraries.

December 24, 2004
Version 3.1.4 released

Several bugfixes.

ODBC: changed recommended connection strings. DSN is inconvinient and not required actually—there is simple way to connect without one.

Hashfile: increased limit of size of data that can be stored there: now key+value can be up to 8000 bytes.

Win32, IIS: added support to help using “Page not find” error to organize virtual adresses (an analogue to Apache/mod_rewrite).

May 28, 2004
Version 3.1.3 released

Bugfix release, minor changes.

May 28, 2004
English version of site is opened
March 26, 2004
Version 3.1.2 released

New class: hashfile, implemeting hash on disk with support of individual key/value pairs expiration.

November 07, 2003
Version 3.1.1 released

String operations speed increased two times.

UTF-8 support in methods string.upper/lower (Simple case).

July 25, 2003
Version 3.0.8 released
July 25, 2003
Version 3.1.0 released

Now memory occupied by unused objects can be freed ("unused"—not referenced from variables): ^memory:compact[], $status:memory.

December 27, 2002
Version 3.0.7 released
December 16, 2002
Version 3.0.6 released
August 02, 2002
Version 3.0.5 released
June 13, 2002
Lesson 6. Working with XML

Lesson 6. Working with XML

April 29, 2002
Official Parser 3.0 release

Published: source code; binary versions for Win32, FreeBSD, Linux; documentation on language (in Russian) and source code.