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.
Inline::SLang
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.
2x3
3x2
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.
make test
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.
requires v2.4.0 of PDL which isn't actually released (a fairly-recent CVS build should do the trick)
conversion betweed 1D arrays and piddles works
should 0D piddles be converted to a scalar or a 1-element 1D array? (currently the code croaks)
> 1D arrays is a mess since a 2x3 array in S-Lang maps to a 3x2 piddle. The first time this happens a warning is printed to STDERR as a precaution. Not sure what the best approach is.
It has not been tested on non 32-bit machines.
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:
Added support to the 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.
DataType_Type
Int16_Type
Int32_Type
Float32_Type
Float64_Type
Short_Type
Long_Type
The build process now checks that the S-Lang library was built with support for floating-point and complex numbers. If it was not then it should stop.
Added a brief section to this document describing how S-Lang errors are handled.
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:
S-Lang arrays can now be converted to the Perl Array_Type object as well as array references. The behaviour is controlled by the Inline::SLang::sl_array2perl() function, described in Inline::SLang.
Array_Type
Inline::SLang::sl_array2perl()
It is now easier to create Perl scalars that contain a 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.
Inline::SLang::<datatype name>()
DataType_Type->new( "<datatype name>" );
'!types'
EXPORT
DataType_Type objects can now be compared for equality (==, eq) and inequality (!=, ne).
==
eq
!=
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.
Support for S-Lang libraries earlier than 1.4.7 has been discontinued.
Perl class names have been changed from Inline::SLang::XXX to XXX.
Inline::SLang::XXX
XXX
S-Lang structs (both 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}.
Struct_Type
x
$foo
$$foo{x}
S-Lang 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.
Assoc_Type
Assoc_Type [Any_Type]
Arrays can now be converted between Perl (array references or Perl 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).
Several Inline::SLang::XXX routines can now be exported to Perl's main package by use of the EXPORT configuration option (rather than the standard Perl way of using 'use foo qw( ... );'. This can be looked at as something of a hack.
Handling of S-Lang errors has been improved: they are now caught and then converted into Perl errors (i.e. calls to 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).
croak
fixed mem leak when converting structs from Perl to S-Lang. Note that the code used *may* trigger a mem leak in the S-Lang library if you are using a version < 1.4.9.
Notable changes are:
Essentially all S-Lang scalars can now be converted to Perl. Those without a direct translation to a native Perl type are converted to "opaque" Perl objects, with classes called 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).
File_Type
FD_Type
"Named" structures - e.g. 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.
Foo_Type
typedef struct {...} Foo_Type;
Inline::SLang::Struct_Type
Fixed handling of BIND_NS => "All".
Added an examples/ directory to the distribution, which contains simple examples (mainly from Inline::SLang::Types). Note that these files are not installed into the Perl tree by 'make install'.
Handling of 'foreign' S-Lang types - those for which we have introduced special classes such as 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).
Inline::SLang::
Inline::SLang::struct
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.
Ref_Type variables are now supported (scalars only) via the 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.
Inline::SLang::Ref_Type
The BIND_NS option only works for v1.4.3 and higher of S-Lang. The option has been enhanced to allow namespace "renaming" and the use of "All" to specify all known namespaces (this only works for v1.4.7 and higher of S-Lang). The only valid string options are now "Global(=...)" and "All".
The BIND_SLFUNCS option has been added to allow you to use slected S-Lang intrinsic functions directly from Perl (i.e. without having to write a S-Lang wrapper function around it). To help avoid nameclashes you can chose your own name for the function in Perl.
Documentation on S-Lang specific configuration options has been moved to Inline::SLang::Config.
License changed to GNU GPL and copyright holder to SAO.
Now binds all functions (other than S-Lang intrinsic functions) in the Global namespace. Added the 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.
BIND_NS
S-Lang Struct_Type variables are converted to Inline::SLang::struct objects. There are memory leaks!
Fixed memory leaks when converting Assoc_Type arrays to Perl.
S-Lang Struct_Type variables are converted to Inline::SLang::struct objects.
Initial public release
To install Inline::SLang, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Inline::SLang
CPAN shell
perl -MCPAN -e shell install Inline::SLang
For more information on module installation, please visit the detailed CPAN module installation guide.