Stony Brook Modula-2 Orientation

This first tutorial will help you become familiar with the Stony Brook Modula 2 environment. This is a tweaked version of the tutorial starting on page 9 of the Stony Brook Utilities Reference Manual available in the lab.

Note for Mac Users

The Modula-2 environment we have installed on the lab Macs is called MPW; the environment is slightly different, but the Modula-2 code you type will be exactly the same. There is an old tutorial for the MPW Mac Modula-2 environment that may be of use. I don't have the resources to officially endorse the Mac environment; you're on your own, sorry! When backing up your work to an external drive (floppy, CD, USB keychain drive, etc.), beware that the name of the formatted disk must not have any spaces, periods, slashes, apostrophes, colons, or quotes in it. This restriction does not apply to filenames, only the disk name. Store your files in a subdirectory on the disk, rather than in the root directory. Also, if you want to read your disk on a PC, you'll need to make sure it's formatted as a PC disk and not a Mac disk. Macs can read PC disks, but PCs can't read Mac disks. C'est la vie.

Windows

Experiment using the Windows operating system until you can

open your user directory ("My Documents" or Z:),
create a subdirectory in your user directory,
copy and rename directories and files,
backup files from your user directory to a floppy/CD/DVD/USB-drive,
get to the command prompt, and
view the CMPT14x homepage and this page in a WWW browser.

Starting Stony Brook Modula-2

You are now ready to run Stony Brook Modula-2.

Navigate to your user directory and create a new subdirectory for your Modula-2 work. You could call it, for instance, "M2".
This link points to a sample Modula-2 project.
Right-click the above link and select "Save Target As..."
Navigate to your new M2 directory and save the project file there.
From Windows Explorer, find the new M2Project.sbp file and double-click on it. The Stony Brook Modula-2 user interface window should open. How exciting!

There's nothing special about the sample project file; you can also make your own by selecting "File->New Project" from the Stony Brook menubar. You do need to make sure the project is set for a console program: "Options->Linker Options", Win32 tab, check Console Application. See p.11 in the Stony Brook Utilities Manual for more details.

Creating and Editing a New Program

From the menubar, select "File->New Module".
In the popup dialog, type HelloWorld for the program name, and select "Program" as the Module Type. Select the "OK" button.
Select the PGM HelloWorld- line and press Enter to edit this program (or simply double-click on it). The editor shows a skeleton program for our HelloWorld module that you can now edit.

Typing the Program

Using the skeleton program as a starting point, complete the program as follows:
- The red <<eof>> in the edit window just indicates the End Of File; it is not part of the program itself.
- There is an intentional typo in this code; don't fix it yet!
From the menubar, select "File->Save" (or press the toolbar button with a floppy-disk icon) to save your work. This source code will be saved in a file named HelloWorld.mod under the mod subdirectory of your M2 directory.
From the menubar, select "File->Close" to close this edit window and return to the project environment view.

Compiling and Debugging the Program

Select PGM HelloWorld- and press Alt-R to run this program.
- You could also use "Build->Run selected or default" from the menubar
- Or you could press the toolbar button with the green traffic-light icon. So many choices!
The Stony Brook environment attempts to compile the program before it can run it. However, the compile fails because of the typo in our program: we typed WriteStr instead of the correct name for the function, WriteString. The compiler reports this error as an "Undeclared identifier" because it doesn't recognize WriteStr as a function.
Edit the program to correct the typo, and press Alt-R to try running the program again. You can run the program directly from the edit window.

Running the Program

If all goes well, the Build Status window should show no errors in compiling the program. (yay!) Press the OK button to run the program.
The program (since it is a console application) pops up a new black DOS window for input and output. The phrase Hello World! should appear. The program is now on the ReadChar() line, waiting for user input.
Press the Enter key in the DOS window to complete the ReadChar() function and allow the program to complete.
Congratulations, you've written your first "Hello World" Modula-2 program! Celebrate with a happy-dance, or maybe a moment of quiet contemplation.

Files Created

From the menubar, select "File->Exit environment" to quit Stony Brook.
Back in Windows Explorer, take a look at your M2 directory.
- M2Project.sbp is your project file; it's the "glue" that holds all your modules and programs together.
- HelloWorld.exe is the executable HelloWorld program that you compiled. You can also double-click this file to run your program directly.
- win32sym and win32obj hold intermediate results of the compilation for the 32-bit Windows platform.
- mod holds all your source code modules. In this subdirectory you should find
  - HelloWorld.mod: This is a text file that holds the source code that you typed in. This is where much of your hard work goes, so be sure you know how to back it up!
  - HelloWorld.bak: When you re-edit your source code, Stony Brook keeps a backup copy of your old file, just in case. You can go back to this old copy just by deleting the HelloWorld.mod file and renaming HelloWorld.bak to HelloWorld.mod. This doesn't replace doing your own backups, though! What if something happens to your whole user directory?
Make sure you've closed the Stony Brook window before you manipulate the files in Windows Explorer; Stony Brook does some weird file locking that prevents you from doing stuff to your Modula-2 files while it's running.

Take a rest for a day or two, but come back again this week and do the next part to continue your orientation. You need to get going on your first assignment as it will be due next week.

Printing Hard Copies

There are some simple ways that you can use to get a copy of the output from your program onto a piece of paper.

The simplest is to copy the text from the terminal window into a word processor. This is a little awkward, but not impossible. First right-click on the title bar of the terminal window:

Select Properties, click on the "Layout" tab, and change the height to a higher number (like 1000). After clicking OK, make sure to choose the "Modify shortcut which started this window" or "Save properties for future windows with this title" option in the dialogue that appears. This will assure that the next terminal window will have the new properties.
The next time you run a program in a terminal window, select "Edit->Mark" from the MSDOS menu in the top left corner. Now you can select some text, copy it, and paste it into another program.
A second, which you may find useful in conjunction with the first is to redirect the output as the program is running. You do this by including the line
```
FROM RedirStdIO IMPORT
OpenInput, CloseInput, OpenOutput, CloseOutput;
```
in the import section and the line
```
OpenOutput;
```
in your program before the first line of the part that you want to be sending to the file. You also need the line
```
CloseOutput;
```
in your program after the last part of the program where you want output to go to the file.
- When the program runs and encounters the OpenOutput command, a prompt will be printed on the screen. Type a file name, or use the default already in the box Output and that is where all WriteXX statements will send their output until the CloseOutput statement is encountered. If you choose the cancel box without giving a file name, the output will go to the screen as usual.
- Note that if the CloseOutput is not included in your program, this will not work, and you may not even be able to delete the flawed file from your disk until the next time you restart the computer.
- Note also that all output is sent to the file during this time, so no prompts printed by WriteString will appear on the screen. We will improve on this limitation later.
- Note also that this is notstandard Modula-2; it has been provided courtesy of TWU. You can now open the file you have created, and print it just as you did your listings above.

Other methods will be discussed at a later date. These are the simple ones; more powerful and versatile ones take more work.

Windows Stony Brook Menu Reference

There are descriptions of all of the menu options that can be chosen from within Stony Brook starting on page 39 of the Utilities Reference Manual.

Further Practice

You can get some more familiarity with the Stony Brook interface and with the Modula-2 language by copying some material from the textbook and compiling and running it. You're going to be spending a lot of cozy-time with the Stony Brook interface this semester, so get to know it and be friends!