Log message:
recursive bump for boehm-gc API bump

Log message:
recursive bump from libffi shlib major bump
(additionaly, reset PKGREVISION of qt4-* sub packages from base qt4 update)

Log message:
"user-destdir" is default these days

Log message:
Ad hoc fix to make OpenAxiom build with CLISP on NetBSD/amd64.

It sounds like COMPILE-FILE is broken in CLISP on NetBSD/amd64.
Silence warnings and suppress redefinition check in order to compile it
without a single warning.

Log message:
Add forgotten patches.

Log message:
Update to OpenAxiom 1.4.1

Changes in OpenAxiom-1.4.1

Algebra

The domain ScriptFormulaFormat and the package ScriptFormulaFormat1 have been \ 
removed.

Changes in OpenAxiom-1.4.0

This release introduces the following changes from the base document
("AXIOM: The Scientific Computation System" by Jenks and Sutor).

Compiler

  * The compiler now accepts interpreter-style unnamed functions.
  * The compiler now generate far better (Lisp) codes for Spad libraries
    or scripts. The compiler now applies more aggressive (but sound)
    optimizations, including domain inlining, type propagations.
  * The compiler now accepts interpreter-style unnamed functions.
  * Parameterized macros are now supported by the compiler.
  * The compiler now support exception handling. In particular,
    the try/finally programming construct was added to support reliable
    resource management (e.g. opening/closing or creating/removing files.)

Algebra

In addition to novelties in OpenAxiom-1.3.0, the following types have been
added to OpenAxiom-1.4.0:

  * The category BooleanLogic has been added.
    It is now extended by PropositionalLogic and BitAggregate.
    The domain SingleInteger now satisfies BooleanLogic.
  * It it now possible to obtain the string representation of a
    DoubleFloat value. The function

       string: DoubleFloat -> %

    was added to the domain String
  * A function matrix is now exported by the category MatrixCategory
    to allow construction of matrices whose entries can be succinctely
    described by a function. For instance, the 4-by-4 Hilbert matrix
    may be expressed as

       m: Matrix Fraction Integer := matrix(4,4,(i,j) +-> 1/(i+j))

    Note that the third argument is a function that computes the value
    of the (i,j)th entry.
  * The category StringCategory was removed as it was essentially redundant
    with the category StringAggregate.
  * The category MappingCategory is now part of the algebra as a builtin
    category constructor.
  * The following operators

       less?: (%,NonNegativeInteger) -> Boolean
       more?: (%,NonNegativeInteger) -> Boolean
       size?: (%,NonNegativeInteger) -> Boolean

    have been moved from the category Aggregate to StreamAggregate
    where they seem more appropriate.
  * The domain InnerTaylorSeries now satisfies the category BiModule.
  * The domains FreeModule and OrderedFreeMonoid now satisfy the newly
    added FreeMonoidCategory.
  * The list of domains for OpenAxiom program manipulation has been expanded.
  * Support for range and segment bindings now includes RangeBinding.

Boot

Boot, the programming language used to write the OpenAxiom compiler,
has been vastly improved. Lisp codes are being phased out.

Log message:
Requires libffi when using ECL.

Log message:
Ignore compilation failure on CLISP: COMPILE-FILE returns failure-p
but CLISP doesn't list any errors.

Log message:
Dragonfly hack is no longer needed.

Log message:
Update to OpenAxiom 1.3.0

Changes since previous release:

Compiler

  - The compiler now treats ^ as alias for **.
  - The compiler now rejects ambiguous left hand sides of
    definitions where parameter types are left out for
    inference. Previously, the compiler would pick the first
    signature from some mostly random order, with a warning.
  - For categories with default implementations, the compiler
    can be directed to compile only the purely category part
    (exports), or only the default implementations (category
    packages).
  - The compiler now supports a Foreign Function Interface. In
    particular, signatures for external entities may be declared
    at capsule level. Currently, only ISO C functions are
    supported, but future releases may support ISO C++ and other
    mainstream languages.
  - The parsing of signature for operators has been improved.
    Previously, operator names needed to be quoted in signature.
    That is not longer needed. For instance, previously, one had
    to write (at category level)

                       "*": (%,%) -> %
                       _/_\: (%,%) -> %
                       _not: % -> %

    With this release of OpenAxiom and onward, one can simply write

                       *: (%,%) -> %
                      /\: (%,%) -> %
                     not: % -> %

    which is much simpler to read, write, and much more regular.
  - The compiler now supports is-case pattern matching. The new
    pattern matching syntax is useful for structuring retractions,
    and also for domain recovery from expressions of type Any.
  - The compiler now supports the loop control transfer operator
    iterate in repeat loops - previously, the construct was
    accepted only in scripts (not libraries). That discrepency is
    now ended.

Interpreter

  - Declared variable with no specified values are now handled
    as if symbolic value with a specified type.
  - The interpreter now parses a disjunctive expression
    involving the 'is' operator the obvious way. E.g. Now

                T is Integer or T has Ring

    is now understood as

                (T is Integer) or (T has Ring)

  - The interpreter now handles existentially quantified or
    universally quantified expressions

Algebra

The following types have been added to OpenAxiom-1.3.0

  - The domain Boolean and category BitAggregate no longer
    export the operation ^ for logical negation. Use the
    operator not which is the canonical and documented operator.
  - The domain InputForm now has a new exported signature

                     parseString: String -> %

    for parsing expressions given as string.
  - The domain Boolean now belongs to the category
    OrderedFinite.
  - The domain KleeneTrivalentLogic is added. It implements
    Stephen Kleene's 3-valued propositional logic.
  - For file orinted I/O, new domains have been added:
      + IOMode: This domains defines three constants to indicate
        the direction of file I/O operations.
      + InputBinaryFile: This domains implements the basic input
        operations on binary files.
      + OutputBinaryFile: This domains implements the basic
        output operations on binary files.
  - The domain BinaryFile has been replaced by three specific domains:
      + InputBinaryFile: datatype for input file open in binary mode;
      + OutputBinaryFile: datatype for output file open in binary mode;
      + InputOutputBinaryFile: datatype for input and output file open
      	in binary mode.
  - Three new categories are introduced, related to conversions:
      + CoercibleFrom: This category is the mirror image of the
        standard category CoercibleTo.
      + HomotopicTo: This category is the symmetrization of the
        category CoercibleTo.
      + ConvertibleFrom: This category is the mirror image of
        ConvertibleTo.
  - Previous releases defined instantiations of the domain
    constructor Expression as satisfying the category OrderedSet.
    That was both confusing and incorrect in conjunction with
    other algebraic structures. From now on, Expression(T) no
    longer satisfies OrderedSet.
  - Three new categories have been added:
      + LeftLinearSet
      + RightLinearSet
      + LinearSet
    The category AbelianGroup extends LeftLinearSet Integer.
    The parameterized category constructor LeftModule extends
    LeftLinearSet. Similarly, the category RightModule extends
    RightLinearSet.
  - The domain Any has been reworked. In particular, the
    operation domainOf, objectOf, and showTypeInOutput have been
    removed. Equality of two objects of domain Any is equality
    according to the underlying domain, if that domain belongs to
    the category BasicType; otherwise, it is equality of storage
    locations.

Runtime System

  The Lisp backend now uses type information derived from exports
  and domain representation for code generation purposes.