/ 
Inline-SLang-1.00
River stage zero No dependents
/ Inline::SLang::Changes

NAME

Inline::SLang::Changes - Changes to previous versions of the module

DESCRIPTION

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.

CHANGES

v0.30 Tue Jun 8 21:00:16 EDT 2004

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.

v0.26 Fri Apr 16 00:07:13 EDT 2004

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).

v0.25 Tue Apr 13 22:56:06 EDT 2004

Another one-line fix and PDL support works on OS-X. PDL support is now the default option (if available) when building Inline::SLang.

v0.24 Tue Apr 13 22:16:12 EDT 2004

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.

v0.23 Wed Apr 7 21:32:07 EDT 2004

This is a bug-fix for make test in version 0.22, which failed on systems which did not already have Inline::SLang installed.

v0.22 Wed Apr 7 16:29:05 EDT 2004

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.

v0.21 Mon Apr 5 15:15:51 EDT 2004

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.

v0.20 Wed May 21 00:37:07 EDT 2003

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.

v0.12 Sun May 11 23:33:38 EDT 2003

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.

  • 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.

v0.11 Wed May 7 00:39:17 EDT 2003

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.

  • 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.

  • DataType_Type objects can now be compared for equality (==, eq) and inequality (!=, ne).

v0.10 Sat May 3 19:39:00 EDT 2003

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.

  • 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}.

  • 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.

  • 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).

  • 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.

v0.06 Thu Apr 3 22:36:54 EST 2003

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).

  • "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.

  • 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'.

v0.05 Fri Mar 14 11:57:31 EST 2003

Notable changes are:

  • 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).

    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.

  • 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.

v0.04 Fri Mar 7 00:14:47 EST 2003

Notable changes are:

  • 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.

  • 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.

v0.03 Tue Jan 28 12:01:49 EST 2003

Initial public release