Es zol niegt iemer tsee zain.

Bij 'Unix' en 'programmeren' denken de meeste mensen al snel aan C en zijn derivaten en aan de scripttaaltjes die langzaam ge-evolueerd zijn. Maar er is meer. Er is een compacte maar hechte club van assembly language programmeurs en ook de klassieke talen Cobol en Fortran worden wel eens gebruikt.
De meeste van deze talen werken met een eigen compiler. Er zijn ook vertaal compilers beschikbaar, zoals P2C, die Pascal source vertaalt naar C broncode en die dan later met gcc compileert. Een omweg, maar wel een omweg die werkt.

Mijn favoriete taal is Modula-2, de 'opvolger' van Pascal. Kijk maar eens op www.modula2.org voor meer informatie.
Modula-2 is een 'strongly typed language'. In de praktijk betekent dat, dat je jezelf moet richten naar de nukken van de compiler maar je krijgt daar een veelvoud aan beveiligingen voor terug. Oorspronkelijk is Modula-2 geschreven om er operating systems mee te schrijven. Het eerste OS dat ermee gemaakt is, was Lilith, een eigen computer systeem van Niklaus Wirth, dat eind 70'er jaren al veel eigenschappen van de huidige Windows en KDE machines had: muis, toetsenbord en grafisch display. Modula-2 kent daarom zowel low level functies als high level toepassingen. Daar gaan we in de loop van deze cursus achterkomen.

Er bestaan meerdere Modula-2 compilers voor Unix. Kijk maar eens op www.modula2.org. Ik werk met de Mocka compiler: MOdula-2 Compiler KArlsruhe. Het is een snelle en betrouwbare compiler die is uitgerust met een eigen IDE (Integrated Development Environment), zij het een simpele. Verder is de compiler FREE (in de betekenis van de GPL) hetgeen niet van de meeste andere gezegd kan worden. XDS is uitgebreider, maar is een commerciele compiler die voor 'single users' gratis is.
Download de Mocka compiler maar eens van www.info.uni-karlsruhe.de/~modula/ en installeer het op je systeem. Als er storingen zijn, ga dan naar fruttenboel toe en lees hoe ik dat heb aangepast.
De Mocka compiler komt met volledige documentatie wat betreft de werking van de compiler. Als je een cursus Modula-2 wilt downloaden moet je even op fruttenboel zoeken naar de Coronado cursus.

Na de installatie.

Op mijn systeem werk ik standaard met de editor 'jed' en mijn Mocka script file heet daar 'MC'. Ik start de compiler met 'MC' waarna ik de '>>' prompt krijg.
De twee belangrijkste opdrachten die we nu gaan gebruiken zijn 'i' en 'p'. Met het i commando kunnen we een programma module gaan editten en met het p commando gaan we dat daarna compileren. Er zijn nog een stel andere opdrachten, maar die zijn nu nog niet relevant.

Over de taal.

Modula-2 is een super gestructureerde taal. De compiler helpt je tijdens het compileren, maar ook in runtime, om je te beschermen tegen de boze buitenwereld. Het prijskaartje dat daaraan vastzit heet 'structuur'. Je moet modulair en gestructureerd werken. Dat is het concept van deze (en eigenlijk ook iedere andere) taal.
Kun je in andere talen bijvoorbeeld integers met floating point getallen in dezelfde formule bewerken, in Modula-2 gaat dat niet direct. Dat is niet gedaan om jouw kunde in te perken, maar om te voorkomen dat je per ongeluk het resultaat in de verkeerde datasoort achterlaat.
Verder doet de compiler aan runtime checks doordat de bounds van array's worden gecontroleerd, de stack wordt in de gaten gehouden, er wordt gelet op overflow, en nog een paar meer.
Kortom, veel van de fouten die storingen in C programma's veroorzaken komen niet voor bij in Modula-2 gecompileerde software. Geen buffer overruns en geen stack corrupties.

Verder nog een noot voor de chaoten onder ons: Modula-2 kent geen 'GOTO' statement. Daar tegenover staat een hele zwik van lus-mechanismen die een GOTO per defintie overbodig maken.

De taal kent slechts weinig 'reserved words':

  40 reserved words
  12 standaard functies
   7 standaard procedures
   9 standaard TYPEs (beetje afhankelijk van de compiler)
   
Voor een redelijk compleet overzicht, kijk even op deze site naar de 'Reference file', inclusief beschrijvingen en voorbeelden.
Dit lage aantal 'eigen' woorden betekent dat je minder hoeft te leren om de taal te leren.

Modula-2 is 'case sensitive'. Dus er is een groot verschil tussen de woorden 'BEGIN' en 'Begin'. Het eerste is een reserved word en de tweede kan vanalles zijn.

Een voorbeeldprogramma.

Genoeg gezeurd, tijd voor wat code. Allereerst gaan we een leeg programma maken. Lege programma's bevatten namelijk minder fouten. Het leegste programma is:

   MODULE leeg;

   BEGIN
   END leeg.
   
Leger dan dit gaat moeilijk. Maar het geeft wel de opbouw van een Modula-2 programma aan. Ieder Modula-2 programma begint met zijn eigen naam, voorafgegaan door het woord 'MODULE'. Om de regel af te sluiten gebruik je een punt-komma. Niet alle regels hoeven door een puntkomma te worden afgesloten maar daar komen we later nog op terug.

De hoofd-routine van een programma vangt aan bij het woord BEGIN. Na een 'BEGIN' hoeft geen puntkomma. Het eind van de hoofdroutine wordt aangegeven met het 'END' woord. Omdat deze 'END' ook het eind van het programma aangeeft, wordt er een PUNT achter gezet. Net als met deze zin.

Start je compiler en voer deze source in:

 jan@p75:~/modula$ mocka
 Mocka 0608
 >> i leeg
 >> p leeg
 >> strip leeg
 >> ls -l leeg*
 -rwxr-xr-x    1 jan      users        3584 May  6 11:51 leeg
 -rw-r--r--    1 jan      users          30 May  6 11:50 leeg.mi
 -rw-r--r--    1 jan      users        1364 May  6 11:50 leeg.o
 -rw-r--r--    1 jan      users           9 May  6 11:50 leeg.r
 >>
   
Met het 'i' commando hebben we de editor gestart om leeg.mi aan te maken. Met het 'p' commando hebben we de compiler aan de gang gezet. De rest zijn bekende Unix commando's.

Een tweede programma: hallo.

We gaan een tweede source compileren. Start de compiler en geef het commando

  >>i hallo
   
en voer de volgende source in:
   MODULE hallo;
   
   BEGIN
      WriteString ('Hallo Linux magazine lezers.');
      WriteLn;
      Write (LF)
   END hallo.
   
Hierna compileren met
  >>p hallo
   
WAT NU? Fouten? in MIJN sources? Dat zijn we niet gewend. :o)
Op dit moment komt een van de leuke dingen van Mocka in beeld: de editor wordt gestart en de fouten zijn op de juiste plaatsen ingevoegd in de source code. We lopen nu even de file door:
   @ LISTING
   MODULE hallo;

   BEGIN
      WriteString ('Hallo Linux magazine lezers.');
   @  ^
   @ Col 4: 'WriteString' not declared
      WriteLn;
   @  ^
   @ Col 4: 'WriteLn' not declared
      Write (LF)
   @  ^
   @ Col 4: 'Write' not declared
   END hallo.
   
De compiler kent de aangegeven woorden niet. Vreemd. Ze klinken zo logisch. Voor de compiler echter is het abracadabra. Die wil weten waar ie kan opzoeken of en hoe deze functies werken. Daarom voegen we een regel in de source in:
   @ LISTING
   MODULE hallo;
      
   -> FROM   InOut   IMPORT  WriteString, WriteLn, Write;

   BEGIN
      WriteString ('Hallo Linux magazine lezers.');
   @  ^
   @ Col 4: 'WriteString' not declared
      WriteLn;
   @  ^
   @ Col 4: 'WriteLn' not declared
      Write (LF)
   @  ^
   @ Col 4: 'Write' not declared
   END hallo.
   
Verder doen we niks. We halen geen foutmeldingen weg of zo, dat gaat straks allemaal vanzelf. We saven de file en hercompileren. Dat gaat makkelijk: als het 'p' commando al een keer eerder gegeven is, volstaat het om op <Enter> te drukken. Het resultaat:
   @ LISTING
   MODULE hallo;

   FROM  InOut  IMPORT WriteString, WriteLn, Write;

   BEGIN
      WriteString ('Hallo Linux magazine lezers.');
      WriteLn;
      Write (LF)
   @         ^
   @ Col 11: 'LF' not declared
   END hallo.
   
Da's al een stuk beter. De meeste fouten zijn weg. Alleen hebben we nog een constante niet gedefinieerd. Dit kan op meerdere manieren. De makkelijkste:
   CONST  LF    = 12C;
   
Hiermee definieren we een constante met de naam 'LF' en de waarde 12 octaal ofwel 10 decimaal. De 'C' achter de '12' geeft aan dat dit getal straks een 'character constant' wordt en dat de waarde hier octaal wordt opgegeven.

Een andere manier is om een constante te ontlenen aan een bestaande bibliotheek:

   FROM   ASCII   IMPORT   LF;
   
Zet een van deze constructies tussen de eerste 'FROM' regel en de 'BEGIN'. Compileer opnieuw en run je programma.
   >> <Enter>
   .. Compiling Program Module hallo I/0001 II/0001
   .. Linking hallo
   >> hallo
   Hallo Linux magazine lezers.
   >>
   
Maar er is nog een betere methode: die gebruik maakt van de complete library. Kijk maar eens naar deze source:
   MODULE hallo;

   FROM  InOut  IMPORT WriteString, WriteLn, Write;

   IMPORT ASCII;

   BEGIN
      WriteString ('Hallo Linux magazine lezers.');
      WriteLn;
      Write (ASCII.LF)
   END hallo.
   
We importeren de hele library ASCII en halen daar later de LF constante uit middels de constructie ASCII.LF
Andere ASCII constantes kunnen zo ook worden opgehaald: ASCII.ESC, ASCII.CR etcetera.

De kleine stukjes code die we tot nu toe gezien hebben, tonen al aan hoe charmant de taal Modula-2 is. Het is leesbaar voor iedereen. Ik noem de taal dan ook vaak 'self documenting'. Ook al staat er geen commentaar in, dan nog is de source goed te lezen en begrijpen. Mits de boel door een fatsoenlijke programmeur geschreven is.

In komende stukjes zal duidelijker worden dat de 'accolade-talen' vaak zeer slecht te volgen zijn. Als je meer wilt weten over programmeren in Modula-2, surf dan eens naar fruttenboel alwaar je een en ander kunt vinden. Grote en kleine sources en een aparte sectie over de Mocka compiler.

Vooruitblik en terugkoppeling.

De volgende keer gaan we zelf functies maken. Daarmee gaan de verschillen met de accolade-talen in een keer een stuk duidelijker.

Page created in 2002,