Modula-2

Print Print
Reading time 18:1

Modula-2
Paradigmsimperative, structured, modular, data and procedure hiding, concurrent
FamilyWirth Modula
Designed byNiklaus Wirth
First appeared1978; 43 years ago (1978)
Typing disciplineStatic, strong, safe
ScopeLexical (static)
PlatformLilith (AMD 2901)
OSCross-platform
Filename extensions.mod, .m2, .def, .MOD, .DEF, .mi, .md
Websitewww.modula2.org
Major implementations
ETH compiler written by Niklaus Wirth
GNU Modula-2
ADW Modula-2
Dialects
PIM2, PIM3, PIM4, ISO
Influenced by
Modula, Mesa, Pascal, ALGOL W, Euclid
Influenced
Modula-3, Oberon, Ada, Fortran 90, Lua, Seed7, Zonnon, Modula-GM

Modula-2 is a structured, procedural programming language developed between 1977 and 1985 by Niklaus Wirth at ETH Zurich. It was created as the language for the operating system and application software of the Lilith personal workstation.[1] It was later used for programming outside the context of the Lilith.

Wirth viewed Modula-2 as a successor to his earlier programming languages Pascal and Modula.[2][3] The main concepts are:

  1. The module as a compiling unit for separate compiling
  2. The coroutine as the basic building block for concurrent processes
  3. Types and procedures that allow access to machine-specific data

The language design was influenced by the Mesa language and the Xerox Alto, both from Xerox PARC, that Wirth saw during his 1976 sabbatical year there.[4] The computer magazine Byte devoted the August 1984 issue to the language and its surrounding environment.[5]

Modula-2 was followed by Modula-3, and later by the Oberon series of languages.

Description

Modula-2 is a general purpose procedural language, sufficiently flexible to do systems programming, but with much broader application. In particular, it was designed to support separate compiling and data abstracting in a straightforward way. Much of the syntax is based on Wirth's earlier and better-known language, Pascal. Modula-2 was designed to be broadly similar to Pascal, with some elements and syntactic ambiguities removed and the important addition of a module concept, and direct language support for multiprogramming.

The language allows use of one-pass compilers. Such a compiler by Gutknecht and Wirth was about four times faster than earlier multi-pass compilers.[6]

Here is an example of the source code for the "Hello world" program: 

MODULE Hello;
FROM STextIO IMPORT WriteString;
BEGIN
  WriteString("Hello World!");
END Hello.

A Modula-2 module may be used to encapsulate a set of related subprograms and data structures, and restrict their visibility from other parts of the program. The module design implemented the data abstraction feature of Modula-2 in a very clean way. Modula-2 programs are composed of modules, each of which is made up of two parts: a definition module, the interface portion, which contains only those parts of the subsystem that are exported (visible to other modules), and an implementation module, which contains the working code that is internal to the module.

The language has strict scope control. The scope of a module can be considered as an impenetrable wall: Except for standard identifiers, no object from the outside is visible inside a module unless explicitly imported; no internal module object is visible from the outside unless explicitly exported.

Suppose module M1 exports objects a, b, c, and P by enumerating its identifiers in an explicit export list 

  DEFINITION MODULE M1;
    EXPORT QUALIFIED a, b, c, P;
    ...

Then the objects a, b,c, and P from module M1 become now known outside module M1 as M1.a, M1.b, M1.c, and M1.P. They are exported in a qualified manner to the outside (assumed module M1 is global). The exporting module's name, i.e. M1, is used as a qualifier followed by the object's name.

Suppose module M2 contains the following IMPORT declaration 

  MODULE M2;
    IMPORT M1;
    ...

Then this means that the objects exported by module M1 to the outside of its enclosing program can now be used inside module M2. They are referenced in a qualified manner, thusly: M1.a, M1.b, M1.c, and M1.P. Example: 

    ...
    M1.a := 0;
    M1.c := M1.P(M1.a + M1.b);
    ...

Qualified export avoids name clashes: For example, if another module M3 would also export an object called P, then we can still distinguish the two objects, since M1.P differs from M3.P. Thanks to the qualified export it does not matter that both objects are called P inside their exporting modules M1 and M3.

An alternative method exists, which is in wide use by Modula-2 programmers. Suppose module M4 is formulated as this: 

  MODULE M4;
    FROM M1 IMPORT a, b, c, P;

Then this means that objects exported by module M1 to the outside can again be used inside module M4, but now by mere references to the exported identifiers in an unqualified manner, thusly: a, b, c, and P. Example: 

    ...
    a := 0;
    c := P(a + b);
    ...

This method of unqualifying import allows use of variables and other objects outside their exporting module in exactly the same simple, i.e. unqualified, manner as inside the exporting module. The walls surrounding all modules have now become irrelevant for all those objects for which this has been explicitly allowed. Of course unqualifying import is only usable if there are no name clashes.

These export and import rules may seem unnecessarily restrictive and verbose. But they do not only safeguard objects against unwanted access, but also have the pleasant side-effect of providing automatic cross-referencing of the definition of every identifier in a program: if the identifier is qualified by a module name, then the definition comes from that module. Otherwise if it occurs unqualified, simply search backwards, and you will either encounter a declaration of that identifier, or its occurrence in an IMPORT statement which names the module it comes from. This property becomes very useful when trying to understand large programs containing many modules.

The language provides for (limited) single-processor concurrency (monitors, coroutines and explicit transfer of control) and for hardware access (absolute addresses, bit manipulation, and interrupts). It uses a nominal type system.

Dialects

There are two major dialects of Modula-2. The first is PIM, named for the book Programming in Modula-2 by Niklaus Wirth.[4] There were three major editions of PIM: the second, third (corrected), and fourth. Each describes slight variants of the language. The second major dialect is ISO, named for the standardization effort by the International Organization for Standardization. Here are a few of the differences among them.

  • PIM2 (1983)
    • Required explicit EXPORT clause in definition modules.
    • Function SIZE needs to be imported from module SYSTEM
  • PIM3 (1985)
    • Removed the EXPORT clause from definition modules following the observation that everything within a definition module defines the interface to that module, hence the EXPORT clause was redundant.
    • Function SIZE is pervasive (visible in any scope without import)
  • PIM4 (1988)
    • Specified the behaviour of the MOD operator when the operands are negative.
    • Required all ARRAY OF CHAR strings to be terminated by ASCII NUL, even if the string fits exactly into its array.
  • ISO (1996, 1998)
    • ISO Modula-2 resolved most of the ambiguities in PIM Modula-2. It added the data types COMPLEX and LONGCOMPLEX, exceptions, module termination (FINALLY clause) and a complete standard input/output (I/O) library. There are many minor differences and clarifications.[7]

Supersets

There are several supersets of Modula-2 with language extensions for specific application domains:

Derivatives

There are several derivative languages that resemble Modula-2 very closely but are new languages in their own right. Most are different languages with different purposes and with strengths and weaknesses of their own:

  • Modula-3, developed by a team of ex-Xerox employees who had moved to DEC and Olivetti[12]
  • Oberon, developed at ETH Zürich for System Oberon[13]available online.
  • Oberon-2, Oberon with OO extensions[14]
  • Active Oberon, yet another object-oriented Extension of Oberon, developed also at ETH with the main objective to support parallel programming on multiprocessor and multicore systems.
  • Parallaxis, a language for machine-independent data-parallel programming[15]
  • Umbriel, developed by Pat Terry as a teaching language[16]
  • YAFL, a research language by Darius Blasband[17]

Many other current programming languages have adopted features of Modula-2.

Language elements

Reserved words

PIM [2,3,4] defines 40 reserved words: 

AND         ELSIF           LOOP       REPEAT
ARRAY       END             MOD        RETURN
BEGIN       EXIT            MODULE     SET
BY          EXPORT          NOT        THEN
CASE        FOR             OF         TO
CONST       FROM            OR         TYPE
DEFINITION  IF              POINTER    UNTIL
DIV         IMPLEMENTATION  PROCEDURE  VAR
DO          IMPORT          QUALIFIED  WHILE
ELSE        IN              RECORD     WITH

Built-in identifiers

PIM [3,4] defines 29 built-in identifiers: 

ABS         EXCL            LONGINT    REAL
BITSET      FALSE           LONGREAL   SIZE
BOOLEAN     FLOAT           MAX        TRUE
CAP         HALT            MIN        TRUNC
CARDINAL    HIGH            NIL        VAL
CHAR        INC             ODD
CHR         INCL            ORD
DEC         INTEGER         PROC

Embedded system use

Modula-2 is used to program many embedded systems.

Cambridge Modula-2

Cambridge Modula-2 by Cambridge Microprocessor Systems is based on a subset of PIM4 with language extensions for embedded development. The compiler runs on DOS and it generates code for Motorola 68000 series (M68k) based embedded microcontrollers running a MINOS operating system.

Mod51

Mod51 by Mandeno Granville Electronics is based on ISO Modula-2 with language extensions for embedded development following IEC1131, an industry standard for programmable logic controllers (PLC) closely related to Modula-2. The Mod51 compiler generates standalone code for 80C51 based microcontrollers.

Modula-GM

Delco Electronics, then a subsidiary of GM Hughes Electronics, developed a version of Modula-2 for embedded control systems starting in 1985. Delco named it Modula-GM. It was the first high-level programming language used to replace machine code (language) for embedded systems in Delco's engine control units (ECUs). This was significant because Delco was producing over 28,000 ECUs per day in 1988 for GM. This was then the world's largest producer of ECUs.[18] The first experimental use of Modula-GM in an embedded controller was in the 1985 Antilock Braking System Controller which was based on the Motorola 68xxx microprocessor, and in 1993 Gen-4 ECU used by the Champ Car World Series Championship Auto Racing Teams (CART) and Indy Racing League (IRL) teams.[19] The first production use of Modula-GM was its use in GM trucks starting with the 1990 model year vehicle control module (VCM) used to manage GM Powertrain's Vortec engines. Modula-GM was also used on all ECUs for GM's 90° Buick V6 engine family 3800 Series II used in the 1997-2005 model year Buick Park Avenue. The Modula-GM compilers and associated software management tools were sourced by Delco from Intermetrics.

Modula-2 was selected as the basis for Delco's high level language because of its many strengths over other alternative language choices in 1986. After Delco Electronics was spun off from GM (with other component divisions) to form Delphi Automotive Systems in 1995, global sourcing required that a non-proprietary high-level software language be used. ECU embedded software now developed at Delphi is compiled with commercial compilers for the language C.

Russian radionavigation satellites

The satellites of the Russian radionavigation-satellite service framework GLONASS, similar to the United States Global Positioning System (GPS), are programmed in Modula-2.[20]

Compilers

  • Amsterdam Compiler Kit (ACK) Modula-2 – for MINIX; freeware[21]
  • ADW Modula-2 – for Windows, ISO compliant, ISO/IEC 10514-1, ISO/IEC 10514-2 (OO extension), ISO/IEC 10514-3 (Generic extension); freeware[22]
  • Aglet Modula-2 – for AmigaOS 4.0 for PowerPC; freeware[23]
  • Cambridge Modula-2 – for various microcontrollers and embedded MINOS operating system; proprietary software[24]
  • Fitted Software Tools (FST) Modula-2 – for DOS; freeware[25][permanent dead link]
  • Gardens Point Modula-2 (GPM) – for BSD, Linux, OS/2, Solaris; ISO compliant; freeware, as of 30 July 2014[26]
  • Gardens Point Modula-2 (GPM/CLR) – for .NET Framework; freeware[27]
  • GNU Modula-2 – for GCC platforms, version 1.0 released December 11, 2010; compliance: PIM2, PIM3, PIM4, ISO; free software, GNU General Public License (GPL)[28]
  • M2Amiga – for Amiga; free software[29]
  • M2M – by N. Wirth and collaborators from ETH Zurich, cross-platform, generates M-code for virtual machine; freeware[30]
  • MacMETH – by N. Wirth and collaborators from ETH Zurich for Macintosh, Classic only; freeware[31]
  • Mod51 – for the Intel 80x51 microcontroller family, ISO compliant, IEC1132 extensions; proprietary software[32]
  • Megamax Modula-2 – for Atari ST with documentation in German only; freeware[33]
  • Modula-2 R10 – reference compiler for this Modula; open-source, peer review[34]
  • ModulaWare – for OpenVMS (VAX and Alpha), ISO compliant; proprietary software[35]
  • ORCA/Modula-2 – for Apple IIGS by The Byte Works for the Apple Programmer's Workshop
  • p1 Modula-2 – for Macintosh, Classic and macOS (PowerPC and Carbon (API) only), ISO compliant; proprietary software[36]
  • MOCKA – for various platforms, PIM compliant; commercial, freeware Linux/BSD versions[37]
  • TDI Modula-2 – for Atari ST, by TDI Software
  • Terra M2VMS – for OpenVMS (VAX and Alpha), PIM compliant; proprietary software[38]
  • m2c, Ulm Modula-2 System – for Solaris (Sun SPARC and Motorola 68k); free software, GNU General Public License (GPL)[39]
  • XDS – ISO compliant, TopSpeed compatible library: Native XDS-x86 for x86 (Windows and Linux); XDS-C for Windows and Linux (16- and 32-bit versions), targets C (K&R & ANSI); freeware[40]

Turbo Modula-2

Turbo Modula-2 was a compiler and an integrated development environment for MS-DOS developed, but not published, by Borland. Jensen and Partners, which included Borland cofounder Niels Jensen, bought the unreleased codebase and turned it into TopSpeed Modula-2. It was eventually sold to Clarion, now owned by SoftVelocity, which still offers the Modula-2 compiler as part of its Clarion product line.

A Zilog Z80 CP/M version of Turbo Modula-2 was briefly marketed by Echelon under license from Borland. A companion release for Hitachi HD64180 was sold by Micromint as a development tool for their SB-180 single-board computer.

IBM Modula-2

IBM had a Modula-2 compiler for internal use which ran on both OS/2 and AIX, and had first class support in IBM's E2 editor.[41] IBM Modula-2 was used for parts of the OS/400 Vertical Licensed Internal Code (effectively the kernel of OS/400).[42] This code was replaced with C++ when OS/400 was ported to the IBM RS64 processor family.[43] A Motorola 68000 backend also existed, which may have been used in embedded systems products.[41]

Operating systems

Modula-2 is used to program some operating systems (OSs). The Modula-2 module structure and support are used directly in two related OSs.

The OS named Medos-2, for the Lilith workstation, was developed at ETH Zurich, by Svend Erik Knudsen with advice from Wirth. It is a single user, object-oriented operating system built from Modula-2 modules.[44][45][46]

The OS named Excelsior, for the Kronos workstation, was developed by the Academy of Sciences of the Soviet Union, Siberian branch, Novosibirsk Computing Center, Modular Asynchronous Developable Systems (MARS) project, Kronos Research Group (KRG). It is a single user system based on Modula-2 modules.[47]

Books

  • Wirth, Niklaus (1988). Programming in Modula-2 (4th ed.). Berlin Heidelberg: Springer-Verlag. doi:10.1007/978-3-642-83565-0. ISBN 978-0-387-96051-7.
  • King, K. N. (1 January 1988). Modula-2: A Complete Guide. Burlington, Massachusetts: Jones and Bartlett Publishers. ISBN 978-0669110913.
  • Sutcliffe, Richard J. (2004–2005). Modula-2: Abstractions for Data and Programming Structures. Arjay Books. ISBN 978-0-669-11091-3. Uses ISO-standard Modula-2.
  • Gleaves, Richard (1984). Modula-2 for Pascal Programmers. Springer Books on Professional Computing (1st ed.). Switzerland: Springer Nature. doi:10.1007/978-1-4613-8531-8. ISBN 978-0-387-96051-7.
  • Cooper, Doug (1 September 1990). Oh My! Modula-2: An Introduction to Programming. New York City, New York: W. W. Norton & Company. ISBN 978-0393960099.

References

  1. ^ "Summary of Projects by N. Wirth, 1962–1999". Department of Computer Science. ETH Zurich.
  2. ^ Wirth, Niklaus (2002). "Pascal and its Successors". In Broy, Manfred; Denert, Ernst (eds.). Software Pioneers: Contributions to Software Engineering. Berlin, Heidelberg: Springer-Verlag. pp. 108–120. doi:10.1007/978-3-642-59412-0. ISBN 978-3-642-59412-0.
  3. ^ Wirth, Niklaus (18 February 2005). "History and Goals of Modula-2". Dr. Dobb's Journal. Informa PLC.
  4. ^ a b Wirth, Niklaus (1988). Programming in Modula-2 (4th ed.). Berlin, Heidelberg: Springer. doi:10.1007/978-3-642-83565-0. ISBN 978-3-642-83565-0. Page 4.
  5. ^ Wirth, Niklaus; Gutknecht, Jürg; Ohran, Richard; Paul, Robert J.; Coar, David (August 1984). "Theme: Modula-2". Byte: The Small Systems Journal. Vol. 9 no. 8. pp. 143–232. Available at Archive.org
  6. ^ Wirth, Niklaus (1 May 1984). "A Single-pass Modula-2 Compiler for Lilith" (PDF). CFB Software. Retrieved 28 January 2019.
  7. ^ ISO/IEC 10514-1:1996
  8. ^ Tichy et al., Modula-2*: An Extension for Modula-2 for highly parallel portable programs, University of Karlsruhe [1990]
  9. ^ Bräunl, Parallel Programming, Prentice-Hall [1993]
  10. ^ Muller, C. (November 1986). "Modula–Prolog: A Software Development". IEEE Software. 3 (6): 39–45}. doi:10.1109/MS.1986.229475.
  11. ^ a b modula2.org, 5. Where can I get information about ISO Modula-2?
  12. ^ Cardelli et al., Modula-3 Report, Research Report 31, Systems Research Center, Digital Equipment Corporation, [1988]
  13. ^ N. Wirth & J. Gutknecht, Project Oberon: the design of an operating system and compiler, ISBN 0-201-54428-8, Addison-Wesley [1992]
  14. ^ Moessenboeck & Wirth, The Programming Language Oberon-2, ETH Zurich [1995]
  15. ^ Thomas Bräunl, Parallaxis, a Language for Structured Data-parallel Programming, University of Stuttgart [1996]
  16. ^ Pat D. Terry, Another Minimal Programming Language, ACM SIGPLAN Notices No. 30 [1995]
  17. ^ D. Blasband, The YAFL Programming Language, Second Edition, [1993]
  18. ^ Delco Electronics Electron Magazine, The Atwood Legacy, Spring '89, page 25
  19. ^ Development of electronics for GM auto racing
  20. ^ Koltashev, A. A. (2006). "Modula-2 in Russian Space". Kronos: History of a Project (in Russian). xTech. Retrieved 8 April 2021.
  21. ^ Given, David (9 October 2020). "ACK". GitHub. Retrieved 13 March 2021.
  22. ^ "ADW Modula-2". Modula-2.org. Retrieved 13 March 2021.
  23. ^ "Aglet Modula-2". Aglet Modula-2. 15 February 2012. Retrieved 13 March 2021.
  24. ^ "Cambridge Modula-2". Cambridge Microprocessor Systems. Retrieved 13 March 2021.
  25. ^ "FST Modula-2". psg.com. Retrieved 13 March 2021.
  26. ^ "Gardens Point Modula". Programming Languages and Systems Group, Faculty of Information Technology. Queensland University of Technology, Brisbane. 29 January 2007. Archived from the original on 23 March 2013. Retrieved 13 March 2021.
  27. ^ "Gardens Point Modula-2 (GPM/CLR)". CodePlex Archive: Open Source Project Archive. Microsoft. 29 January 2007. Archived from the original on 2018. Retrieved 13 March 2021.
  28. ^ "GNU Modula-2". Savannah. Free Software Foundation. 30 August 2018. Retrieved 13 March 2021.
  29. ^ Degen, René; Nieder, Claudio; Preusing, Bernd; Schaub, Markus; Straube, Jörg (2004). "M2Amiga". Claudio's web site. A+L AG. Archived from the original on 20 January 2019. Retrieved 13 March 2021.
  30. ^ "Lilith and Modula-2". CFB Software. Retrieved 13 March 2021.
  31. ^ "MacMETH: A Fast Modula-2 Language System for Macintosh Computers". ETH Zurich: Terrestrial Systems Ecology. 22 January 2020. Retrieved 13 March 2021.
  32. ^ "Mod51 Structured Text Programming Language". Design Tools. Archived from the original on 21 October 2008. Retrieved 13 March 2021.
  33. ^ Tempelmann, Thomas (1 September 2020). "Thomas Tempelmann's home page". Retrieved 18 March 2021.
  34. ^ "Modula-2 R10". Retrieved 18 March 2021.
  35. ^ Dotzel, Chih-Ya (21 January 2020). "ModulAware". Retrieved 18 March 2021.
  36. ^ Wiedemann, Albert (13 January 2021). "p1 Modula-2". p1 Society for Computer Science. Retrieved 19 March 2021.
  37. ^ Beck, Michael; Geiss, Rubino (2006). "The Karlsruhe Modula-2 Compiler MOCKA". Institute for Program Structures and Data Organization (IPD). Karlsruhe Institute of Technology. Archived from the original on 4 September 2009. Retrieved 21 March 2021.
  38. ^ "Modula-2 systems for OpenVMS/Alpha and OpenVMS/VAX". Terra Datentechnik (in English and German). Erlenbach, Switzerland. 12 November 2002. Retrieved 23 March 2021.
  39. ^ Borchert, Andreas; Hasch, Martin (21 January 2003). "m2c: Ulm's Modula-2 System". Ulm University. Ulm, Germany. Retrieved 23 March 2021.
  40. ^ "XDS Family of Products: Modula-2 – Oberon-2 development tools". Excelsior LLC. 1999–2009. Archived from the original on 27 May 2009. Retrieved 23 March 2021.
  41. ^ a b "IBM Modula-2". edm2.com. 2 March 2019. Retrieved 12 March 2021.
  42. ^ "Reader Feedback on AS/400 to i Mystery Solved". itjungle.com. 21 February 2011. Retrieved 12 March 2021.
  43. ^ Soltis, Frank G. (1997). Inside the AS/400 (2nd ed.). Duke Press. ISBN 978-1882419661.
  44. ^ Knudsen, Svend Erik (1983). Medos-2: A Modula-2 Oriented Operating System for the Personal Computer Lilith (PhD). ETH Zurich. doi:10.3929/ethz-a-000300091.
  45. ^ Knudsen, Svend Erik (25 October 2000). "Medos in Retrospect". In Böszörményi, László; Gutknecht, Jürg; Pomberger, Gustav (eds.). The School of Niklaus Wirth: The Art of Simplicity. Morgan Kaufmann. pp. 69–86. ISBN 978-1558607231. ISBN 1-55860-723-4 & dpunkt, ISBN 3-932588-85-1.
  46. ^ Sand, Paul A. (September 1984). "The Lilith Personal Computer". Byte. pp. 300–311. Retrieved 6 March 2021. Reprint.
  47. ^ Kuznetsov, D.N.; Nedorya, A.E.; Tarasov, E.V.; Filippov, V.E. "Kronos: a family of processors for high-level languages". Kronos: History of a Project (in Russian). xTech. Retrieved 13 April 2021.

External links

This article is based on material taken from the Free On-line Dictionary of Computing prior to 1 November 2008 and incorporated under the "relicensing" terms of the GFDL, version 1.3 or later.

By: Wikipedia.org
Edited: 2021-06-18 18:14:44
Source: Wikipedia.org

© 2024 CodeDocs.org
 Privacy Policy • Contact Us • Terms of Use