Laboration 0: Modula-2, Kompilering och Länkning

Inledning

Denna laboration är avsedd att introducera programspråket Modula-2 och den programmeringsmiljö som finns för Modula på MC:s arbetsstationer. Ni skall få se hur kompilatorn och länkaren fungerar samt skriva ett mycket enkelt Modula-2 program.

De saker som är helt nya från ML-delen är naturligtvis språket Modula samt användandet av en kompilator. Redigering av program emacs och Unix i allmänhet förutsätter jag vara skåpmat.

Information om Modula-2 kompilatorn och länkaren finns i DATORHANDBOK FÖR DATORANVÄNDARE VID MATEMATISKT CENTRUM samt i manualbladen.

Kompilering av programmoduler

Om hela programmet finns i en programmodul är det väldigt enkelt att producera en exekverbar fil med hjälp av kompilatorn. I kursbiblioteket /users/mdstud/naptv finns en fil sum.mod med en programmodul Sum som räknar ut summan av serien 0+1+2+...+n. Programmet är lite slarvigt skrivit så det innehåller några fel som du måste rätta innan kompilatorn producerar en exekverbar fil.

Kopiera filen till ditt bibliotek.
Kompilera programmet.
Rätta felen.
Kompilera om programmet.
Exekvera objektfilen för några olika indata.

Fördefinierade moduler

Olika implementeringar av Modula innehåller olika fördefinierade moduler som man kan importera och använda. För att se vilka funktioner, procedurer och variabler som dessa fördefinierade moduler innehåller kan man titta i motsvarande definitionsmoduler. De fördefinierade definitionsmodulerna för den implementering som vi använder finns i biblioteket /usr/lang/SC1.0/modula2/src/ (Anm: om inte detta fungerar, prova /usr/lang.old/...). Titta vilka fördefinierade moduler som finns och vilka funktioner och procedurer dessa innehåller. Se bland annat efter vilka funktioner och procedurer som definieras i modulerna InOut, String och MathLib.

Separatkompilering av moduler

Om ett program finns utspritt i flera moduler är det lite mer arbete att tillverka en exekverbar fil. Alla delarna måste nu översättas till objektkod innan man kan länka ihop dem till en exekverbar fil. Om man upptäcker fel i någon del så är det naturligvis inte nödvändigt att kompilera om mer än den delen.

I kursbiblioteket finns ett speciellt bibliotek ModulaLib med Modula-moduler. Bland annat finns två filer som implementerar en modul Func som innehåller två funktioner som beräknar fakultet och fibonacci funktionerna. Namnet på funktionerna samt typerna på argument och result ser man i definitionsmodulen, denna finns i filen Func.def (namn på filer med definitionsmoduler skall alltid sluta på .def.) När man kompilerar en definitionsmodul så hamnar resultatet i file.sym. Implementeringen av Func-modulen finns i filen Func.mod som ni inte kan läsa(!) men ni kan läsa filen Func.o som innehåller objektkoden för modulen. Skriv en programmodul som använder funktionen i Func-modulen och skriver ut en tabell med funktionernas värde för argumenten 1 till 10!

Separatkompilera er programmodul så att ni får en .o-fil och när programmet blivit felfritt länkar ni ihop de separat översatta delarna med objektkod för programmet och Func-modulen till en exekverbar fil.

Om man importerar en modul i ett program letar kompilatorn normalt i samma bibliotek samt i ett standardbibliotek efter en fil som heter samma som modulen. Det är därför lämpligt att alltid spara en modul som heter namn i en fil namn.mod och lägga alla modulerna i samma bibliotek. Två flaggor till kompilatorn modifierar var kompilatorn letar efter importerade moduler:

-Mdir: Specificerar att kompilatorn även skall leta i biblioteket dir. OBS! inget mellanslag mellan M och biblioteksnamnet.
-m module:file: Specificerar att modulen module finns i filen file (dvs. i file.def, file.mod, file.sym och file.o).

Ett litet Modula-program

Skriv ett litet Modula-program för att lösa någon eller några av följande problem:

Skriv ett program som läser tre heltal och avgör om ett av talen är summan av de andra. Programmet skall ge utskriften ingen summa! om inget av talen är summan av de andra och 23 + 45 = 68 om 23, 45 och 68 är de tre heltalen.
Skriv ett program som läser ett heltal och avgör om detta är ett primtal.
Skriv ett program som skriver ut alla tal mindre än 200 som är primtal.
Skriv ett program som ritar en brownsk rörelse. Man får en sådan genom upprepade gånger gå rakt fram en slumpmässig sträcka och svänga en slumpmässig vinkel. Tips: för att rita linjer kan man använda modulen TurtleGraphics som beskrivs i Appendix F i läroboken. För att få slumpmässiga tal kan man använda modulen RandomModule. Båda modulerna finns i biblioteket /users/mdstud/naptv/ModulaLib.
Märk: när man länkar program som använder modulen TurtleGraphics måste man lägga till -lX11 sist på kommandoraden.
Skriv ett program som spelar spelet Hi-Lo. I detta spel spelar en användare mot datorn. Datorn väljer slumpvis (Tips: Titta efter en biblioteksmodul RandomModule i biblioteket /users/mdstud/naptv/ModulaLib). ett tal mellan 1 och 100, och användaren skall på så få gissningar som möjligt ta reda på talet. Efter varje gissning meddelar datorn om man gissade rätt, för lågt eller för högt.
En körning av programmet kan se ut på följande sätt:
```
   Välkommen till spelet HI-LO.
   Jag tänker på ett tal mellan 1 och 100. Vilket? 50
   50 är för stort, försök igen! 25
   25 är för litet, försök igen! 37
   37 är korrekt!! Du behövde 3 gissningar.
	
```
Med en optimal strategi behöver man inte så många gissningar för att komma fram till rätt svar. Hur många? Varför?