Inline::SLang::Changes - Changes to previous versions of the module
This document lists the changes to previous versions of the Inline::SLang module.
See the "Changes" section of the Inline::SLang documentation for the changes in the latest version.
This is intended to be the last release before the release of version 1.00.
I have decided to stick with the differences between the indexing of multi-dimensional arrays in PDL and S-Lang: a 2x3 element piddle will be converted to a 3x2 element S-Lang array.
The PDL support has been upgraded to better-handle virtual piddles, such as slices of another piddle. The current approach has the side effect of calling PDL's make_physical() method on the piddle, which results in extra memory use.
Minor bug fixes to Makefile.PL.
Minor documentation fixes - including exampes/array_conversion.pl - and improvements to Inline::SLang::Details - including the addition of examples/order.pl.
Fixed a bug which caused t/11type_synonyms.t to fail on some machines.
The S-Lang interpreter is now initialised with the min, max, sum and cumsum functions as part of the S-Lang run-time library (cumsum is only available if you have v1.4.9 of S-Lang).
Another one-line fix and PDL support works on OS-X. PDL support is now the default option (if available) when building Inline::SLang.
A one-line fix means that PDL support now works on Linux as well as Solaris. It works on OS-X until you try to convert a S-Lang array to a piddle. PDL support is now on by default for Solaris and Linux machines.
This is a bug-fix for make test in version 0.22,
which failed on systems which did not already have Inline::SLang installed.
The build process has been changed to use Inline::C to embed C code within Makefile.PL, rather than having it in a separate file which we have to compile ourselves. This should hopefully make the build process a bit more portable.
This release will now build on OS-X machines. The support for PDL has been turned off by default - even if PDL is installed on your system - since it does not work on Linux and OS-X machines.
The main changes are behind the scenes, and involve splitting the code up and making a tad more modular.
This release begins support for the Perl Data Language in Inline::SLang.
Please note that it is a work-in-progress.
This is a minor upgrade in functionality to version 0.11; the changes are made to help support the inclusion of PDL in a future release. The changes are:
DataType_Type class for numeric types that are - or may be - synonyms of the "base" types.
The added types are: Int16_Type,
Int32_Type,
their unsigned versions,
Float32_Type,
Float64_Type,
and - if they are not a "base" type - Short_Type and Long_Type.This release makes a couple of improvements to version 0.10 and includes infrastructure changes to support PDL (although piddles are still not supported). The major changes are:
Array_Type object as well as array references.
The behaviour is controlled by the Inline::SLang::sl_array2perl() function,
described in Inline::SLang.DataType_Type object: use the functions Inline::SLang::<datatype name>() instead of DataType_Type->new( "<datatype name>" );.
Use '!types' in the EXPORT configuration option to import all these functions.DataType_Type objects can now be compared for equality (==,
eq) and inequality (!=,
ne).There have been a number of significant enhancements and changes in this release, which is why the release number has been bumped-up to the lofty heights of 0.10.
The really-short summary is that all variables should now be supported and the support for S-Lang's associative arrays, normal arrays, and structures has been made much -more Perl like.
Inline::SLang::XXX to XXX.Struct_Type and named structs) are stored using a Perl object (also called Struct_Type) which can be treated as a hash reference.
As an example,
if the S-Lang structure has a field x and it is stored in the Perl variable $foo then you can access the field as $$foo{x}.Assoc_Type arrays are now converted to the Perl Assoc_Type class (and vice-versa).
This object can be treated as a hash reference.
When calling S-Lang functions,
hash references are converted to S-Lang as an Assoc_Type [Any_Type] array.Array_Type objects) and S-Lang (Array_Type variables) for any S-Lang data type.
Any dimension of array supported by S-Lang is now available (in previous only one and two dimensional arrays could be used).
Support for piddles is not yet available (planned soon).
croak).
This means that calling DataType_Type->new() with an unknown type name no longer results in S-Lang error messages printed to STDERR (which it did in 0.06).Notable changes are:
Inline::SLang::XXX where XXX equals the name of their S-Lang data type.
Essentially all you can do with these objects is pass them back to S-Lang routines.
However,
it does mean you can now call routines that return module-defined types.
Currently the S-Lang file types (so File_Type and FD_Type) are converted using this scheme,
which means you can not use them with Perl I/O commands.
I need to read up a lot more on Perl's I/O mechanism before I can change this (if it's possible).
Foo_Type created by typedef struct {...} Foo_Type; - are now handled as Inline::SLang::XXX objects,
where XXX matches the structure type (so Foo_Type in this example).
These classes are sub-classes of Inline::SLang::Struct_Type.Notable changes are:
DataType_Type variables - has been changed to use a scheme in which the Perl class name is formed from the concatanation of Inline::SLang:: and the S-Lang type (so Inline::SLang::struct has been renamed to Inline::SLang::Struct_Type).
The classes are also more uniform in that they have a number of common functions and, where possible, the method names are similar to S-Lang functions with the same functionality.
Inline::SLang::Ref_Type class.
Unfortunately this requires use of function/types that are not part of the public interface of the S-Lang library.Notable changes are:
BIND_NS configuration option to allow functions in other namespaces to be bound as well.
Use the Inline '-MInline=INFO' option to find out what functions have been bound.Struct_Type variables are converted to Inline::SLang::struct objects.
There are memory leaks!Assoc_Type arrays to Perl.Struct_Type variables are converted to Inline::SLang::struct objects.Initial public release
