About MPW Oberon

• the MPW Oberon compiler
• files of interface declarations that provide access to Oberon, SANE and Macintosh routines
• the Oberon libraries
• several Sample programs, with instructions for building them
• a help file

MPW Oberon includes the following new features expanding the power and flexibility of Oberon programming:

• support for SADE, the symbolic debugger
• support for Macsbug
• support for more than 32K global data
• support for inline and external procedures

1. About the Oberon interface files
2. Using interface files
3. About the Oberon libraries
4. About the Oberon examples
5. Installing MPW Oberon
6. Creating an application in MPW Oberon
   • Building an application
   • Compiling an application
   • Linking an application
7. Creating a tool in MPW Oberon
   • Compiling a tool
   • Linking a tool
8. Creating a desk accessory in MPW Oberon
9. Creating code for different models of the Macintosh
   • Interface files
   • Compiler options

Note: The interface files supplied with MPW Oberon are not the universal interface files needed to develop code for the PowerPC. The universal interface files will be made available with a subsequent release of MPW Oberon.

Using interface files

The compiler searches several directories for interface files, until the specified file is found. It searches the directory containing the source file, directories specified using the -i option to the compiler, and directories specified in the Shell variable {OInterfaces}.

You specify the modules needed for your module by the IMPORT statement:

IMPORT module, module, …;

Note: Variant records are not supported by Oberon, so the variant record types defined in Inside Macintosh were adapted for MPW Oberon. Each variant is defines in a separate record. Type extension is used to declare the common fields. The data types GrafPort, WindowRecord, and DialogsRecord are also defined using type inheritance where DialogRecord is an extension of WindowRecord which is an extension of GrafPort.

Warning: The replacement of variant records with records defined using type extension creates no problems in many cases. An incompatibility arises when array of variant records are considered. Pascal allocates enough memory for each element to accommodate the largest variant. The same declaration is accepted by Oberon but the compiler does not reserve enough space for each element. Fortunately this construct is not used very often-once-with the interface files supplied with MPW Oberon.

Warning: You may cause system crashes when you are not using the proper variant (extended type) of a parameter block. Most of the routines accept a parameter of type ParmBlkPtr. The following fragment shows an example where a block with the wrong size is passed to PBOpen.

VAR
  block: OSUtils.ParamBlockRec;
…
  error:=PBOpen(SYSTEM.ADR(block), TRUE);

Every MPW Oberon program must be linked with the libraries Runtime.o, Interface.o and OberonLib.o. Others are required for different operations. For further information about using the libraries, see the documentation of MPW.

Note: The libraries included with MPW Oberon are not yet final. Some library modules for accessing files within the MPW Shell were implemented using routines from the Pascal library. This will be fixed in a subsequent version of MPW Oberon.

About the Oberon examples

In addition to the samples describes above showing standard Macintosh programming, eleven sample programs are included with MPW Oberon written in Oberon, Pascal, and C. These programs are contained in the folder JMLCSamples and were used to compare the code generation of MPW Oberon with MPW Pascal and MPW C. The results of this comparison were presented at the Joint Modular Languages Conference 1994 in Ulm. The following table lists the targets of the Makefile which may be used for producing reports.

Note: The first generation of a report may take a while since all programs must be build.

Most of the examples in the test suite above were adapted from textbooks. For "standardized" testing the folder Hennessy contains the standard Hennessy benchmark suite. This suite is provided in Oberon, Pascal and C. You will notice that MPW Oberon performs equally well in both test suites.

Installing MPW Oberon

1. Copy Oberon (the compiler) to the {MPW}Tools folder.
2. Copy UserStartup•Oberon to the {MPW} folder.
3. Copy the folder OExamples to the {MPW}Examples folder.
4. Copy the folder OInterfaces to the {MPW}Interfaces folder.
5. Copy the folder OLibraries to the {MPW}Libraries folder.
6. Append the file Oberon.Help to the {MPW}MPW.Help file.

This section outlines the steps for building an application in MPW Oberon. The Instructions files in the OExamples folder describe some of the tools that can be used to automate to processes. The Makefile file in the OExamples folder illustrates the use of some of the tools. See the MPW documentation for further details about these tools.

Building an application

You will see something like this on the screen:

# 10:22:49 Uhr ----- Build of Sample.
# 10:22:49 Uhr ----- Analyzing dependencies.
# 10:22:51 Uhr ----- Executing build commands.
    Oberon Sample.mod -o Sample.mod.o
    Link -o Sample Sample.mod.o ∂
        "Yogi:Libraries:Libraries:"Runtime.o∂
        "Yogi:Libraries:Libraries:"Interface.o ∂
        "Yogi:Libraries:OLibraries:"OberonLib.o
    SetFile Sample -t APPL -c 'MOOS' -a B
    Rez -rd -o Sample Sample.r -append
# 10:23:03 Uhr ----- Done.
    Sample 

Oberon -p Sample.mod

{Libraries}Interfaces.o
{Libraries}Runtime.o
{OLibraries}OberonLib.o

Tools are executed by entering an MPW command. The parameter specified in the command line are passed as parameters to the main program. The exported Shell variables can be accessed using the procedure IntEnv.getenv from the Oberon library. To access these parameters use the IntEnv module.

Tools have direct access to MPW Shell windows and selections. The variables stdin, stdout and stderr refer to MPW' standard input, standard output, and diagnostic output. Any files opened by tools read and write to windows, if the file specified is open in a window. The contents of the window are read or written in place of the file's data fork. Selection in windows can also be read and written as if they were files by the adding the suffix .§ to the filename.

Compiling a tool

Link -t MPST -c "MPS " …

{Libraries}Stubs.o
{Libraries}ToolLibs.o

ΔΔElaborateΔΔ

Creating code for different models of the Macintosh

Note: Programs written in MPW Oberon will execute on the PowerPC. The PowerPC models will emulate an MC68LC040 processor. Floating-point operations must be performed using the SANE because FPU instructions are not emulated. Do not use the -mc68881 option when writing programs using floating-point that should execute in the PowerPC environment.

Interface files

Many routines described in Inside Macintosh are not available on certain models of the Macintosh, because they make use of hardware options that are not available on other models. You can import all of the interface-file definitions in code for use on any model, but you cannot call ROM routines that are not present on the machine that will the compiled code.

Compiler options

Use the -mc68881 option for programs which do a lot of computation involving floating-point numbers. If this option is given to the compiler, it will not generate call to the SANE package but generate opcodes of the MC68881. A large number of transcendental functions is provided by the FPU which can be used with MPW Oberon. See "Arithmetic procedures and functions" for a list of arithmetic functions provided by MPW Oberon.

Note: Some transcendental functions implemented in the SANE package are slightly more accurate that their counterparts provided by the FPU. MPW Oberon is designed for maximum speed, so it will generate direct call for the FPU.

Warning: The type LONGREAL occupies 10 bytes if code for SANE is generated and 12 bytes if code for the MC68881 is generated. Keep this in mind if you want to read files containing binary floating-point numbers.