* algebra/syntax.spad.pamphlet: Rename from algebra/syntax.spad.

	Add a new domain for constructor instantiation form.
	* algebra/Makefile.pamphlet (axiom_algebra_layer_1): Include
	CTORCALL.o 
	(SYNTAX.NRLIB/code.$(FASLEXT)): Remove rule.  Now implicit.
	* share/algebra: Update databases.

1 files changed, 0 insertions, 225 deletions

diff --git a/src/algebra/syntax.spad b/src/algebra/syntax.spad
deleted file mode 100644
index f6d0719e..00000000
--- a/src/algebra/syntax.spad
+++ /dev/null
@@ -1,225 +0,0 @@
---Copyright (C) 2007, Gabriel Dos Reis.
---All rights reserved.
---
---Redistribution and use in source and binary forms, with or without
---modification, are permitted provided that the following conditions are
---met:
---
---    - Redistributions of source code must retain the above copyright
---      notice, this list of conditions and the following disclaimer.
---
---    - Redistributions in binary form must reproduce the above copyright
---      notice, this list of conditions and the following disclaimer in
---      the documentation and/or other materials provided with the
---      distribution.
---
---    - Neither the name of The Numerical Algorithms Group Ltd. nor the
---      names of its contributors may be used to endorse or promote products
---      derived from this software without specific prior written permission.
---
---THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
---IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
---TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
---PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
---OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
---EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
---PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
---PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
---LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
---NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
---SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-)abbrev domain SYNTAX Syntax
-++ Author: Gabriel Dos Reis
-++ Date Created: November 10, 2007
-++ Date Last Updated: December 05, 2007
-++ Description:  This domain provides a simple, general, and arguably 
-++ complete representation of Spad programs as objects of a term algebra
-++ built from ground terms of type boolean, integers, foats, symbols, 
-++ and strings.  This domain differs from InputForm in that it represents
-++ any entity from a Spad program, not just expressions.
-++ Related Constructors: Boolean, Integer, Float, symbol, String, SExpression.
-++ See Also: SExpression.
-++ Fixme: Provide direct support for boolean values, arbritrary 
-++        precision float point values.
-Syntax(): Public == Private where
-  Public ==> Join(UnionType, CoercibleTo(OutputForm)) with
-    convert: % -> SExpression
-      ++ convert(s) returns the s-expression representation of a syntax.
-
-    convert: SExpression -> %
-      ++ convert(s) converts an s-expression to syntax.  Note, when `s'
-      ++ is not an atom, it is expected that it designates a proper list,
-      ++ e.g. a sequence of cons cell ending with nil.
-
-    coerce: Integer -> %
-      ++ coerce(i) injects the integer value `i' into the Syntax domain
-
-    coerce: % -> Integer
-      ++ coerce(s) extracts and integer value from the syntax `s'
-    autoCoerce: % -> Integer
-      ++ autoCoerce(s) forcibly extracts an integer value from
-      ++ the syntax `s'; no check performed.  To be called only
-      ++ at the discretion of the compiler.
-
-    coerce: DoubleFloat -> %
-      ++ coerce(f) injects the float value `f' into the Syntax domain
-
-    coerce: % -> DoubleFloat
-      ++ coerce(s) extracts a float value from the syntax `s'.
-    autoCoerce: % -> DoubleFloat
-      ++ autoCoerce(s) forcibly extracts a float value from the syntax `s';
-      ++ no check performed.  To be called only at the discretion of
-      ++ the compiler
-
-    coerce: Symbol -> %
-      ++ coerce(s) injects the symbol `s' into the Syntax domain.
-
-    coerce: % -> Symbol
-      ++ coerce(s) extracts a symbol from the syntax `s'.
-    autoCoerce: % -> Symbol
-      ++ autoCoerce(s) forcibly extracts a symbo from the Syntax
-      ++ domain `s'; no check performed.  To be called only at
-      ++ at the discretion of the compiler.
-
-    coerce: String -> %
-      ++ coerce(s) injects the string value `s' into the syntax domain
-
-    coerce: % -> String
-      ++ coerce(s) extracts a string value from the syntax `s'.
-    autoCoerce: % -> String
-      ++ autoCoerce(s) forcibly extracts a string value from
-      ++ the syntax `s'; no check performed.  To be called only at
-      ++ the discretion of the compiler.
-
-    buildSyntax: (Symbol, List %) -> %
-      ++ buildSyntax(op, [a1, ..., an]) builds a syntax object for op(a1,...,an).
-  
-    buildSyntax: (%, List %) -> %
-      ++ buildSyntax(op, [a1, ..., an]) builds a syntax object for op(a1,...,an).
-
-    nil?: % -> Boolean
-      ++ nil?(s) is true when `s' is a syntax for the constant nil.
-
-    getOperator: % -> Union(Integer, DoubleFloat, Symbol, String, %)
-      ++ getOperator(x) returns the operator, or tag, of the syntax `x'.
-      ++ The return value is itself a syntax if `x' really is an 
-      ++ application of a function symbol as opposed to being an
-      ++ atomic ground term.
- 
-
-    getOperands: % -> List %
-      ++ getOperands(x) returns the list of operands to the operator in `x'.
-
-    compound?: % -> Boolean
-      ++ compound? x is true when not an atomic syntax.
-
-    _case: (%, [|Integer|]) -> Boolean
-      ++ x case Integer is true is x really is an Integer 
-
-    _case: (%, [|DoubleFloat|]) -> Boolean
-      ++ x case DoubleFloat is true is x really is a DoubleFloat
-
-    _case: (%, [|Symbol|]) -> Boolean
-      ++ x case Symbol is true is x really is a Symbol
-
-    _case: (%, [|String|]) -> Boolean
-      ++ x case String is true is x really is a String
-
-  Private ==> SExpression add
-    rep(x: %): SExpression ==
-      x pretend SExpression
-
-    per(x: SExpression): % ==
-      x pretend %
-
-    s case Integer ==
-      integer? rep s
-
-    s case DoubleFloat ==
-      float? rep s
-
-    s case String ==
-      string? rep s
-
-    s case Symbol ==
-      symbol? rep s
-
-    convert(x: %): SExpression ==
-      rep x
-
-    convert(x: SExpression): % ==
-      per x
-
-    coerce(i: Integer): % ==
-      i pretend %
-
-    autoCoerce(i: %): Integer ==                -- used for hard coercion
-      i : Integer
-
-    coerce(i: %): Integer ==
-      i case Integer => i
-      userError "invalid conversion target type"
-
-    coerce(f: DoubleFloat): % ==
-      f pretend %
-
-    autoCoerce(f: %): DoubleFloat ==		-- used for hard coercion
-      f : DoubleFloat
-
-    coerce(f: %): DoubleFloat ==
-      f case DoubleFloat => f
-      userError "invalid conversion target type"
-
-    coerce(s: Symbol): % ==
-      s pretend %
-
-    autoCoerce(s: %): Symbol ==                 -- used for hard coercion
-      s : Symbol
-
-    coerce(s: %): Symbol ==
-      s case Symbol => s
-      userError "invalid conversion target type"
-
-    coerce(s: String): % ==
-      s pretend %
-
-    autoCoerce(s: %): String ==                 -- used for hard coercion
-      s : String
-
-    coerce(s: %): String ==
-      s case String => s
-      userError "invalid conversion target type"
-
-    buildSyntax(s: Symbol, l: List %): % ==
-      -- ??? ideally we should have overloaded operator `per' that convert
-      -- from list of syntax to syntax.  But the compiler is at the 
-      -- moment defective for non-exported overloaded operations.
-      -- Furthermore, this direct call to `CONS' is currently necessary
-      -- in order to have the Syntax domain compiled as early as possible
-      -- in algebra boostrapping process.  It should be removed once
-      -- the bootstrap process is improved.
-      CONS(s,l)$Lisp @ %
-
-    buildSyntax(op: %, l: List %): % ==
-      CONS(op,l)$Lisp @ %
-
-    nil? x ==
-      null? rep x
-
-    getOperator x ==
-      atom? rep x => userError "atom as operand to getOperator"
-      op := car rep x
-      symbol? op => symbol op
-      integer? op => integer op
-      float? op => float op
-      string? op => string op
-      convert op
-   
-    compound? x ==
-      pair? rep x
-
-    getOperands x ==
-      s := rep x
-      atom? s => []
-      [per t for t in destruct cdr s]