Modula 2

Presented by:

Mohsan Naqi

Roll no MS-10-06 11/04/2023 1

Introduction

• Modula-2– Procedural Programming Language– Block-structured– Design was based on Pascal and Modula

• Improvements over Pascal– Modules– Low-level features– Coroutines– Syntactic features

11/04/2023 2

Design and Development

• Modules– A tool for expressing the relations between

major parts of programs and provide support for abstract data types

• Low-Level Features– a small language, which can be

implemented on a wide variety of microcomputers• Contains facilities for high-level and low-level

programming

11/04/2023 3

Design and Development

• Coroutines– Used for embedded systems that require

concurrency without the overhead of large operating systems or large languages

• Syntactic Features– Have a small vocabulary and consists of

few sentence structures• Contains simple and consistent rules of syntax,

which makes it easy to learn

11/04/2023 4

Uses of Modula-2

• Suitable for learning programming– Large projects written and maintained in the fashion

of professional software engineers– real-time embedded systems

• Safety-critical areas– Traffic control systems

• It is small, expressive, easy to learn, and to read

11/04/2023 5

History• The history of Modula-2 is the history of its designer, Dr.

Niklaus Wirth.• Dr. Wirth was a member of a large committee whose

task was to design a successor to the language ALGOL-60 in 1960.

• Modula-2 is a computer programming language designed and developed between 1977 and 1980 by Niklaus Wirth at ETH Zurich as a revision of Pascal to serve as the sole programming language for the operating system and application software for the personal workstation Lilith

• The first Modula-2 compiler, written by K. van Le in 1977 • Modula-2 compiler was designed in 1979-80 by L.

Geissmann and Ch. Jacobi with the PDP-11 compiler .• 1981, Modula-2 was in daily use and quickly proved its

worth as a powerful, efficiently implemented language

611/04/2023

Current compilers• ACK Modula-2 for Minix (freeware)• ADW Modula-2 ADW Modula-2 for Windows, ISO

compliant, ISO/IEC 10514-1, ISO/IEC 10514-2 (OO extension), ISO/IEC 10514-3 (Generic extension) (freeware)

• Aglet Modula-2 for Amiga OS 4.0/PPC (freeware)• Cambridge Modula-2 for various micro-controllers and

embedded MINOS operating system (commercial + proprietary software)

• Canterbury Modula-2 generates Java source code• FST Fitted Software Tools Modula-2 for MS-DOS

(freeware)• Gardens Point Modula-2 for BSD, Linux, OS/2, Solaris

and .NET - ISO compliant (freeware)• GNU Modula-2 for GCC platforms, version 1.0 released

December 11, 2010; PIM2, PIM3, PIM4, and ISO compliant (free software, GPLed)

• M2Amiga for Amiga (free software)• M2M by N. Wirth and collaborators from ETH Zurich,

platform independent, generates M-code for virtual machine (freeware)

• The Karlsruhe Modula-2 Compiler MOCKA for various platforms, PIM compliant (commercial, freeware

711/04/2023

11/04/2023 8

Modula 2• Has keywords: words from the

language• Always in CAPITAL letters!

• DO, FOR, IF, WHILE, END, THEN, UNTIL, LOOP, ELSE, RECORD, ARRAY, OF, TYPE, CONST, IMPORT, FROM, SET, VAR, WITH, CASE, MODULE, REAL, INTEGER…

11/04/2023 9

Program structure

• Program is called a MODULEMODULE name;

FROM …. IMPORT …;CONST pi = 3.1459;TYPE euro = REAL;

BEGIN …. (* comment *)

END name.

11/04/2023 10

Syntax• Keywords completely in CAPITAL

letters• Spaces do not matter• White lines do not matter• Signal the end of a command with

semi colon ;

• End of program with a period .

11/04/2023 11

Variables

• Convenient way to:– Store values– Manipulate values

• Closely related to the variable concept used in mathematics!

11/04/2023 12

Variables

– Need to be declared:• Name• Type

VARX : CARDINAL;

– Change the value (assignment)

X := 451;

:=

:

11/04/2023 13

Variables

• Single types:– Characters (‘a’) : CHAR– Integers (-40) : INTEGER– Reals (2.7) : REAL– Positive number (3) :

CARDINAL– Logical (TRUE/FALSE) :

BOOLEAN

11/04/2023 14

Variables

MODULE demo;VAR

a : CHAR; b : INTEGER; c : REAL; d : CARDINAL; e : BOOLEAN:

BEGIN a := ‘z’; b := -345; c := 0.35E-3; d := 345; e := FALSE;

END demo.

:=

11/04/2023 15

Variables vs. Literals

• Variable can have several values (not at one time)

• Literals are the values themselves:– -3– 123– ‘z’– 4.342– TRUE

11/04/2023 16

Working with numbers

• INTEGER, CARDINAL and REAL• Operators:

– Sum using +– Substract using –– Multiply using *

• Divide using– DIV for CARDINAL and INTEGER– / for REAL

• Modulo using MOD

11/04/2023 17

Working with numbers

MODULE demo;VAR

a, b : INTEGER; d : REAL; f : CARDINAL;

BEGIN a := -3; b := a * 2; d := 5.0 / 3.0; f := 5 DIV 3;

END demo.

11/04/2023 18

Conversions

• Numbers can not be mixed!

• CARDINAL REAL INTEGER

• Conversion is needed– TRUNC(real) => CARDINAL– FLOAT(cardinal/integer) => REAL

11/04/2023 19

BOOLEAN algebra

• Built-in type: BOOLEAN

• 2 values: TRUE, FALSE

• OPERATORS:– Logical : AND, OR, NOT– Comparison : <, >, =, <=, >=, <>, #

11/04/2023 20

BOOLEAN algebra

MODULE demo;VAR

a, b : INTEGER; c, d : BOOLEAN;

BEGIN a := -3; b := 33; c := a > b; d := NOT c;

END demo.

11/04/2023 21

Characters

• Built-in type: CHAR

• Values: all the entries of the ASCII table

• Character literals have to be surrounded by single quotes :– ‘z’

11/04/2023 22

Constant

• Keyword CONST

• Usage identical to variable• Assignment is impossible

MODULE demo;CONST

pi = 3.14159; code = 9342;

=

11/04/2023 23

Constant Example

MODULE demo;CONST

Pi = 3.14159;VAR

x, r : REAL;BEGIN

r := 5.0;x := 2.0 * Pi * r;

END demo.

11/04/2023 24

Writing on screen

• Writing on the computer screen can be done using the following procedures– String : WrStr(x);– INTEGER: WrInt(x, 0);– REAL: WrReal(x, 7, 0);– CARDINAL: WrCard(x, 0);– BOOLEAN: WrBool(x);– CHAR: WrChar(x);

• MODULE IntVar; • FROM InOut IMPORT WriteLn, WriteString, WriteInt; • VAR Count : INTEGER; x,y : INTEGER; BEGIN x := 12; y := 13; Count := x + y; WriteString("The sum of them ="); WriteInt(Count,6); WriteLn; END IntVar.

2511/04/2023

11/04/2023 26

Control instruction

• Normal program execution– Top down– Line by line

• Statements that influence the execution of the program

• 3 groups:– Branches– Loops– Procedures

11/04/2023 27

IF

• Choose an alternative based on result of the boolean expression

IF boolean_express1 THENstatements…

ELIF boolean_express2 THENstatements…

ELSEstatements…

END;

11/04/2023 28

IF

MODULE demo;FROM InOut IMPORT WrStr;VAR

x : CARDINAL;BEGIN

x := 3;IF (x < 5) THEN

WrStr(" x is smaller than 5");END;

END demo.

11/04/2023 29

IFMODULE demo;FROM IO IMPORT WrStr;VAR

x : CARDINAL;BEGIN

x := 3;IF (x < 5) THEN

WrStr(" x is smaller than 5");ELSE

WrStr(" x is >= 5");END;

END demo.

11/04/2023 30

IFMODULE demo;FROM IO IMPORT WrStr;VAR

x : CARDINAL;BEGIN

x := 3;IF (x < 5) THEN

WrStr(" x is smaller than 5");ELIF (x > 5) THEN

WrStr(" x is bigger than 5");ELSE

WrStr("x equals 5");END;

END demo.

11/04/2023 31

CASE

• Choose one alternative using a label, no test!!

CASE expression OFlabel1, label2 : statements… |label3 : staments… |

ELSEstatements…

END;

11/04/2023 32

CASEMODULE demo;VAR

menu : (junior, normal, maxi);price : REAL;

BEGINmenu := junior;CASE menu OF

junior : price := 1.25; |normal : price := 2.25; |maxi : price := 3.00; |

ELSEprice := -99.999;

END;END demo.

11/04/2023 33

FOR

• Loop a fixed number of times using a counter variable

FOR counter := start TO stop BY step DOstatements…

END;

• BY step is optional

11/04/2023 34

FOR• The counter will be

changed automatically by the FOR loop

• If BY step is omitted a default step of 1 is used

• start < stop if step is > 0

FOR counter := 10 TO 1 BY –1 DO

11/04/2023 35

FORMODULE demo;VAR

i : CARDINAL;sum : CARDINAL;

BEGINsum := 0;FOR i := 1 TO 20 DO

sum := sum + i;END;

END demo.

11/04/2023 36

WHILE

• Loop as long as the condition return TRUE

WHILE boolean_express DOstatements…

END;

11/04/2023 37

WHILEMODULE demo;VAR

i : CARDINAL;sum : CARDINAL;

BEGINsum := 0;i := 1;WHILE (i <= 20) DO

sum := sum + i;INC(i);

END;END demo.

11/04/2023 38

REPEAT

• Loop until condition becomes TRUE

REPEATstatements…

UNTIL boolean_express;

• Always at least 1 loop!!

11/04/2023 39

REPEAT

MODULE demo;VAR

i : CARDINAL;sum : CARDINAL;

BEGINsum := 0;i := 1;REPEAT

INC(sum, i);INC(i);

UNTIL (i > 20);END demo.

11/04/2023 40

LOOP

• The most basic loop– No counter– No stop condition

LOOPstatements…

END;

• Use EXIT to escape the loop

11/04/2023 41

Array

• DeclarationVAR name : ARRAY index_type OF type;

• Array contains one or more values depending on the index_type

VAR x : ARRAY [1..10] OF REAL;

11/04/2023 42

Array

VAR price : ARRAY (junior, normal, maxi)

OF REAL;

BEGIN price[normal] := 2.25; price[maxi] := 3.00;

11/04/2023 43

Strings

• Character can be represented using the built-in CHAR type– One character at a time

• There is no seperate type in Modula 2 for strings of characters!

VAR text : ARRAY [1..30] OF CHAR;

11/04/2023 44

N-dimensional array

• Modula 2 arrays can have more than one index => more than one dimension

VAR x : ARRAY [1..5] OF ARRAY [1..3] OF REAL;BEGIN x[5][2] := 5.0;

11/04/2023 45

N-dimensional array

• Declaration short hand for n-dim arrays:– x : ARRAY type1 OF ARRAY type2 OF ARRAY

type3 OF type– x : ARRAY type1,type2,type3 OF type

• Indexing short hand for n-dim arrays:– x[3][3][4]– x[3,3,4]

11/04/2023 46

PROCEDURE

• Frequently used statement can be seperated and put into a procedure => code reuse

• In Modula 2 a procedure a is little program on its own

• Difference with program:– Has a name– Possibly some input values– Possibly some output values

11/04/2023 47

PROCEDURE

• 2 aspect:

– Definition: which computation are being performed, which inputs and outputs

– Procedure call: correct use of the procedure in the program

11/04/2023 48

PROCEDURE

• Definition– Name– Number of parameters– Type of each parameter

– Does the procedure return a value:• Type of the value return value

11/04/2023 49

PROCEDURE

• 2 types of procedures– Procedures that compute a value

and return it• Function procedure

– Procedures that have a side effect (write to disk, reset a value, …)

11/04/2023 50

PROCEDURE

PROCEDURE name (arg1 : TYPE1; arg2 : TYPE2; …);(* Declarations just like for a MODULE *)CONST ….TYPE ….VAR ….BEGIN

(* The code comes here *)….

END name;

11/04/2023 51

PROCEDURE

PROCEDURE name (arg1 : TYPE1; arg2 : TYPE2; …) : TYPE6;

(* Declarations just like for a MODULE *)CONST ….TYPE ….VAR ….BEGIN

(* The code comes here *)….

END name;

11/04/2023 52

PROCEDURE

• Keyword RETURN

• Used to:– Jump out of the procedure

– Return a value and jump out of the procedure

11/04/2023 53

PROCEDURE

MODULE demo;PROCEDURE add ( a , b :CARDINAL) :

CARDINAL;BEGIN RETURN a+b;END add;VARt sum : CARDINAL;`BEGIN sum := add( 4, 2);END demo.

11/04/2023 54

PROCEDURE

MODULE demo;FROM IO IMPORT WrStr;PROCEDURE odd( x : REAL);BEGINIF (x < 4.5) THEN RETURN;END;WrStr("x is not < 4.5");END odd;

BEGIN odd(3.); odd(5.5);END demo.

11/04/2023 55

SCOPING

• Procedure are little programs on their own:– Own declarations : types, constants,

variables and even other procedures

• Which variables, constants and procedure can one use inside procedure?

Scoping rules

11/04/2023 56

SCOPING

• Global vs. Local delcarations– Global ~ defined in the main part of

the module– Local ~ defined in procedures

• Top down• Modules• Hiding phenomenon

11/04/2023 57

SCOPINGMODULE demo;VAR v : CHAR;CONST c = 0;PROCEDURE p;VAR z : CHAR;…(* v, c, z, p *)END p;PROCEDURE q;CONST v = 6;…(* v, c, p, q *)END q;BEGIN

END demo.

11/04/2023 58

Structured types

• Store more than one value per variable

– RECORD: possible to combine different types in one variable

– ARRAY: represent several values of the same type in one variable

11/04/2023 59

Record

• DelcarationVAR name: RECORD field1 : type1;

. .

fieldN : typeN; END;

11/04/2023 60

Record

• DeclarationVAR

date :RECORD

day : [1..31];month : [1..12];year : [1900..3000];

END;

11/04/2023 61

Record

• Since a record contains several values we use the field name to access the value:– record.field_name

date.day := 8;date.month := 10;date.year := 2002;

.

11/04/2023 62

Record

VAR point1, point2 : RECORD x, y : REAL; END;BEGIN point1.x := 5.4; point1.y := 2.3; point2 := point1;

11/04/2023 63

RECURSION• f(x) = g(f(x))• Example: factorial

fac(n) := n * fac(n-1); (n>1)fac(n) := 1; (n <=1)

PROCEDURE fac(n : CARDINAL): CARDINAL;BEGIN IF (n <= 1) THEN RETURN n * fac(n-1); ELSE RETURN 1; END;END fac;

MODULE IfDemo; FROM InOut IMPORT WriteString, WriteInt, WriteLn; VAR Index1 : INTEGER; BEGIN FOR Index1 := 1 TO 8 DO IF Index1 < 4 THEN (* Simple IF statement *) WriteString("Index1 is less than 4."); WriteInt(Index1,4); WriteLn; END; (* end of first IF statement *) IF Index1 = 5 THEN (* two way IF statement *) WriteString("Index1 is 5"); ELSE WriteString("Index1 is not 5"); END; (* end of second IF statement *) WriteLn; IF Index1 = 2 THEN (* multiple way IF statement

*) WriteString("Index1 is 2"); ELSIF Index1 = 6 THEN WriteString("Index1 is 6"); ELSE WriteString("I really don't care what Index1 is"); END; WriteLn; END; (* of big FOR loop *) END IfDemo. 6411/04/2023

MODULE Proced1; FROM InOut IMPORT WriteString, WriteLn; VAR Count : INTEGER; PROCEDURE WriteHeader; BEGIN WriteString("This is the header"); WriteLn; END WriteHeader; PROCEDURE WriteMessage; BEGIN WriteString("This is the message"); WriteLn; END WriteMessage; BEGIN (* Main program *) WriteHeader; FOR Count := 1 TO 8 DO WriteMessage; END;END Proced1.

6511/04/2023

Procedure with return typeMODULE Function;

FROM InOut IMPORT WriteString, WriteInt, WriteLn; PROCEDURE QuadOfSum(Number1, Number2 : INTEGER) : INTEGER;

BEGIN RETURN(4*(Number1 + Number2)); END QuadOfSum; VAR Dogs, Cats, Feet : INTEGER; BEGIN (* Main program *) Dogs := 4; Cats := 3; Feet := QuadOfSum(Dogs,Cats); WriteString("There are a total of"); WriteInt(Feet,3); WriteString(" paws."); WriteLn; END Function. 6611/04/2023