Commit b7bb161e authored by Bjoern Peemoeller's avatar Bjoern Peemoeller
Browse files

Initial commit

parents
Copyright (c) 1998-2004, Wolfgang Lux
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. 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.
3. None of the names of the copyright holders and 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.
===============================================================================
==
== Münster-Curry-Compiler
== Distribution zur Anwendung als Frontend in PAKCS
==
== Letztes Update: 27.10.05
Diese Distribution enthält die modifizierte Version des
Münster-Curry-Compilers (MCC) für die Verwendung als Frontend in PAKCS. Dieses
System ist u.a. in der Lage aus Curry-Programmen (entwickelt nach
PAKCS-Standard) Flat-Darstellungen (FlatCurry ".fcy", FlatInterface ".fint"
und FlatXML "_flat.xml"), sowie Abstract-Darstellungen (AbstractCurry ".acy"
und untyped AbstractCurry ".uacy") zu generieren.
1. Installation
---------------
1.1 Installation der Binary-Distribution
Die Binary-Distribution befindet sich in einem tar-Archiv und wird
durch folgendes Kommando entpackt:
tar zxvf <Distribution>.tar.gz
Danach steht der Compiler im Verzeichnis 'mcc' zur Verfügung.
1.2 Installation der Source-Distribution
Nach dem Entpacken des tar-Archivs mittels
tar zxvf <Distribution>.tar.gz
kann der Compiler durch Aufruf von 'make' im Verzeichnis 'mcc' installiert
werden. Bei Recompilierung (z.B. nach Änderungen in der Quelldateien)
wird empfohlen vor einer erneuten Installation 'make clean' auszuführen.
Nach erfolgreicher Installation befindet sich in beiden Fällen im Verzeichnis
'mcc/bin/' folgende ausführbare Datei:
cymake - der Curry-Programm-Builder
Dieses Tool übersetzt Curry-Programme unter Berücksichtigung der Import-
abhängigkeiten.
2. Kommandoübersicht
--------------------
In der folgenden Tabelle sind die Optionen zur Generierung der jeweiligen
Darstellungen für das Kommando 'cymake' aufgelistet:
--flat : Erzeugt FlatCurry- und FlatInterface-Datei
--xml : Erzeugt FlatXML-Datei
--acy : Erzeugt (typinferierte) AbstractCurry-Datei
--uacy : Erzeugt ungetypte AbstractCurry-Datei
3. Erzeugung von FlatCurry- und FlatXML-Programmen
--------------------------------------------------
Die Übersetzung eines Curry-Programms 'file.curry', sowie sämtlicher
importierter Module nach FlatCurry bzw. FlatInterface, bewirkt folgendes
Kommando:
cymake --flat <filename>
Hierdurch werden die Dateien mit den entsprechenden Endungen ".fcy" und
".fint" generiert. Der Dateiname <filename> kann hierbei mit oder ohne
Endung ".curry" bzw. ".lcurry" angegeben werden.
Die analogen Übersetzungen in die FlatXML-Darstellung bewirkt folgendes
Kommando:
cymake --xml <file name>
Die hierdurch generierte Flat-XML-Datei hat die Endung '_flat.xml'.
4. Erzeugung von AbstractCurry-Programmen
-----------------------------------------
Die Übersetzung eines Curry-Programms 'file.curry' nach (typgeprüftem)
AbstractCurry bewirkt folgendes Kommando:
cymake --acy <filename>
Hierdurch wird die entsprechende Datei (mit der Endung ".acy") generiert.
Der Dateiname <filename> kann hierbei mit oder ohne Endung ".curry" bzw.
".lcurry" angegeben werden.
Ungetypte, bzw. typsignierte AbstractCurry-Programme werden mit folgendem
Kommando generiert:
cymake --uacy <filename>
Die hierdurch generierte Datei besitzt die Endung ".uacy".
Die Generierung des ungetypten AbstractCurry-Programms findet ohne
Typüberprüfung statt (d.h. auch Programme mit Typfehlern werden übersetzt).
Alle Funktionen besitzen entweder die im Quellprogramm angegebenen Typsignatur,
oder, sofern diese nicht vorhanden ist, den Dummy-Typ "prelude.untyped".
In beiden Fällen werden für die Übersetzung FlatCurry-Dateien
für alle importierten Module erzeugt. Dies ist notwendig, da die
entsprechenden Interfaces für die Typinferenz (nur im Fall der getypten
AbstractCurry-Generierung) und die statisch-semantische Analyse benötigt
werden.
5. Anmerkungen
--------------
- Um die PAKCS-Bibliotheken (insbesondere die Prelude) für Übersetzungen
nutzen zu können muß die Umgebungsvariable 'PAKCS_LIB' auf die
entsprechenden Pfade verweisen, z.B. mittels
export PAKCS_LIB=<pakcs path>/pacs/lib:<pakcs path>/pacs/lib/meta:...
wobei <pakcs path> das Verzeichnis ist, das die PAKCS-Distribution
enthält.
- Im Gegensatz zu PAKCS erlaubt das Frontend die Verwendung anonymer
Variablen (dargestellt durch dem Unterstrich '_') in Typdeklarationen,
z.B.
data T _ = C
Bekannte Probleme
------------------
- Lambda-, do-, if-, case-, oder let-Ausdrücke, die in Argumenten von
Funktionsaufrufen verwendet werden, müssen immer geklammert werden.
- 'let'-Anweisungen dürfen nicht folgendes Layout besitzen:
let x = <expr>
in ...
- Die Regeln einer Funktionsdeklaration müssen immer zusammenstehen, d.h.
nicht durch andere Deklarationen unterbrochen werden.
- Es ist bislang nicht möglich, den Konstruktor für leere Listen [], sowie
den Unit-Konstruktor () zu qualifizieren (z.B. führt 'prelude.[]' zu
einem Fehler). Der Listenkonstruktor (:), sowie Tupel-Konstruktoren
dagegen sind qualifizierbar.
- FlatXML-Übersetzungen können derzeit mittels der Funktionen aus dem
PAKCS-Modul "FlatXML" noch nicht eingelesen werden, da es Unstimmigkeiten
zwischen dem generierten und den erforderlichen Formaten gibt.
- Bei der Erzeugung von typgeprüftem AbstractCurry können die im Quelltext
verwendeten Bezeichner für Typvariablen nicht ins AbstractCurry-Programm
übernommen werden. Stattdessen generiert der Übersetzer neue
Bezeichner.
- Bei der Erzeugung von ungetyptem AbstractCurry werden Typsynonyme in
Typsignaturen von Funktionen nicht dereferenziert.
- Das Frontend gibt derzeit noch keinerlei Warnungen aus.
#------------------------------------------------------------------------------
#--
#-- Generate a simple version of the Muenster Curry Compiler for
#-- running with PAKCS
#--
# Path of the MCC
MCC = $(CURDIR)
MCC_SRC = $(MCC)/src
MCC_BIN = $(MCC)/bin
MCC_DIST = $(MCC)/distribution
MCC_DIST_BIN = $(MCC_DIST)/binary
MCC_DIST_SRC = $(MCC_DIST)/source
# distributions
MCC_SRC_NAME = mcc_for_pakcs_src
MCC_BIN_NAME = mcc_for_pakcs_`uname -s`
#------------------------------------------------------------------------------
# Let's start...
# Generate the MCC
.PHONY: all
all: compile
# Compile all necessary MCC components
.PHONY: compile
compile:
@cd $(MCC_SRC) && make
# Clean generated files
.PHONY: clean
clean: clean_src clean_dist
clean_src:
@cd $(MCC_SRC) && rm -f *.hi *.o
clean_dist:
@cd $(MCC_DIST) && rm -rf *
# Generate distribution
# name of the root directory of the distribution:
DISTROOT=mccparser
.PHONY: dist
dist: compile dist_src dist_bin
dist_src:
@mkdir -p $(MCC_DIST_SRC)/$(DISTROOT)/src
@mkdir -p $(MCC_DIST_SRC)/$(DISTROOT)/bin
@mkdir -p $(MCC_DIST_SRC)/$(DISTROOT)/dist
@cp $(MCC_SRC)/*.lhs $(MCC_DIST_SRC)/$(DISTROOT)/src
@cp $(MCC_SRC)/*.hs $(MCC_DIST_SRC)/$(DISTROOT)/src
@cp $(MCC_SRC)/Makefile $(MCC_DIST_SRC)/$(DISTROOT)/src
@cp $(MCC)/LICENSE $(MCC_DIST_SRC)/$(DISTROOT)
@cp $(MCC)/Makefile $(MCC_DIST_SRC)/$(DISTROOT)
@cd $(MCC_DIST_SRC) \
&& tar cvf $(MCC_SRC_NAME).tar $(DISTROOT)/* \
&& gzip -f9 -S .gz $(MCC_SRC_NAME).tar \
&& mv $(MCC_SRC_NAME).tar.gz $(MCC_DIST)
@rm -rf $(MCC_DIST_SRC)
dist_bin:
@mkdir -p $(MCC_DIST_BIN)/$(DISTROOT)/bin
@cp $(MCC_BIN)/cymake $(MCC_DIST_BIN)/$(DISTROOT)/bin
@cp $(MCC)/LICENSE $(MCC_DIST_BIN)/$(DISTROOT)
@cd $(MCC_DIST_BIN) \
&& tar cvf $(MCC_BIN_NAME).tar $(DISTROOT)/* \
&& gzip -f9 -S .gz $(MCC_BIN_NAME).tar \
&& mv $(MCC_BIN_NAME).tar.gz $(MCC_DIST)
@rm -rf $(MCC_DIST_BIN)
import Distribution.Simple
main = defaultMain
Records: Es ist kein qualifizierter Import von Records möglich, da die
Feldbezeichnungen nicht mit importiert werden können.
Beispiel:
import CompilerOpts -- okay
import CompilerOpts (Options) -- okay, aber Feldbezeichner nicht importiert
import CompilerOpts (Options (..)) Fehler: Options is not a data type
NoImplicitPrelude
Typklassen
Hierarchische Module
Nondeterminism by overlapping abschaltbar?
QName wird als Typvariable angesehen
DHO als Variable
\ No newline at end of file
Name: curry-frontend
Version: 0.3.0
Cabal-Version: >= 1.6
Synopsis: Compile the functional logic language Curry to several
intermediate formats
Description: The Curry Frontend consists of the executable program "cymake".
It is used by various backends to compile Curry programs to
an internal representation.
The code is a stripped-down version of an early version of
the Muenster Curry Compiler
(<http://danae.uni-muenster.de/~lux/curry/>)
Category: Language
License: OtherLicense
License-File: LICENSE
Author: Wolfgang Lux, Martin Engelke, Bernd Brassel, Holger Siegel
Maintainer: Holger Siegel
Bug-Reports: mailto:hsi@informatik.uni-kiel.de
Homepage: http://curry-language.org
Build-Type: Simple
Stability: experimental
Extra-Source-Files: LIESMICH
Data-Files: src/Html/currydoc.css
Flag split-syb
Description: Has the syb functionality been split into the package syb?
Default: True
Executable cymake
hs-source-dirs: src
Main-is: cymake.hs
if flag(split-syb)
Build-Depends: base == 4.*, syb
else
Build-Depends: base == 3.*
Build-Depends:
curry-base >= 0.3.0
, mtl, old-time, containers, pretty
ghc-options: -Wall
Other-Modules:
Base
, Base.Arity
, Base.Import
, Base.Module
, Base.OpPrec
, Base.TypeConstructors
, Base.Types
, Base.Value
, Check.InterfaceCheck
, Check.KindCheck
, Check.PrecCheck
, Check.SyntaxCheck
, Check.TypeCheck
, Check.WarnCheck
, Curry.IL
, Curry.IL.Pretty
, Curry.IL.Type
, Curry.IL.XML
, Curry.Syntax
, Curry.Syntax.Lexer
, Curry.Syntax.Parser
, Curry.Syntax.Pretty
, Curry.Syntax.ShowModule
, Curry.Syntax.Type
, Curry.Syntax.Utils
, Env.CurryEnv
, Env.NestEnv
, Env.OldScopeEnv
, Env.ScopeEnv
, Env.TopEnv
, Gen.GenAbstractCurry
, Gen.GenFlatCurry
, Html.CurryHtml
, Html.SyntaxColoring
, CurryBuilder
, CurryCompilerOpts
, CurryDeps
, CurryToIL
, Eval
, Exports
, Frontend
, Imports
, Messages
, Modules
, SCC
, Subst
, Transform.CaseCompletion
, Transform.Desugar
, Transform.Lift
, Transform.Qual
, Transform.Simplify
, Types
, TypeSubst
, Typing
, Utils
Library
hs-source-dirs: src
Build-Depends: filepath
Exposed-Modules:
Files.CymakePath
Other-Modules:
Paths_curry_frontend
\documentclass[11pt,fleqn]{article}
\usepackage{latexsym}
\usepackage{makeidx}
\usepackage{amssymb}
\usepackage{url}
%%% ------------------------------------------------------------------
\usepackage[colorlinks,linkcolor=blue]{hyperref}
%\usepackage[]{hyperref}
\hypersetup{bookmarksopen=true}
\hypersetup{bookmarksopenlevel=0}
\hypersetup{pdftitle={Curry: An Integrated Functional Logic Language}}
\hypersetup{pdfauthor={Michael Hanus}}
%\hypersetup{pdfstartview=Title}
\hypersetup{pdfstartview=FitH}
\usepackage{thumbpdf}
%%% ------------------------------------------------------------------
\setlength{\textwidth}{16.5cm}
\setlength{\textheight}{23cm}
\renewcommand{\baselinestretch}{1.1}
\setlength{\topmargin}{-1cm}
\setlength{\oddsidemargin}{0cm}
\setlength{\evensidemargin}{0cm}
\setlength{\marginparwidth}{0.0cm}
\setlength{\marginparsep}{0.0cm}
\newlength{\figurewidth}
\setlength{\figurewidth}{\textwidth}
\addtolength{\figurewidth}{-0.4cm}
% environment for typing program texts:
\makeatletter
\newenvironment{prog}{\par\vspace{1.5ex}
\setlength{\parindent}{1.0cm}
\setlength{\parskip}{-0.1ex}
\obeylines\@vobeyspaces\tt}{\vspace{1.5ex}\noindent
}
\makeatother
\newcommand{\startprog}{\begin{prog}}
\newcommand{\stopprog}{\end{prog}\noindent}
\newcommand{\pr}[1]{\mbox{\tt #1}} % program text in normal text
\newcommand{\Ac}{{\cal{A}}}
\newcommand{\Cc}{{\cal{C}}}
\newcommand{\Dc}{{\cal{D}}}
\newcommand{\Fc}{{\cal{F}}}
\newcommand{\Tc}{{\cal{T}}}
\newcommand{\Xc}{{\cal{X}}}
\newcommand{\var}{{\cal V}ar}
\newcommand{\Dom}{{\cal D}om}
\newcommand{\VRan}{{\cal VR}an}
\renewcommand{\emptyset}{\varnothing}
\newcommand{\ans}{\mathbin{\framebox[1mm]{\rule{0cm}{1.2mm}}}}
%\newcommand{\ans}{\;}
\newcommand{\todo}[1]{\fbox{\sc To do: #1}}
\newcommand{\dexp}{D} % a disjunctive expression
\newcommand{\cconj}{\ensuremath \mathop{\pr{\&}}} % concurrent conj. in math
\newcommand{\ttbs}{\mbox{\tt\char92}} % backslash in tt font
\newcommand{\ttus}{\mbox{\tt\char95}} % underscore in tt font
\newcommand{\sem}[1]{\ensuremath [\![#1]\!]} % double square brackets
\newcommand{\eval}[1]{{\cal E}\!val\sem{#1}}
\newcommand{\To}{\Rightarrow}
\newcommand{\infrule}[2]{\begin{array}{@{}c@{}} #1 \\ \hline #2 \end{array}}
\newcommand{\pindex}[1]{\index{#1@{\tt #1}}} % program elements in index
\newcommand{\comment}[1]{} % ignore the argument
\catcode`\_=\active
\let_=\sb
\catcode`\_=12
% commands for the syntax:
\newcommand{\term}[1]{{\tt #1}}
\newcommand{\opt}[1]{\rm [\it #1{\rm ]}}
\newcommand{\offside}[3]{\term{\{}\seq{#1}{#2}{#3} \term{\}}}
\newcommand{\seq}[3]{{\it #1$_1$ \term{#2} $\ldots$ \term{#2} #1$_#3$}}
\newcommand{\head}[1]{\makebox[1.3in][r]{\it #1}}
\newcommand{\por}{\\\head{}\makebox[3em][c]{$|$}}
\newcommand{\nextline}{\\\head{}\makebox[3em]{}}
\newcommand{\marg}[1]{\hspace{\fill}$(#1)$}
\newcommand{\lexicon}[1]{\production #1 {\rm see lexicon} end}
\def\production #1 #2 end {\head{#1}\makebox[3em]{\rm ::=}\it #2}
\newcommand{\translation}[1]{\bigskip\fbox{\begin{minipage}{15cm}\textbf{Translation: }{#1}\end{minipage}}\bigskip}
\makeindex
\begin{document}
%%------------------------------------------------------------------------------
%%------------------------------------------------------------------------------
\section {Records}
\label{records}
A record is a data structure for bundling several data of various types.
It consits of typed data fields where each field is associated with
a unique label. These labels can be used to construct, select or update
fields in a record.
Unlike labeled data fields in Haskell, records are
no syntactic sugar but a real extension of the
language\footnote{
The current version allows to transform records
into abstract data types. Future extensions may not have
this facility.}.
The basic concept is described in \cite{Leijen05} but the current
version doesn't yet provide all features mentioned there.
The restrictions are explained in section \ref{sec-restrinrecs}.
\subsection{Record Type Declaration}
\label{sec-recordtypedecl}
It is necessary to define a record type before a record
can be constructed or used. The declaration has the following form:
\startprog
type $R$ $\alpha_1$ \ldots $\alpha_n$ = \{ $l_1$ :: $\tau_1$, \ldots, $l_m$ :: $\tau_m$ \}
\stopprog
It introduces a new $n$-ary record type $R$ which represents a
record consisting of $m$ fields. Each field has a unique label $l_i$
representing a value of the type $\tau_i$. Labels
are identifiers which refer to the corresponding
fields. The following examples define some records types:
\startprog
type Person = \{name :: String, age :: Int\}
type Address = \{person :: Person, street :: String, city :: String\}
type Branch a b = \{left :: a, right :: b\}
\stopprog
It is possible to summarize different labels which have the same
type. E.g. the record \pr{Address} can also be declared as follows:
\startprog
type Address = \{person :: Person, street,city :: String\}
\stopprog
The fields can occur in an arbitrary order. The example above
can also be written as
\startprog
type Address = \{street,city :: String, person :: Person\}
\stopprog
The record type can be used in every type expression to represent
the corresponding record, e.g.
\startprog
data BiTree = Node (Branch BiTree BiTree) | Leaf Int
\stopprog
\startprog
getName :: Person -> String
getName \ldots
\stopprog
Labels can only be used in the context of
records. They do not share the name space with
functions/constructors/variables or type constructors/type variables.
For instance it is possible to use
the same identifier for a label and a function at the same time. Label
identifiers cannot be shadowed by other identifiers.
Like in type synonym declarations, recursive or mutually
dependent record declarations are not allowed. Records can only
be declared at top level. Further restrictions are described in
section \ref{sec-restrinrecs}.
\subsection{Record Construction}
\label{sec-recordconstr}
The record construction generates a record with initial values for
each data field. It has the following form:
\startprog
\{ $l_1$ = $v_1$, \ldots, $l_m$ = $v_m$ \}
\stopprog
It generates a record where each label $l_i$ refers to the
value $v_i$. The type of the record results from the record type
declaration where the labels $l_i$ are defined.
A mix of labels from different
record types is not allowed. All labels must be specified with
exactly one assignment. Examples for record constructions are
\startprog
\{name = "Johnson", age = 30\} -- generates a record of type 'Person'
\{left = True, right = 20\} -- generates a record of type 'Branch'
\stopprog
Assignments to labels can occur in an arbitrary order. For instance a
record of type \pr{Person} can also be generated as follows:
\startprog
\{age = 30, name = "Johnson"\} -- generates a record of type 'Person'
\stopprog
Unlike labeled fields in record type declarations,
record constructions can be used in expressions without any restrictions
(as well as all kinds of record expressions). For instance the following
expression is valid:
\startprog
\{person = \{name = "Smith", age = 20\}, -- generates a record of
street = "Main Street", -- type 'Address'
city = "Springfield"\}
\stopprog
\subsection{Field Selection}
\label{sec-fieldsel}
The field selection is used to extract data from records.
It has the following form:
\startprog
$r$ -> $l$
\stopprog
It returns the value to which the label $l$ refers to from the
record expression $r$. The label must occur in the declaration of
the record type of $r$.
An example for a field selection is:
\startprog