Commit 5e3fafb0 authored by Thomas van Noort's avatar Thomas van Noort
Browse files

Post-migration cleanup: removing folders that are already in other repositories

parent 588ebdf9
Pipeline #21074 failed with stages
in 16 seconds
\DThe Concurrent Clean Programming Development System
\c© 1987-1998
\cUniversity of Nijmegen
\cHILT - High Level Software Tools B.V.
\cNijmegen - The Netherlands
\cThis programming environment for
\cthe lazy functional language Concurrent Clean
\chas been written in Clean.
\dThe Concurrent Clean System
\c is distributed via
\dwww (
\dftp (
\dMacintosh, PC (Windows 95/NT,OS/2,Linux) and Sun (Solaris,SunOS).
\DThe Concurrent Clean Program Development System
\dDraft Version 1.3 - April 1998
\d© 1987-1998
Concurrent Clean 1.3 is a general purpose, higher order, pure and lazy func-
tional programming language that can be used for the development of se-
quential, parallel or distributed executing real world applications.
The Concurrent Clean Programming Development System is a special pro-
gramming environment for Concurrent Clean.
\D2. Copyright Notice and Disclaimer
Concurrent Clean and the Concurrent Clean Program Development System
© 1987-1998
Computing Science Institute
University of Nijmegen
Nijmegen - The Netherlands
HILT - High Level Software Tools B.V.
Nijmegen - The Netherlands
We do not make any warranty, either express or implied, with respect to this
\D3. Availability
Concurrent Clean is available for Macintosh, PowerMac, Sun (SunOS, Solaris) and
PC (Windows, OS/2, Linux).
Clean is a commercial product, so, for commercial use a license is required.
Please contact:
Rinus Plasmeijer, Department of Computer Science, University of Nijmegen,
Toernooiveld 1, 6525 ED Nijmegen, The Netherlands
Concurrent Clean and the Concurrent Clean Programming Development System
are distributed free for educational and research purposes only!
Please send us your electronic mail address when you take a copy such that we
can inform you about important changes and upgrades (mail to
Permission is granted to make and distribute copies of this version for edu-
cational purposes, provided the disclaimer, the copyright notice, the Reference
Manual and the Clean Help file are preserved on all copies. Without a special
license, the software may not, however, be used for commercial purposes, be
sold or distributed for profit, or included with other software which is sold or
distributed for profit.
If you would like to obtain the latest information about Concurrent Clean, have
bugs to report, or when you have wishes or comments, please send an
electronic mail to or to
\D4. More information on the language Clean
A description of the syntax and semantics of Concurrent Clean 1.3 can be found
in the following manual which is included in the distribution:
\jConcurrent Clean
\cLanguage Report
\c- version 1.3 -
\cRinus Plasmeijer and Marko van Eekelen
\cUniversity of Nijmegen
The ideas behind Clean and its implementation on sequential and parallel
machine architectures are explained in detail in the following textbook:
\jFunctional Programming and Parallel Graph Rewriting
\cRinus Plasmeijer and Marko van Eekelen
\cAddison-Wesley Publishing Company
\cISBN 0-201-41663-8
The latest papers on Clean can be found on
\D5. The Integrated Development Environment (1.3)
The Concurrent Clean Programming Development System is a programming
environment for Concurrent Clean written in Clean itself.
The current version 1.3 of the system contains:
¥ An integrated development environment providing an automatic make
facility, advanced search facilities and a built-in text-editor.
¥ A compiler and code generator for the platform on which the system is
running. A linker is included that generates stand-alone Mac applications. Such
an application can also be sub-launched from the Clean system.
\D6. Installation
Please follow the installation descriptions of the distribution which are platform
Make a back-up of your old Clean programs, Clean system and I/O libraries.
Put the Clean compiler, Program Development System, all folders, libraries, the
Clean Help file in one folder on your Machine. Put the example programs in any
folder you like. Put related Clean programs (a Clean project) in one folder.
The Concurrent Clean System generates native applications. If you have Virus
detectors they may complain about this. Clear the protection for the Clean
compiler and editor. They should be allowed to create, edit and delete other
files (but not system files). Make sure that you have an original unaf-fected
Nijmegen version of the Clean System (see availability).
Make sure that the following path names are set in the default paths (choose
Paths... in the Options menu) such that at least the following standard Clean
libraries can be found (assuming that the Clean 1.3 application and the libraries
are put into one folder):
{Application}:MacInterface: (for Mac applications only)
{Application}:PowerMacInterface: (for PowerMac applications only)
Path names that are printed in italics do not lead to the indicated libraries.
Remove these paths and add the missing libraries.
It is possible that you have received a version of the Clean System in which the
object files and/or .abc files of the I/O and arithmetic libraries are not present,
for example to save disk space and/or copying time. Compilation of an
application using the I/O libraries may take some time then, because code has
to be generated for all modules of these libraries. Fortunately this has to be
done only once, so the next time compilation will be much faster.
\D6. Quick Try
Install the system properly (see Installation).
¥ Double-click on one of the example programs.
The Concurrent Clean System should now launch.
¥ Now select Run in the Commands menu (command R).
The system should compile, generate code, build an application and launch it. If
all files are already consistent, the project manager will just launch the
Building the application might not succeed when you have virus detections
active (see Installation). Launching will not succeed when the generated ap-
plication has not enough memory to run. This is the case when your Mac has
not enough free memory left. Quit other applications until enough free mem-ory
is available. It is also possible that you have to quit the Concurrent Clean
System and launch the generated application from the operating system. It is
also possible that not the right amount of memory is assigned to the gener-ated
application. Increase or decrease the amount of memory (see Applica-tion... in
the Options menu).
The application might not run when you have generated code that is not suited
for your platform. The generated application will warn you about this situation
when it is launched. Regenerate the application but now choose the proper
option for the Code Generator (see Code Generator... in the Options menu).
\D7. Help
The Help window displays the help information you are reading now. It is
opened by choosing the Help... command in the Window menu.
Use the scroll bar to scroll through the manual.
\D8. System Parts
The Concurrent Clean System version 1.3 consists of the following parts:
¥ The Project Manager
¥ The Text Editor
¥ The Clean Compiler
¥ The Code Generator
¥ The Linker
¥ Libraries for arithmetic, I/O handling, utility modules for interfacing
\dThe Project Manager
The Concurrent Clean Project Manager checks and controls the consistency of all
the files, windows and options of the system such that the compilation of Clean
programs and the creation, execution of applications can be invoked with only
one command.
All information about a project is remembered such that a second compila-tion
goes much faster than the first one. The information about a project is stored in
a file (name.prj) such that projects can be continued in the same status they are
A Clean program consists of modules that can be compiled separately. There are
implementation modules (name.icl) and definition modules (name.dcl). Only
implementation modules can be compiled explicitly, the corresponding
definition modules are checked automatically.
Modules are hierarchical. The top-most implementation module is called the
main module or start module. It should contain a Start rule (see the Clean
Language Report).
The project manager needs to know what the main module is. When this
module is known all other modules (and the corresponding intermediate files)
in the hierarchy are examined by the manager. All these files together are
called a project (see Files). The name of the project is the name of the main
module. The settings of a particular project are stored in the project file
The project manager will scan your disk to find the files it needs. In order to
restrict the search time the search paths should be set as accurate as possible
(see Installation and the PathsÉ help information).
By default the implementation module displayed in the active window (see
Windows) is assumed to be the main module of the project. Any implemen-
tation module can be assigned to be the main module via New ProjectÉ and Set
Main Module in the Commands menu. The Run or Execute command in the
Commands menu always reveals what the name of the main module is.
A window can be opened on a file containing a Clean module. The contents can
be changed with the text editor (see Text Editor). When you generate an
application, the project manager may warn you when windows and files have
different contents. The Clean compiler always uses the version on disk, so donÕt
forget to save your changes before you bring your project up-to-date.
¥ Implementation modules
An implementation module (name.icl) consists of a sequence of type, func-tion,
graph, class, macro and other definitions. These definitions have in prin-ciple
only a local scope: they only have meaning in the implementation mod-ule they
are defined in. In the corresponding definition module one can specify which
types and rules (defined in the corresponding implementation module) are
exported, i.e. are made visible to the outside world.
¥ The main module
The main module is always an implementation module. In its module header
the keyword "implementation" can be left out. In that case the main module
does not need a corresponding definition module. Furthermore, a main mod-ule
should always contain an explicit or implicit declaration of the Start rule, i.e.
this rule should either be defined in the start module or
imported from another module. Any implementation module can become a
main module by inserting a start rule. This is helpful for the debugging of
¥ Definition modules
In a definition module (name.dcl) one can specify which definitions (defined in
the corresponding implementation module) are exported, i.e. are made visible
to the outside world. All other definitions given in the implementation module
remain hidden.
¥ System modules
System modules are special definition modules indicated by the keyword
"system" instead of "definition". This indicates that the corresponding imple-
mentation modules are special system modules. These modules are prede-fined
and can only be made by system programmers.
Files used by the Concurrent Clean System have certain extensions that indi-cate
their use. The following kind of files are recognized by the Concurrent Clean
¥ name.icl
A Concurrent Clean implementation module with the name ÒnameÓ.
¥ name.dcl
A Concurrent Clean definition module.
It is assumed that a .icl file and its corresponding .dcl file are always kept in
one and the same folder.
A (P)abc file generated by the Clean (to Pabc) compiler.
¥ name.obj0, name.obj1, name.obj2, name.o, ...
These are object files generated by the code generator. The extension indi-cates
the type of processor that the file is generated for (e.g. obj0 = 68000, obj1 =
68020 without Floating Point Unit, obj2 = 68020 with Floating Point Unit,
The generated abc and object files are stored in the Clean System Files folder
that will be generated in the folder where the corresponding .icl (and .dcl) files
are stored.
¥ name.prj
The project file.
¥ name
An application generated by the linker.
¥ name.a, name.asm, ...
An assembly file generated by the code generator.
The generated application and assembly files will be stored in the same folder
as the corresponding .icl (and .dcl) files.
The .icl, .dcl, .abc, .a files are text files which can be edited by the Concurrent
Clean editor.
Several kinds of windows can appear on your screen.
¥ .icl window
A window on an implementation module.
¥ .dcl window
A window on a definition module.
¥ Types window
A window that displays derived and checked type information as well as
the derived and assumed strictness information.
¥ Errors window
A window that displays warnings and error messages generated by the sys-tem.
¥ Help window
A window on the Clean Help file.
¥ Project window
A dialog box that displays information on the current project.
Furthermore, the following text windows can be opened:
¥ .abc window contains a file with Pabc machine instructions
¥ any other text file can be opened in a window as well.
All windows above are so-called text windows, with the exception of the Help
and Project window.
\dThe Text Editor
All text files (see Files) can be edited with the Text Editor using the com-mands
available in the Edit and Search menus.
The editor has an auto indent facility. When this option is on the editor will
remember the first non-tab, non-space position at the beginning of the line.
When a return is typed the cursor will move to the remembered position in the
next (new) line and the needed amount of tabs and spaces will be added. When
an option-return is typed the cursor will move to the beginning of the next
(new) line. The auto indent option can be switched on and off in the Format
dialog (see Format... under the Edit menu).
The following abbreviations exist in the editor of the Clean System:
Backspace delete previous character
Delete delete next character
Option-Backspace delete to begin of word
Option-Delete delete to end of word
Command-Backspace delete to begin of line
Command-Delete delete to end of line
\bCursor movement:
Left one character left
Right one character right
Up one line up
Down one line down
Option-Left one word left
Option-Right one word right
Command-Left begin of line
Command-Right end of line
Option-Up top of window / previous page
Option-Down end of window / next page
Command-Up begin of file
Command-Down end of file
Shift + Any of the Above extend current selection
\bLocating definitions of symbols
The editor also contains two key and mouse combinations with which defini-
tions of imported Clean symbols (functions, types and constructors) can be
Command + Double-click on a Clean symbol Locates the definition of the symbol
in its .dcl file.
Command-Shift + Double-click on a Clean symbol Locates the definition of the
symbol in its .icl file.
The same effect can be achieved by selecting a symbol name and then choosing
Find Definition (for the .dcl file) or Find Implementation (for the .icl file) in the
Search menu. Warning: Functions that have no type specification cannot be
found. When your Clean modules have a (very) unusual lay-out the search
algorithm might also not be able to find the definitions of Clean symbols.
Only symbols can be found in files which are located in the folders indicated in
the path settings.
See also the commands Open Implementation and Open Definition (under the
File menu).
\dThe Concurrent Clean Compiler
The Concurrent Clean compiler compiles an implementation module to abc-code.
It performs syntactical and semantical checks (see the Clean Language Re-port).
The corresponding definition module is also checked, as well as the consistency
between definition and implementation module. Errors are re-ported in the
Errors window.
(Uniqueness) type information is inferred and checked. Strictness informa-tion is
inferred with help of the built-in strictness analyser. On demand, the type and
strictness information is displayed in the Types window.
If no errors are found, abc-code is generated. For each .icl module a file .abc will
be created in the corresponding Clean System Files folder. This code is input for
the Code Generator to build an application.
\dThe Code Generator / Linker
The Code Generator takes sequential abc-code as input (an .abc file) and pro-
duces an object file in the Clean System Files folder. The linker links all ob-ject
files of the project together and builds a Mac application.
By default, the Code Generator generates code for the machine that you are
working on. If you want to generate code for a different processor, check one of
the other options. See Code GeneratorÉ in the Options menu.
When you are developing your program you should use the Check Stacks and
Check Indices options. This will add checks for stack overflows and out-of-
bound array operations. After youÕve convinced yourself that your program
doesnÕt violate these conditions, you can remove these checks for optimal speed.
Heap and stack space must be allocated to the application. Also other options
can be set (see ApplicationÉ in the Options menu). These settings take effect the
next time the application is linked. The current project name (see Execute in the
Commands menu) determines of which application the options will be set. On
demand, the Code Generator can produce assembly files. To produce the
assembly code choose Generate Assembly in the Commands menu. The
assembly file is generated in the same directory as the Clean icl module with
the .a extension.
\D9. The Menus
This section describes each of Concurrent CleanÕs menus.
\dThe Apple Menu
\b¥ About Clean SystemÉ
This command opens Concurrent CleanÕs About window.
\dThe File Menu
\b¥ NewÉ
A new window to a new file will be opened with the default name Unti-tled.icl.
This default name can be changed in the Dialog.
The window can be edited with the Concurrent Clean text editor and its con-
tents can be saved to the file (see Save and Save AsÉ)
\b¥ OpenÉ
Open a window on an existing file.
The standard Open dialog appears.
\b¥ Close
Closes the active (front) window.
A dialog will appear when a text window is closed with a contents different
from the corresponding file.
\b¥ Open Definition
When a portion of text is selected (for ex-
ample the text "selection") the command is enabled and changes to Open
"selection.dcl". When this command is chosen it will try to open the corre-
sponding .dcl file. It can be used to quickly open imported modules: just se-lect
the name of the file in the ÒimportÓ statement and choose this command. For an
easy way to locate the definitions of imported functions and types see Find
Definition and Find Implementation under the Search menu.
When no module name is selected, you can specify the module name in a dialogue
\b¥ Open Implementation
This command works the same as the Open Definition command, but now the
implementation module (.icl file) will be opened.
\b¥ Open Other
This command will open the corresponding .dcl file if the front window is a .icl
file or vice versa.
\b¥ Save
Save the contents of the active (front) window to the corresponding file.
\b¥ Save AsÉ
Save the contents of the active (front) window to the indicated file. A stan-dard
New File dialog appears, asking you to specify the fileÕs name and loca-tion.
\b¥ Revert
Reopen the last saved version of the file corresponding to the active (front)
window. A dialog appears to warn you that the changes made after the last
time the text was saved will be lost.
\b¥ Quit
Quit the Concurrent Clean System.
\dThe Edit Menu
\b¥ Undo
Undo the last change made in the text of the front window.
\b¥ Cut
Cuts the text currently selected in the front window to the clipboard.
\b¥ Copy
Copies the text currently selected in the front window to the clipboard.
\b¥ Paste
Insert the contents of the clipboard at the current cursor location or replace the
currently selected text in the front window by the contents of the clip-board.
\b¥ Clear
Clear the text currently selected in the front window.
\b¥ Shift Left / Shift Right
With these commands you can (un)indent the selected text. Warning: undo is not
implemented for these commands.
\b¥ Balance
This commands selects the smallest balanced piece of text that surrounds the
current cursor position or currently selected text.
This feature can be used to find corresponding open and close symbols in
Concurrent Clean programs.
The following symbols are considered: Parentheses: '(' and ')' to check expres-
sions, Brackets: '[' and ']' to check lists, Curly braces: '{' and '}' to check anno-
\b¥ Select All
Select all text of the front window.
\b¥ FormatÉ
The dialog allows you to assign a new text font and text size to the active (front)
text window. Also the tab width can be redefined. With the Auto In-dent
checkbox the auto indent facility of the text editor can be switched on and off
for the active window.
The newlines option lets you specify with which newline convention the text file
will be saved.
The Use As Default button sets the default font for new files and for files for
which no font information is available. The Use Default Settings reverts the
settings to the defaults.
The font settings for a file are stored in the project file. This means that the
next time you open the file, the font settings will only be restored if you have
the same project selected.
\dThe Search Menu
\b¥ FindÉ
A dialog appears in which one can define a text to search for (in the Find Box)
and the text to replace the found text with (in the Replace Box).
By default the Find and Replace starts from the current cursor position or
currently selected text to the end of the text. On demand the Find and Re-place
goes backwards to the beginning of the text. When Wrap Around is chosen the
Find and Replace does not stop at the beginning and end of the text in the
active window. When Ignore Case is chosen, no distinction is made between
upper and lower case characters in the text to search for. When the Match
Words option is checked only whole words will be selected. When the text to
search for appears as a part of another word it will be ignored. Whole words
are delimited by outline characters (spaces, tabs, (semi)colons, quotes etcetera).
\b¥ Find Next
When a text has been entered in the Find Box (see Find...) this command
changes to Find Next. It will find the next piece of text as defined in the Find
Box. When the Option key is held down the command changes to Find Previ-ous,
which finds the previous piece of text as defined in the Find Box. When the