|
Ronin is an implementation of Oberon programming language on .NET platform. The immediate goal of this project is providing Windows developers with the standalone command line implementation of Oberon compiler that can be instantly downloaded and used. The present release is of beta quality and should be considered work in progress.
Oberon is a programming language created in 1986 by Professor Niklaus Wirth and his associates at ETH Zurich in Switzerland. Its most important features are block structure, modularity, separate compilation, static typing with strong type checking, and type extension with type-bound procedures.
The original Oberon language report is available at at http://www.inf.ethz.ch/personal/wirth/Articles/Oberon/Oberon.Report.pdf
The present implementation supports also elements of the language extension known as Active Oberon described at http://bluebottle.ethz.ch/languagereport/index.html
Ronin compiler is implemented in C++. Its front-end is based on the ETH OP2 compiler. The relevant portions of OP2 source code originally written in Oberon have been ported to C++. The back-end generating .NET code has been written from scratch.
Ronin compiler generates the CIL (MSIL) assembly language code as the output. The ILASM assembler is required to generate portable executable (PE) files from MSIL. ILASM is shipped as part of the .NET distribution.
Ronin compiler processes one Oberon module at a time producing a separate MSIL file for each module. This file can be converted using ILASM to a DLL if the module represents a part of a library or to an EXE is the module represents a main program of an application.
At present Ronin supports the original Oberon specification as well as Object Oriented Extensions (without Definitions) of Active Oberon. Furthermore, the scoping rules have been relaxed as described in the Declaration sequence and forward references of the Active Oberon language report. Implementation of the Active Oberon Concurrency Support is planned for the future.
The license for the Ronin binary distribution can be found here.
Distributable Code of Microsoft Visual C++ 2008 Express Edition located in
ronin\bin\Microsoft.VC90.CRT may be distributed only as part of Ronin
binary software in strict conformance with the distribution requirements and
restrictions specified in the file msvc_redist.txt located in
the distribution root directory.
The most recent release of software can be downloaded at https://www.unicorn-enterprises.com/download/ronin.zip.
Installing is easy. Just download the distribution and unpack its content into any directory on your computer.
ronin
This is the root directory of the distribution. It contains the following files:
readme.html | this file |
license.txt | the license |
ronin\bin
Contains executable files:
onc.exe | Compiler |
Subdirectory ronin\bin\Microsoft.VC90.CRT contains redistributable libraries of
Microsoft Visual C++.
ronin\lib
Directory for object and executable files. Initially contains pre-built DLL files for Oberon library modules.
ronin\src
Contains various Oberon source files.
ronin\src\lib
Contains source code of Oberon library modules.
File bldlibs.bat contains instructions for building the library
modules from the source code.
It is assumed that Ronin is installed in the directory c:\util\ronin.
In case of different installation directory, the assignments of environment
variables in the batch files should be modified accordingly.
ronin\src\lib\ilasm
Contains source code of low-level Oberon library modules implemented in ILASM.
File bldlibs.bat contains instructions for building the low-level
library modules from the source code.
ronin\src\demo
Contains a collection Oberon sample programs
ronin\src\demo\po
Contains several examples from the book "Programming in Oberon" by Prof. N. Wirth.
File bldall.bat contains instructions for building all examples
from the source code. File runall.bat can be used to run
all examples.
ronin\src\demo\ad
Contains several examples from the book "Algorithms and Data Structures (Oberon Version)" by Prof. N. Wirth.
File bldall.bat contains instructions for building all examples
from the source code. File runall.bat can be used to run
all examples.
Subdirectory ronin\src\demo\ad\data contains input data
for the examples.
To start using Ronin, it is necessary to become familiar with Oberon programming language. The textbooks written by Prof. Niklaus Wirth can be used for this purpose. On-line versions of these books are available at the ETH Web site at http://www.ethoberon.ethz.ch/WirthPubl/
To compile an Oberon module file, use the following command:
onc.exe [-P objdir] [-M mainproc] source
where
objdir | directory for object files |
mainproc | name of the main procedure |
source | name of the source Oberon module file |
On successful compilation, two files will be produced: an ILASM
file Modname.il and a symbol file Modname.sym,
where Modname stands for a module name as defined in the source file using
the Oberon MODULE clause. If the directory for the object files is specified
on the command line via the -P option, the output files will be placed
in that directory, otherwise the current directory will be used.
During the compilation the compiler looks up for symbol files for imported modules.
If the directory for the object files is specified on the command line via
the -P option, the compiler will look up for symbol files in
this directory, otherwise the current directory will be used.
Thus with the current implementation it is assumed that all the ILASM, symbol, DLL, and EXE files of a particular project, be they the standard library or the project-specific files, should be located in a single directory. It is planned to remove this restriction in the future releases by implementing the symbol file lookup over the multiple directories and thus allowing object files to be located in multiple places.
The compiler will generate different versions of the ILASM output depending on whether the source code represents a library module or a main module of an application. The reason is that for the main module of an application the compiler must produce a method containing the application initialization code. This method will be marked as an entry point and will contain, in the proper order, initialization of all modules involved followed by a call to the main procedure of the application.
An Oberon module that is intended to be used as a main application module
must contain a main procedure. This must be a procedure in the module top-level
scope, having the external visibility, no parameters and no return value.
Although a conventional name for the main procedure is Main,
the user is free to choose any valid procedure name. Note that the concept
of the main procedure is specific to the Ronin implementation of Oberon
and is not part of the language specification.
The name main procedure is specified on a command line vie the -M
option. If this option is present, the compiler will produce the ILASM code
for an application main module, otherwise code for an ordinary library module
will be produced.
The subsequent compilation of an ILASM file with the MSIL assembler must conform to the nature of the module compiler, that is, MSIL must produce an EXE file for application main modules and DLL files for libraries. The desired ILASM behavior is achieved by setting the appropriate MSIL command options. Examples may be found in the compilation batch files included the demo section of this distribution.
The standard runtime library supplied with the compiler contains a collection of modules ported to .NET from the A2 operating system. At present these modules include:
Clock | Low level clock operations |
Dates | Date and time operations |
Reals | Functions for real numbers |
Streams | Support for generic I/O streams |
Strings | String operations |
Files | File operations |
Commands | Command line operations |
KernelLog | Basic logging utilities |
StringPool | Support for string pools |
BitSets | Bit set operations |
Console | Simple console I/O operations |
Debugging | Debugging utilities |
Runtime | A stub module for low-level runtime procedures |
Options | Support for command line options |
THE RONIN SOFTWARE IS PROVIDED BY THE COPYRIGHT OWNER "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 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.
Ronin compiler is based on and contains modified portions of ETH A2 (formerly Bluebottle, formerly Aos) software. This software has been copyrighted and distributed as follows:
ETH Bluebottle (formerly Aos)
Copyright (c) 2008, Computer Systems Institute, ETH Zurich
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 ETH Zurich 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.
|