diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,327 @@ +Change log for curry-frontend +============================= + +Version 2.0.0 +============= + + * Implemented the "MonadFail-Proposal" for curry + (see ) + * Data class (see ) + * Fixed bug with partially imported Typeclasses + * Fixed bug with parsing of empty blocks + * Fixed bug with re-export of record labels + +Version 1.0.4 +============= + + * Fixed bug in type checking of instances + * Fixed bugs in deriving of `Bounded` instances. + +Version 1.0.3 +============= + + * Fixed bug in type checking of typeclasses + +Version 1.0.2 +============= + + * Added 'short-ast' and 'ast' as new compilation targets + * Fixed bug with wrong type of free variables in the intermediate language. + * Fixed bug with generated default implementations of nullary class methods. + * Fixed bug in desugaring of record patterns. + * Fixed bug that external data declarations weren't considered when + AbstractCurry was generated + +Version 1.0.1 +============= + + * Fixed bug with wrong order of super classes in selector functions + generated by the dictionary transformation. + * Changed desugaring of numeric literals. It now generates calls to the + functions `Prelude.fromInt` and `Prelude.fromFloat`. + * Fixed bug with wrong original names of imported record labels + * Fixed bug when compiling type constructor classes with super classes + * Adjusted warning message for potentially unreachable pattern matches + +Version 1.0.0 +============= + + * Added support for typeclasses as known from Haskell + +Version 0.4.2 +============= + + * Improved readability of environment information in dumps + (option dump-simple) + * Added option to dump all bindings instead of just local ones + (dump-all-bindings) + * Introduced annotated FlatCurry as a new output format + (annotated-flat) + +Version 0.4.1 +============= + + * Added a simple cabal test suite + * Split import of interfaces/modules and expansion and checking of + import specifications into two modules. + * Improved error messages generated by export check (fixes #1253) + * Split checking and expansion of export specification into two + subsequent steps (by Yannik Potdevin, fixes #1335) + * Consider parenthesized type expressions in the Curry AST (by Katharina Rahf) + * Added syntax extension `ExistentialQuantification` that allows the use + of existentially quantified types in data and newtype constructors + * Fixed bug that type declarations weren't syntax checked + +Version 0.4.0 +============= + + * Refactored AbstractCurry generation + + * Complete refactoring of FlatCurry generation + + * Removed support for Curry's record syntax and introduced Haskell's record + syntax instead + + * During desugaring record updates are translated to fcase-expressions instead + of introducing explicit update functions + + * HTML generation now places HTML files for hierarchical modules into + files named `_curry.html`, i.e., no sub-folders reflecting + the the module name hierarchy are generated. In addition, if the option + `--html-dir` is not given, the current directory is used as the output + directory. + + * Removed record type extensions + + * Enabled declaration of (mutually) recursive record types + + * Removed expansion of record types in type error messages + + * Replaced `MessageM` monad with `CYT` monads and moved `CYT` monads + to package `curry-base` + + * Implemented warnings for overlapping module aliases - fixes #14 + + * The check for overlapping rules has been completely refactored and + improved to now also handle rigid case expressions. + + * The check for missing pattern matching alternatives now correctly handles + String literals - fixes #1048. + + * Added warnings for top-level functions without type signatures - fixes #769 + + * Moved pretty-printing of types from Checks.TypeCheck to Base.CurryTypes + + * Type synonyms in typed expressions are now desugared - fixes #921 + + * Declaration of operator precedence is now optional in infix operator + declarations + + * Moved module `InterfaceEquivalence` to curry-base + (`Curry.Syntax.InterfaceEquivalence`) + + * Converted literate Haskell files into simple Haskell files + + * Removed support for FlatCurry XML files. + + * Added syntax extension `NegativeLiterals` to translate negated literals + into negative literals instead of a call to `Prelude.negate` and + `Prelude.negateFloat`, respectively. + + * The frontend now considers options pragmas of the following form: + + ~~~ {.curry} + {-# OPTIONS_CYMAKE opt1 ... optn #-} + ~~~ + + The string following `OPTIONS_CYMAKE` will be split at white spaces + and treated like an ordinary command line argument string. + + If one wishes to provide options containing spaces, e.g., directory + paths or alike, this can be achieved by quoting the respective argument + using either `'single quotes'` or `'double quotes'` (may bot be mixed). + + Note that *following options are excluded*: + + * A change of the current mode + (e.g., change from compilation to HTML generation) + * A change of the import paths + * A change of the library paths + * A change of the compilation targets + (e.g., change from FlatCurry to AbstractCurry) + + These options can only be set via the command line. + + * Refactored the source code HTML generation. + The generation now supports full Curry with all supported extensions, + i.e., it supports pragmas, record types and functional patterns. + Furthermore, the created HTML has been simplified, and updated towards + HTML 5. + + * The HTML generation now accepts an option `--htmldir=dir` to specify + the output directory of the generated HTML files. + +Version 0.3.10 +============== + + * Various improvements of the internal structure. + + * Improved status messages. The compilation status message are now of the form + + [m of n] Compiling/Skipping (, ) + + * Implemented support for custom preprocessors. It is now possible to run + a custom preprocessor command via the following options: + + * `-F` enables support for a preprocessor + * `-pgmF ` set the preprocessor command to `` + * `-optF ` adds an additional argument to the preprocessor command + (can be repeated to add multiple arguments) + + The preprocessor is applied to all source files which are (re)compiled + after unliterating *and after determining the import list*. + Consequently, adding modules via the preprocessor will results in + compilation errors due to missing imports. + On the other hand, the frontend will automatically determine changed + files which are then handed to the preprocessor. + + The command is called with at least three arguments: + + #. The (normalised) file name of the source file currently processed. + **This name is intended only for reference.** + #. The name of the file containing the (potentially unliterated) + contents of the original file. + **This is the file the preprocessor should read from.** + #. The name of the file where the preprocessed source code should go to. + **This is the file the preprocessor should write to.** + #. Optionally, any additional arguments specified using `-optF`. + +Version 0.3.9 +============= + + * Simplified verbosity options by merging options "-v1" and "-v2". + Now only "-v0" and "-v1" are supported. + + * Fixed bug in non-exhaustive pattern matching check which occured + when retrieving the siblings of a constructor imported using an alias. + + * Fixed bug when using functional patterns in `case`-expressions. + Functional patterns are only allowed in the patterns of a function + definition and forbidden elsewhere, i.e., in `case`-expressions, + `do`-sequences, list comprehensions or lambda expressions. + + * Implementation of module pragmas added. Module pragmas of the following + types are now parsed and represented in the abstract syntax tree: + + ~~~ {.curry} + {-# LANGUAGE LANG_EXT+ #-} + {-# OPTIONS "string" #-} + {-# OPTIONS_TOOL "string" #-} + module Main where + ~~~ + + where + + - `LANGEXT+` is a non-empty, comma-separated list of the following + language extensions: `AnonFreeVars`, `FunctionalPatterns`, + `NoImplicitPrelude`, `Records` + - `TOOL` is either `KICS2`, `PAKCS`, or some other tool, represented + as `Unknown String`. + + While the distinct language pragmas enable the respective language + extensions, the OPTIONS pragma is ignored. + + All other texts given in the pragma braces is ignored and treated as + a nested comment. + + * Error message for different arities of function equations now also + report the corresponding source code positions. + +Version 0.3.8 +============= + + * Implemented warnings for non-exhaustive pattern matchings + both in function declarations and `case`-expressions - fixes #349. + + * Extended options to enable/disable certain types of warnings. + + * Fixed problem when defining an operator directly after an import statement + without import restrictions - fixes #494. + + * Fixed bug w.r.t. polymorphically typed local variables - fixes #480. + + * Fixed missing polymorphism in record labels - fixes #445. + + * Dumping of intermediate structures improved. + + * Fixed bug in type checking w.r.t. recursive type synonyms - fixes 489. + + * Reactivation of Curry interface files. + During adaption of the MCC frontend to FlatCurry the Curry interface + files have been deactivated and replaced by FlatCurry's interface + files. To allow the later addition of type classes to Curry, + they have now been reactivated. + + * Implemented missing semantics of functional patterns in combination + with non-linear left-hand-sides and as-patterns. + + * Various improvements. + +Version 0.3.7 +============= + + * Support for typed FlatCurry expressions added. Now additional type + information given by the programmer as in + + ~~~ {.curry} + null (unknown :: [()]) + ~~~ + + is represented in FlatCurry and cann therefore be processed by other + programs like PAKCS or KICS2. + +Version 0.3.6 +============= + + * Error messages are now sorted according to their source code position. + +Version 0.3.5 +============= + + * Improved reporting of mutiple type signatures. + +Version 0.3.4 +============= + + * Bug in renaming phase fixed. + +Version 0.3.3 +============= + + * Corrected translation of `fcase`-expressions. + +Version 0.3.2 +============= + + * Non-linear left-hand-sides now work with guarded expressions - fixes #328. + + * Implemented precedence check - fixes #327. + + * Case completion refactored and corrected - fixes #323. + + * Various improvements and refactorings. + +Version 0.3.1 +============= + + * Corrected renaming of anonymous free variables - fixes #288. + +Version 0.3.0 +============= + + * Massive refactoring of the previous version. + + * All compiler warnings removed. + + * Fixed various implementation bugs (#9, #16, #19, #29, #289). + diff --git a/LICENSE b/LICENSE --- a/LICENSE +++ b/LICENSE @@ -1,4 +1,5 @@ Copyright (c) 1998-2004, Wolfgang Lux +Copyright (c) 2005-2016, Michael Hanus All rights reserved. Redistribution and use in source and binary forms, with or without diff --git a/LIESMICH b/LIESMICH deleted file mode 100644 --- a/LIESMICH +++ /dev/null @@ -1,172 +0,0 @@ -=============================================================================== -== -== 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 .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 .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 - -Hierdurch werden die Dateien mit den entsprechenden Endungen ".fcy" und -".fint" generiert. Der Dateiname kann hierbei mit oder ohne -Endung ".curry" bzw. ".lcurry" angegeben werden. - -Die analogen Übersetzungen in die FlatXML-Darstellung bewirkt folgendes -Kommando: - - cymake --xml - -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 - -Hierdurch wird die entsprechende Datei (mit der Endung ".acy") generiert. -Der Dateiname kann hierbei mit oder ohne Endung ".curry" bzw. -".lcurry" angegeben werden. - -Ungetypte, bzw. typsignierte AbstractCurry-Programme werden mit folgendem -Kommando generiert: - - cymake --uacy - -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=/pacs/lib:/pacs/lib/meta:... - - wobei 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 = - 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. - - diff --git a/README.md b/README.md new file mode 100644 --- /dev/null +++ b/README.md @@ -0,0 +1,65 @@ +# Curry Frontend + +The frontend lexes, parses, type-checks and transforms Curry source files into a variety of intermediate formats, including + +* **FlatCurry** for program analyzers and backends +* **AbstractCurry** for program manipulation tools +* **HTML** for documentation + +It is used by the two major Curry compilers, [PAKCS](https://git.ps.informatik.uni-kiel.de/curry/pakcs) and +[KiCS2](https://git.ps.informatik.uni-kiel.de/curry/kics2). + +## Requirements + +* Make sure that a recent version of Haskell Stack is installed on your computer + +## Building + +* To build the project, run `make`. +* To test the project, run `make runtests`. + +The built executable will be located at `bin/curry-frontend`. + +## Usage + +For a detailed overview of the available options, you can use the following command: + +`curry-frontend --help` + +### Available Formats + +``` +--flat : Generate a FlatCurry (.fcy) and FlatInterface (.fint) file +--xml : Generate a FlatXML (_flat.xml) file +--acy : Generate a (type-inferred) AbstractCurry (.acy) file +--uacy : Generate an untyped AbstractCurry (.uacy) file +``` + +The generation of an untyped AbstractCurry program is performed without +type checking (i.e. programs with type checks will compile). All functions +will either have the type signature specified in the source or, if not +available, the dummy type `prelude.untyped`. + +FlatCurry files will always be generated for the imported modules, +since the interfaces are required for static-semantic analysis and type +inference (only for typed AbstractCurry). + +## Remarks + +- To use the PAKCS libraries (especially for the `Prelude`), the environment + variable `PAKCS_LIB` has to point to the correct paths, e.g. using + + `export PAKCS_LIB=[pakcs path]/pacs/lib:[pakcs path]/pacs/lib/meta:...` + + where `[pakcs path]` is the directory containing the PAKCS distribution. + +- In contrast to PAKCS, the frontend allow use of anonymous variables + (denoted by an underscore `_`) in type declarations, e.g. + + ```curry + data T _ = c + ``` + +## Known Issues + +[See GitLab](https://git.ps.informatik.uni-kiel.de/curry/curry-frontend/-/issues) diff --git a/app/cymake.hs b/app/cymake.hs new file mode 100644 --- /dev/null +++ b/app/cymake.hs @@ -0,0 +1,57 @@ +{- | + Module : $Header$ + Description : Main module + Copyright : (c) 2005 Martin Engelke + 2011 - 2016 Björn Peemöller + License : BSD-3-clause + + Maintainer : bjp@informatik.uni-kiel.de + Stability : experimental + Portability : portable + + Command line tool for generating Curry representations (e.g. FlatCurry, + AbstractCurry) for a Curry source file including all imported modules. +-} +module Main (main) where + +import Curry.Base.Monad (runCYIO) + +import Base.Messages +import Files.CymakePath (cymakeGreeting, cymakeVersion) + +import CurryBuilder (buildCurry) +import CompilerOpts (Options (..), CymakeMode (..), getCompilerOpts, usage) + +-- |The command line tool cymake +main :: IO () +main = getCompilerOpts >>= cymake + +-- |Invoke the curry builder w.r.t the command line arguments +cymake :: (String, Options, [String], [String]) -> IO () +cymake (prog, opts, files, errs) = case optMode opts of + ModeHelp -> printUsage prog + ModeVersion -> printVersion + ModeNumericVersion -> printNumericVersion + ModeMake | not (null errs) -> badUsage prog errs + | null files -> badUsage prog ["No input files"] + | otherwise -> runCYIO (mapM_ (buildCurry opts) files) >>= + either abortWithMessages continueWithMessages + where continueWithMessages = warnOrAbort (optWarnOpts opts) . snd + +-- |Print the usage information of the command line tool +printUsage :: String -> IO () +printUsage prog = putStrLn $ usage prog + +-- |Print the program version +printVersion :: IO () +printVersion = putStrLn cymakeGreeting + +-- |Print the numeric program version +printNumericVersion :: IO () +printNumericVersion = putStrLn cymakeVersion + +-- |Print errors and abort execution on bad parameters +badUsage :: String -> [String] -> IO () +badUsage prog errs = do + putErrsLn $ map (\ err -> prog ++ ": " ++ err) errs + abortWith ["Try '" ++ prog ++ " --help' for more information"] diff --git a/curry-frontend.cabal b/curry-frontend.cabal --- a/curry-frontend.cabal +++ b/curry-frontend.cabal @@ -1,71 +1,207 @@ -Name: curry-frontend -Version: 0.2.12 -Cabal-Version: >= 1.6 -Synopsis: Compile the functional logic language Curry to several +name: curry-frontend +version: 2.0.0 +cabal-version: 2.0 +synopsis: Compile the functional logic language Curry to several intermediate formats -Description: The Curry Frontend consists of the executable program "cymake". +description: The Curry front end consists of the executable program + "curry-frontend". It is used by various backends to compile Curry programs to - an internal representation. + an intermediate representation. The code is a stripped-down version of an early version of the Muenster Curry Compiler - () -Category: Language -License: OtherLicense -License-File: LICENSE -Author: Wolfgang Lux, Martin Engelke, Bernd Brassel, Holger Siegel -Maintainer: Björn Peemöller -Bug-Reports: http://www-ps.informatik.uni-kiel.de/redmine/projects/curry-frontend -Homepage: http://www.curry-language.org -Build-Type: Simple -Stability: experimental + () + which has been extended to produce different intermediate + representations. + For further information, please check + +category: Language +license: BSD3 +license-file: LICENSE +author: Wolfgang Lux, Martin Engelke, Bernd Brassel, Holger Siegel, + Bjoern Peemoeller, Finn Teegen +maintainer: fte@informatik.uni-kiel.de +homepage: http://curry-language.org +build-type: Simple +stability: experimental -Extra-Source-Files: LIESMICH -Data-Files: src/currydoc.css +extra-source-files: README.md CHANGELOG.md -Flag split-syb - Description: Has the syb functionality been split into the package syb? - Default: True +data-dir: data +data-files: currysource.css -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.2.9 && < 0.3 - , mtl, old-time, containers, pretty - ghc-options: -Wall - Other-Modules: Curry.Syntax.Lexer, Curry.Syntax.LexComb - Curry.Syntax.Parser, Curry.Syntax.LLParseComb - Curry.Syntax.ShowModule, Curry.Syntax.Pretty - Curry.Syntax, Curry.Syntax.Type - Curry.Syntax.Unlit, - Curry.Syntax.Utils, - Curry.Syntax.Frontend, - CurryBuilder, IL.Type - CurryCompilerOpts, Modules, Subst, Arity - CurryDeps, Eval, IL.Pretty, NestEnv, SyntaxCheck, Base - Exports, IL.Scope, SyntaxColoring, CurryEnv - IL.CurryToIL, OldScopeEnv, CurryHtml - IL.XML, PatchPrelude, TopEnv, CaseCompletion - Imports, - TypeCheck, - InterfaceCheck, - Types, PrecCheck - TypeSubst, GenAbstractCurry - Typing - GenFlatCurry, KindCheck, Qual - SCC, Utils - Lift, ScopeEnv, WarnCheck - Desugar, - Simplify +source-repository head + type: git + location: https://git.ps.informatik.uni-kiel.de/curry/curry-frontend.git -Library - hs-source-dirs: src - Build-Depends: filepath - Exposed-Modules: - Curry.Files.CymakePath - Other-Modules: - Paths_curry_frontend +library + hs-source-dirs: src + default-language: Haskell2010 + other-extensions: CPP, TemplateHaskell + ghc-options: -Wall + build-depends: + base >= 4.11 && < 4.15 + , template-haskell >= 2.10 && < 2.16 + , extra >= 1.4.6 && < 1.8 + , transformers >= 0.5 && < 0.6 + , mtl >= 2.2 && < 2.3 + , directory >= 1.2 && < 1.4 + , filepath >= 1.4 && < 1.5 + , file-embed >= 0.0 && < 0.1 + , containers >= 0.6 && < 0.7 + , set-extra >= 1.4 && < 1.5 + , bytestring >= 0.10 && < 0.11 + , process >= 1.6 && < 1.7 + , network-uri >= 2.6 && < 2.7 + , pretty >= 1.1 && < 1.2 + , binary >= 0.8 && < 0.9 + , time >= 1.9 && < 2.0 + , parsec >= 3.1 && < 3.2 + exposed-modules: + Base.AnnotExpr + , Base.CurryKinds + , Base.CurryTypes + , Base.Expr + , Base.KindSubst + , Base.Kinds + , Base.Messages + , Base.NestEnv + , Base.PrettyKinds + , Base.PrettyTypes + , Base.SCC + , Base.Subst + , Base.TopEnv + , Base.TypeExpansion + , Base.TypeSubst + , Base.Types + , Base.Typing + , Base.Utils + , Checks + , Checks.DeriveCheck + , Checks.ExportCheck + , Checks.ExtensionCheck + , Checks.ImportSyntaxCheck + , Checks.InstanceCheck + , Checks.InterfaceCheck + , Checks.InterfaceSyntaxCheck + , Checks.KindCheck + , Checks.PrecCheck + , Checks.SyntaxCheck + , Checks.TypeCheck + , Checks.TypeSyntaxCheck + , Checks.WarnCheck + , Curry.AbstractCurry + , Curry.AbstractCurry.Files + , Curry.AbstractCurry.Type + , Curry.Base.Ident + , Curry.Base.LexComb + , Curry.Base.LLParseComb + , Curry.Base.Message + , Curry.Base.Monad + , Curry.Base.Position + , Curry.Base.Pretty + , Curry.Base.Span + , Curry.Base.SpanInfo + , Curry.CondCompile.Parser + , Curry.CondCompile.Transform + , Curry.CondCompile.Type + , Curry.Files.Filenames + , Curry.Files.PathUtils + , Curry.Files.Unlit + , Curry.FlatCurry + , Curry.FlatCurry.Files + , Curry.FlatCurry.Goodies + , Curry.FlatCurry.InterfaceEquivalence + , Curry.FlatCurry.Pretty + , Curry.FlatCurry.Type + , Curry.FlatCurry.Typeable + , Curry.FlatCurry.Annotated.Goodies + , Curry.FlatCurry.Annotated.Type + , Curry.FlatCurry.Typed.Goodies + , Curry.FlatCurry.Typed.Type + , Curry.Syntax + , Curry.Syntax.Extension + , Curry.Syntax.InterfaceEquivalence + , Curry.Syntax.Lexer + , Curry.Syntax.Parser + , Curry.Syntax.Pretty + , Curry.Syntax.ShowModule + , Curry.Syntax.Type + , Curry.Syntax.Utils + , CompilerEnv + , CompilerOpts + , CondCompile + , CurryBuilder + , CurryDeps + , Env.Class + , Env.Instance + , Env.Interface + , Env.ModuleAlias + , Env.OpPrec + , Env.Type + , Env.TypeConstructor + , Env.Value + , Exports + , Files.CymakePath + , Generators + , Generators.GenAbstractCurry + , Generators.GenFlatCurry + , Generators.GenTypedFlatCurry + , Generators.GenAnnotatedFlatCurry + , Html.CurryHtml + , Html.SyntaxColoring + , IL + , IL.Pretty + , IL.ShowModule + , IL.Type + , IL.Typing + , Imports + , Interfaces + , Modules + , TokenStream + , Transformations + , Transformations.CaseCompletion + , Transformations.CurryToIL + , Transformations.Derive + , Transformations.Desugar + , Transformations.Dictionary + , Transformations.Lift + , Transformations.Newtypes + , Transformations.Qual + , Transformations.Simplify + , Paths_curry_frontend + autogen-modules: + Paths_curry_frontend + +executable curry-frontend + hs-source-dirs: app + main-is: cymake.hs + default-language: Haskell2010 + ghc-options: -Wall + build-depends: + base >= 4.11 + , curry-frontend + +test-suite test-frontend + type: detailed-0.9 + hs-source-dirs: test + test-module: TestFrontend + default-language: Haskell2010 + other-extensions: CPP, TemplateHaskell + ghc-options: -Wall + build-depends: + base >= 4.11 + , Cabal >= 1.20 + , template-haskell >= 2.10 + , extra >= 1.4.6 + , transformers + , mtl + , directory >= 1.2.0.1 + , filepath + , file-embed + , containers + , set-extra + , bytestring >= 0.10 + , process + , network-uri >= 2.6 + , pretty + , curry-frontend diff --git a/data/currysource.css b/data/currysource.css new file mode 100644 --- /dev/null +++ b/data/currysource.css @@ -0,0 +1,95 @@ +:root { + --link-bg-color: lightyellow; + --line-number-color: grey; + --pragma-color: green; + --comment-color: green; + --keyword-color: blue; + --symbol-color: red; + --type-color: orange; + --cons-color: magenta; + --label-color: darkgreen; + --func-color: purple; + --ident-color: black; + --module-color: brown; + --number-color: teal; + --string-color: maroon; + --char-color: maroon; + color-scheme: light dark; +} + +body { + font-family: monospace; + text-size-adjust: none; + -moz-text-size-adjust: none; + -ms-text-size-adjust: none; + -webkit-text-size-adjust: none; +} + +table { + border-collapse: collapse; +} + +/* Hyperlinks */ +a:link, +a:visited, +a:active { + background: var(--link-bg-color); + text-decoration: none; +} + +/* Line numbers */ +.line-numbers { + border-right: 1px solid var(--line-number-color); + color: var(--line-number-color); + min-width: 5ch; + padding-right: 1em; + text-align: right; +} + +/* Source code */ +.source-code { + padding-left: 1em; +} + +/* Code highlighting */ +.pragma { color: var(--pragma-color) } +.comment { color: var(--comment-color) } +.keyword { color: var(--keyword-color) } +.symbol { color: var(--symbol-color) } +.type { color: var(--type-color) } +.cons { color: var(--cons-color) } +.label { color: var(--label-color) } +.func { color: var(--func-color) } +.ident { color: var(--ident-color) } +.module { color: var(--module-color) } +.number { color: var(--number-color) } +.string { color: var(--string-color) } +.char { color: var(--char-color) } + +@supports not (color-scheme: light dark) { + @media (prefers-color-scheme: dark) { + html { + background: hsl(0, 0%, 12%); + color: white; + } + } +} + +@media (prefers-color-scheme: dark) { + :root { + --link-bg-color: hsl(0, 0%, 17%); + --pragma-color: hsl(0, 0%, 60%); + --comment-color: hsl(0, 0%, 60%); + --keyword-color: hsl(300, 66%, 70%); + --symbol-color: hsl(0, 66%, 70%); + --type-color: hsl(60, 66%, 70%); + --cons-color: hsl(330, 66%, 70%); + --label-color: hsl(240, 66%, 70%); + --func-color: hsl(200, 66%, 70%); + --ident-color: hsl(0, 0%, 85%); + --module-color: hsl(20, 66%, 70%); + --number-color: hsl(180, 66%, 70%); + --string-color: hsl(120, 66%, 70%); + --char-color: hsl(120, 66%, 70%); + } +} diff --git a/src/Arity.hs b/src/Arity.hs deleted file mode 100644 --- a/src/Arity.hs +++ /dev/null @@ -1,133 +0,0 @@ -------------------------------------------------------------------------------- -------------------------------------------------------------------------------- --- --- Arity - provides functions for expanding the arity environment 'ArityEnv' --- (see Module "Base") --- --- September 2005, --- Martin Engelke (men@informatik.uni-kiel.de) --- -module Arity (bindArities) where - -import Curry.Base.Ident -import Curry.Syntax - -import Base(ArityEnv, bindArity) - - -------------------------------------------------------------------------------- - --- Expands the arity envorinment with (global / local) function arities and --- constructor arities -bindArities :: ArityEnv -> Module -> ArityEnv -bindArities aEnv (Module mid _ decls) - = foldl (visitDecl mid) aEnv decls - - -------------------------------------------------------------------------------- - -visitDecl :: ModuleIdent -> ArityEnv -> Decl -> ArityEnv -visitDecl mid aEnv (DataDecl _ _ _ cdecls) - = foldl (visitConstrDecl mid) aEnv cdecls -visitDecl mid aEnv (ExternalDecl _ _ _ id texpr) - = bindArity mid id (typeArity texpr) aEnv -visitDecl mid aEnv (FunctionDecl _ id equs) - = let (Equation _ lhs rhs) = head equs - in visitRhs mid (visitLhs mid id aEnv lhs) rhs -visitDecl _ aEnv _ = aEnv - - -visitConstrDecl :: ModuleIdent -> ArityEnv -> ConstrDecl -> ArityEnv -visitConstrDecl mid aEnv (ConstrDecl _ _ id texprs) - = bindArity mid id (length texprs) aEnv -visitConstrDecl mid aEnv (ConOpDecl _ _ _ id _) - = bindArity mid id 2 aEnv - - -visitLhs :: ModuleIdent -> Ident -> ArityEnv -> Lhs -> ArityEnv -visitLhs mid _ aEnv (FunLhs id params) - = bindArity mid id (length params) aEnv -visitLhs mid id aEnv (OpLhs _ _ _) - = bindArity mid id 2 aEnv -visitLhs _ _ aEnv _ = aEnv - - -visitRhs :: ModuleIdent -> ArityEnv -> Rhs -> ArityEnv -visitRhs mid aEnv (SimpleRhs _ expr decls) - = foldl (visitDecl mid) (visitExpression mid aEnv expr) decls -visitRhs mid aEnv (GuardedRhs cexprs decls) - = foldl (visitDecl mid) (foldl (visitCondExpr mid) aEnv cexprs) decls - - -visitCondExpr :: ModuleIdent -> ArityEnv -> CondExpr -> ArityEnv -visitCondExpr mid aEnv (CondExpr _ cond expr) - = visitExpression mid (visitExpression mid aEnv expr) cond - - -visitExpression :: ModuleIdent -> ArityEnv -> Expression -> ArityEnv -visitExpression mid aEnv (Paren expr) - = visitExpression mid aEnv expr -visitExpression mid aEnv (Typed expr _) - = visitExpression mid aEnv expr -visitExpression mid aEnv (Tuple _ exprs) - = foldl (visitExpression mid) aEnv exprs -visitExpression mid aEnv (List _ exprs) - = foldl (visitExpression mid) aEnv exprs -visitExpression mid aEnv (ListCompr _ expr stmts) - = foldl (visitStatement mid) (visitExpression mid aEnv expr) stmts -visitExpression mid aEnv (EnumFrom expr) - = visitExpression mid aEnv expr -visitExpression mid aEnv (EnumFromThen expr1 expr2) - = foldl (visitExpression mid) aEnv [expr1,expr2] -visitExpression mid aEnv (EnumFromTo expr1 expr2) - = foldl (visitExpression mid) aEnv [expr1,expr2] -visitExpression mid aEnv (EnumFromThenTo expr1 expr2 expr3) - = foldl (visitExpression mid) aEnv [expr1,expr2,expr3] -visitExpression mid aEnv (UnaryMinus _ expr) - = visitExpression mid aEnv expr -visitExpression mid aEnv (Apply expr1 expr2) - = foldl (visitExpression mid) aEnv [expr1,expr2] -visitExpression mid aEnv (InfixApply expr1 _ expr2) - = foldl (visitExpression mid) aEnv [expr1,expr2] -visitExpression mid aEnv (LeftSection expr _) - = visitExpression mid aEnv expr -visitExpression mid aEnv (RightSection _ expr) - = visitExpression mid aEnv expr -visitExpression mid aEnv (Lambda _ _ expr) - = visitExpression mid aEnv expr -visitExpression mid aEnv (Let decls expr) - = foldl (visitDecl mid) (visitExpression mid aEnv expr) decls -visitExpression mid aEnv (Do stmts expr) - = foldl (visitStatement mid) (visitExpression mid aEnv expr) stmts -visitExpression mid aEnv (IfThenElse _ expr1 expr2 expr3) - = foldl (visitExpression mid) aEnv [expr1,expr2,expr3] -visitExpression mid aEnv (Case _ expr alts) - = visitExpression mid (foldl (visitAlt mid) aEnv alts) expr -visitExpression _ aEnv _ = aEnv - - -visitStatement :: ModuleIdent -> ArityEnv -> Statement -> ArityEnv -visitStatement mid aEnv (StmtExpr _ expr) - = visitExpression mid aEnv expr -visitStatement mid aEnv (StmtDecl decls) - = foldl (visitDecl mid) aEnv decls -visitStatement mid aEnv (StmtBind _ _ expr) - = visitExpression mid aEnv expr - - -visitAlt :: ModuleIdent -> ArityEnv -> Alt -> ArityEnv -visitAlt mid aEnv (Alt _ _ rhs) - = visitRhs mid aEnv rhs - - - -------------------------------------------------------------------------------- - --- Computes the function arity using a type expression -typeArity :: TypeExpr -> Int -typeArity (ArrowType _ t2) = 1 + typeArity t2 -typeArity _ = 0 - - -------------------------------------------------------------------------------- -------------------------------------------------------------------------------- diff --git a/src/Base.lhs b/src/Base.lhs deleted file mode 100644 --- a/src/Base.lhs +++ /dev/null @@ -1,557 +0,0 @@ -% $Id: Base.lhs,v 1.77 2004/02/15 22:10:25 wlux Exp $ -% -% Copyright (c) 1999-2004, Wolfgang Lux -% See LICENSE for the full license. -% -% Modified by Martin Engelke (men@informatik.uni-kiel.de) -% -\nwfilename{Base.lhs} -\section{Common Definitions for the Compiler} - -The module Base implements the anti-pattern 'God-object'. -By providing definitions for various unrelated phases of the -compiler, it irrevocably turns the module structure into spaghetti. -(hsi, 2009) - -\begin{verbatim} - -> module Base where - -> import Data.List -> import Control.Monad -> import Data.Maybe -> import qualified Data.Map as Map - -> import Curry.Base.Ident -> import Curry.Base.Position -> import Types -> import qualified Curry.Syntax as CS -> import Curry.Syntax.Utils -> import TopEnv -> import Utils - - - -\end{verbatim} -\paragraph{Types} -The functions \texttt{toType}, \texttt{toTypes}, and \texttt{fromType} -convert Curry type expressions into types and vice versa. The -functions \texttt{qualifyType} and \texttt{unqualifyType} add and -remove module qualifiers in a type, respectively. - -When Curry type expression are converted with \texttt{toType} or -\texttt{toTypes}, type variables are assigned ascending indices in the -order of their occurrence. It is possible to pass a list of additional -type variables to both functions which are assigned indices before -those variables occurring in the type. This allows preserving the -order of type variables in the left hand side of a type declaration. -\begin{verbatim} - -> toQualType :: ModuleIdent -> [Ident] -> CS.TypeExpr -> Type -> toQualType m tvs = qualifyType m . toType tvs - -> toQualTypes :: ModuleIdent -> [Ident] -> [CS.TypeExpr] -> [Type] -> toQualTypes m tvs = map (qualifyType m) . toTypes tvs - -> toType :: [Ident] -> CS.TypeExpr -> Type -> toType tvs ty = toType' (Map.fromList (zip (tvs ++ tvs') [0..])) ty -> where tvs' = [tv | tv <- nub (fv ty), tv `notElem` tvs] - -> toTypes :: [Ident] -> [CS.TypeExpr] -> [Type] -> toTypes tvs tys = map (toType' (Map.fromList (zip (tvs ++ tvs') [0..]))) tys -> where tvs' = [tv | tv <- nub (concatMap fv tys), tv `notElem` tvs] - -> toType' :: Map.Map Ident Int -> CS.TypeExpr -> Type -> toType' tvs (CS.ConstructorType tc tys) = -> TypeConstructor tc (map (toType' tvs) tys) -> toType' tvs (CS.VariableType tv) = -> maybe (internalError ("toType " ++ show tv)) TypeVariable (Map.lookup tv tvs) -> toType' tvs (CS.TupleType tys) -> | null tys = TypeConstructor (qualify unitId) [] -> | otherwise = TypeConstructor (qualify (tupleId (length tys'))) tys' -> where tys' = map (toType' tvs) tys -> toType' tvs (CS.ListType ty) = TypeConstructor (qualify listId) [toType' tvs ty] -> toType' tvs (CS.ArrowType ty1 ty2) = -> TypeArrow (toType' tvs ty1) (toType' tvs ty2) -> toType' tvs (CS.RecordType fs rty) = -> TypeRecord (concatMap (\ (ls,ty) -> map (\l -> (l, toType' tvs ty)) ls) fs) -> (maybe Nothing -> (\ty -> case toType' tvs ty of -> TypeVariable tv -> Just tv -> _ -> internalError ("toType " ++ show ty)) -> rty) - -> fromQualType :: ModuleIdent -> Type -> CS.TypeExpr -> fromQualType m = fromType . unqualifyType m - -> fromType :: Type -> CS.TypeExpr -> fromType (TypeConstructor tc tys) -> | isTupleId c = CS.TupleType tys' -> | c == listId && length tys == 1 = CS.ListType (head tys') -> | c == unitId && null tys = CS.TupleType [] -> | otherwise = CS.ConstructorType tc tys' -> where c = unqualify tc -> tys' = map fromType tys -> fromType (TypeVariable tv) = -> CS.VariableType (if tv >= 0 then nameSupply !! tv -> else mkIdent ('_' : show (-tv))) -> fromType (TypeConstrained tys _) = fromType (head tys) -> fromType (TypeArrow ty1 ty2) = CS.ArrowType (fromType ty1) (fromType ty2) -> fromType (TypeSkolem k) = CS.VariableType (mkIdent ("_?" ++ show k)) -> fromType (TypeRecord fs rty) = -> CS.RecordType (map (\ (l,ty) -> ([l], fromType ty)) fs) -> (maybe Nothing (Just . fromType . TypeVariable) rty) - - - -\end{verbatim} -\paragraph{Interfaces} -The compiler maintains a global environment holding all (directly or -indirectly) imported interfaces. - -The function \texttt{bindFlatInterface} transforms FlatInterface -information (type \texttt{FlatCurry.Prog} to MCC interface declarations -(type \texttt{CurrySyntax.IDecl}. This is necessary to process -FlatInterfaces instead of ".icurry" files when using MCC as frontend -for PAKCS. -\begin{verbatim} - -> type ModuleEnv = Map.Map ModuleIdent [CS.IDecl] - -> lookupModule :: ModuleIdent -> ModuleEnv -> Maybe [CS.IDecl] -> lookupModule = Map.lookup - - -\end{verbatim} -\paragraph{Type constructors} -For all defined types the compiler must maintain kind information. At -present, Curry does not support type classes. Therefore its type -language is first order and the only information that must be recorded -is the arity of each type. For algebraic data types and renaming types -the compiler also records all data constructors belonging to that -type, for alias types the type expression to be expanded is saved. In -order to manage the import and export of types, the names of the -original definitions are also recorded. On import two types are -considered equal if their original names match. - -The information for a data constructor comprises the number of -existentially quantified type variables and the list of the argument -types. Note that renaming type constructors have only one type -argument. - -Importing and exporting algebraic data types and renaming types is -complicated by the fact that the constructors of the type may be -(partially) hidden in the interface. This facilitates the definition -of abstract data types. An abstract type is always represented as a -data type without constructors in the interface regardless of whether -it is defined as a data type or as a renaming type. When only some -constructors of a data type are hidden, those constructors are -replaced by underscores in the interface. Furthermore, if the -right-most constructors of a data type are hidden, they are not -exported at all in order to make the interface more stable against -changes which are private to the module. -\begin{verbatim} - -> data TypeInfo = DataType QualIdent Int [Maybe (Data [Type])] -> | RenamingType QualIdent Int (Data Type) -> | AliasType QualIdent Int Type -> deriving Show - -> data Data a = Data Ident Int a deriving Show - -> instance Entity TypeInfo where -> origName (DataType tc _ _) = tc -> origName (RenamingType tc _ _) = tc -> origName (AliasType tc _ _) = tc -> merge (DataType tc n cs) (DataType tc' _ cs') -> | tc == tc' = Just (DataType tc n (mergeData cs cs')) -> where mergeData ds [] = ds -> mergeData [] ds = ds -> mergeData (d:ds) (d':ds') = d `mplus` d' : mergeData ds ds' -> merge (DataType tc n _) (RenamingType tc' _ nc) -> | tc == tc' = Just (RenamingType tc n nc) -> merge (RenamingType tc n nc) (DataType tc' _ _) -> | tc == tc' = Just (RenamingType tc n nc) -> merge (RenamingType tc n nc) (RenamingType tc' _ _) -> | tc == tc' = Just (RenamingType tc n nc) -> merge (AliasType tc n ty) (AliasType tc' _ _) -> | tc == tc' = Just (AliasType tc n ty) -> merge _ _ = Nothing - -> tcArity :: TypeInfo -> Int -> tcArity (DataType _ n _) = n -> tcArity (RenamingType _ n _) = n -> tcArity (AliasType _ n _) = n - -\end{verbatim} -Types can only be defined on the top-level; no nested environments are -needed for them. Tuple types must be handled as a special case because -there is an infinite number of potential tuple types making it -impossible to insert them into the environment in advance. -\begin{verbatim} - -> type TCEnv = TopEnv TypeInfo - -> bindTypeInfo :: (QualIdent -> Int -> a -> TypeInfo) -> ModuleIdent -> -> Ident -> [Ident] -> a -> TCEnv -> TCEnv -> bindTypeInfo f m tc tvs x -> = bindTopEnv "Base.bindTypeInfo" tc t -> . qualBindTopEnv "Base.bindTypeInfo" tc' t -> where tc' = qualifyWith m tc -> t = f tc' (length tvs) x - -> lookupTC :: Ident -> TCEnv -> [TypeInfo] -> lookupTC tc tcEnv = lookupTopEnv tc tcEnv ++! lookupTupleTC tc - -> qualLookupTC :: QualIdent -> TCEnv -> [TypeInfo] -> qualLookupTC tc tcEnv = -> qualLookupTopEnv tc tcEnv ++! lookupTupleTC (unqualify tc) - -> lookupTupleTC :: Ident -> [TypeInfo] -> lookupTupleTC tc -> | isTupleId tc = [tupleTCs !! (tupleArity tc - 2)] -> | otherwise = [] - -> tupleTCs :: [TypeInfo] -> tupleTCs = map typeInfo tupleData -> where typeInfo (Data c _ tys) = -> DataType (qualifyWith preludeMIdent c) (length tys) -> [Just (Data c 0 tys)] - -> tupleData :: [Data [Type]] -> tupleData = [Data (tupleId n) 0 (take n tvs) | n <- [2..]] -> where tvs = map typeVar [0..] - -\end{verbatim} -\paragraph{Function and constructor types} -In order to test the type correctness of a module, the compiler needs -to determine the type of every data constructor, function, -variable, record and label in the module. -For the purpose of type checking there is no -need for distinguishing between variables and functions. For all objects -their original names and their types are saved. Functions also -contain arity information. Labels currently contain the name of their -defining record. On import two values -are considered equal if their original names match. -\begin{verbatim} - -> data ValueInfo = DataConstructor QualIdent ExistTypeScheme -> | NewtypeConstructor QualIdent ExistTypeScheme -> | Value QualIdent TypeScheme -> | Label QualIdent QualIdent TypeScheme -> -- Label