From 8559362639b3460afb49ed8c32dba0a75b9bab71 Mon Sep 17 00:00:00 2001 From: dos-reis Date: Sun, 20 Jan 2008 01:02:10 +0000 Subject: * 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. --- src/algebra/Makefile.in | 6 +- src/algebra/Makefile.pamphlet | 6 +- src/algebra/domain.spad | 16 ++- src/algebra/syntax.spad | 225 ------------------------------- src/algebra/syntax.spad.pamphlet | 285 +++++++++++++++++++++++++++++++++++++++ 5 files changed, 299 insertions(+), 239 deletions(-) delete mode 100644 src/algebra/syntax.spad create mode 100644 src/algebra/syntax.spad.pamphlet (limited to 'src/algebra') diff --git a/src/algebra/Makefile.in b/src/algebra/Makefile.in index 0877c436..1812268d 100644 --- a/src/algebra/Makefile.in +++ b/src/algebra/Makefile.in @@ -392,7 +392,7 @@ axiom_algebra_layer_1 = \ PATAB.o PLOT1.o PPCURVE.o PSCURVE.o \ REAL.o RESLATC.o RETRACT.o RETRACT-.o \ SEGBIND2.o SEGCAT.o STREAM1.o STREAM2.o \ - STREAM3.o BINDING.o + STREAM3.o BINDING.o CTORCALL.o axiom_algebra_layer_1_nrlibs = \ $(axiom_algebra_layer_1:.$(OBJEXT)=.NRLIB/code.$(OBJEXT)) @@ -902,10 +902,6 @@ $(builddir)/%.tex: $(srcdir)/%.pamphlet $(axiom_build_texdir)/diagrams.tex: $(axiom_src_docdir)/diagrams.tex $(INSTALL_DATA) $< $@ -SYNTAX.NRLIB/code.$(FASLEXT): syntax.spad - @ rm -rf SYNTAX.NRLIB - echo ")co $(srcdir)/syntax.spad" | ${INTERPSYS} - SPADPRSR.NRLIB/code.$(FASLEXT): spad-parser.spad @ rm -rf SPADPRSR.NRLIB echo ")co $(srcdir)/spad-parser.spad" | ${INTERPSYS} diff --git a/src/algebra/Makefile.pamphlet b/src/algebra/Makefile.pamphlet index 0beef0b8..53ee408b 100644 --- a/src/algebra/Makefile.pamphlet +++ b/src/algebra/Makefile.pamphlet @@ -234,7 +234,7 @@ axiom_algebra_layer_1 = \ PATAB.o PLOT1.o PPCURVE.o PSCURVE.o \ REAL.o RESLATC.o RETRACT.o RETRACT-.o \ SEGBIND2.o SEGCAT.o STREAM1.o STREAM2.o \ - STREAM3.o BINDING.o + STREAM3.o BINDING.o CTORCALL.o axiom_algebra_layer_1_nrlibs = \ $(axiom_algebra_layer_1:.$(OBJEXT)=.NRLIB/code.$(OBJEXT)) @@ -1855,10 +1855,6 @@ $(axiom_build_texdir)/diagrams.tex: $(axiom_src_docdir)/diagrams.tex <> <> -SYNTAX.NRLIB/code.$(FASLEXT): syntax.spad - @ rm -rf SYNTAX.NRLIB - echo ")co $(srcdir)/syntax.spad" | ${INTERPSYS} - SPADPRSR.NRLIB/code.$(FASLEXT): spad-parser.spad @ rm -rf SPADPRSR.NRLIB echo ")co $(srcdir)/spad-parser.spad" | ${INTERPSYS} diff --git a/src/algebra/domain.spad b/src/algebra/domain.spad index 6d30ab18..64247670 100644 --- a/src/algebra/domain.spad +++ b/src/algebra/domain.spad @@ -33,14 +33,19 @@ )abbrev domain DOMAIN Domain ++ Author: Gabriel Dos Reis ++ Date Create: October 18, 2007. -++ Date Last Updated: December 12, 2007. +++ Date Last Updated: January 19, 2008. ++ Basic Operations: coerce, reify ++ Related Constructors: Type, Syntax, OutputForm -++ Also See: Type +++ Also See: Type, ConstructorCall Domain(): Public == Private where Public ==> CoercibleTo(OutputForm) with - reify: % -> Syntax + reify: % -> ConstructorCall ++ reify(d) returns the abstract syntax for the domain `x'. + + reflect: ConstructorCall -> % + ++ reflect cc returns the domain object designated by the + ++ ConstructorCall syntax `cc'. The constructor implied + ++ by `cc' must be known to the system since it is instantiated. showSummary: % -> Void ++ showSummary(d) prints out implementation detail information @@ -51,7 +56,10 @@ Domain(): Public == Private where outputDomainConstructor(x)$Lisp reify x == - convert(devaluate(x)$Lisp@SExpression)$Syntax + devaluate(x)$Lisp @ ConstructorCall + + reflect cc == + evalDomain(cc)$Lisp @ % showSummary x == showSummary(x)$Lisp 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] diff --git a/src/algebra/syntax.spad.pamphlet b/src/algebra/syntax.spad.pamphlet new file mode 100644 index 00000000..e7c2b50b --- /dev/null +++ b/src/algebra/syntax.spad.pamphlet @@ -0,0 +1,285 @@ +\documentclass{article} +\usepackage{axiom} + +\author{Gabriel Dos~Reis} + +\begin{document} + +\begin{abstract} +\end{abstract} + +\tableofcontents +\eject + +\section{domain Syntax} +<>= +)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] +@ + + +\section{domain ConstructorCall} +<>= +)abbrev domain CTORCALL ConstructorCall +++ Author: Gabriel Dos Reis +++ Date Created: January 19, 2008 +++ Date Last Updated: January 19, 2008 +++ Description: This domains represents a syntax object that +++ designates a category, domain, or a package. +++ See Also: Syntax, Domain +ConstructorCall(): Public == Private where + Public ==> CoercibleTo OutputForm with + constructorName: % -> Symbol + ++ constructorName c returns the name of the constructor + arguments: % -> List Syntax + ++ arguments returns the list of syntax objects for the + ++ arguments used to invoke the constructor. + + Private ==> add + rep(x: %): List Syntax == + x pretend List(Syntax) + + constructorName x == + (first rep x)::Symbol + + arguments x == + rest rep x + + coerce x == + outputDomainConstructor(x)$Lisp +@ + + +\section{License} +<>= +--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. +@ + +<<*>>= +<> +<> +<> +@ + +\end{document} -- cgit v1.2.3