The Paradigm/SP Implementation Notes

Atanas Radenski
Computer Science Department, P.O. Box 19479
Winston-Salem State University, Winston-Salem, NC 27103
e-mail: radenski@computer.org

 
 
 
 
 
 

These notes describe the Paradigm/SP compiler and interpreter and define the terms and conditions for their use. The notes also explain what work performed by others has been used in the Paradigm/SP implementation.

< ^>    Contents

  • 1. Definitions
    • bullet 1.1 Implementation
    bullet 1.2 Manuals
    bullet 1.3 Programs
  • 2. Credit to Others
  • 3. Terms and Conditions
  • 4. Software Limits
  • 5. Program Installation
  • 6. References
  • 7. Related Links

    • < ^>    1. Definitions

    <^>1.1 Implementation

    The Paradigm/SP prototype implementation (hereafter Implementation) consists of experimental research software and documentation created by Atanas Radenski (hereafter AR). The Implementation consists of  Manuals and Programs for the programming language Paradigm/SP designed by AR. The whole Implementation is available on the web at
    http://www.rtpnet.org/~radenski/research/compilers/index.html

    <^>1.2 Manuals

    The following Manuals are available:
    bullet  Implementation Notes (this document)
    bullet  Language Reference Manual
    bullet  User Manual

    < ^>1.3 Programs

    The Programs, written by AR, are a Paradigm/SP compiler and interpreter (hereafter Compiler and Interpreter). All Programs have to be installed in the same Implementation Directory. The Programs are written in TurboPascal, Borland version 7.0 (hereafter TP). The Programs can be used from with the TurboPascal Integrated Development Environment (hereafter TP IDE).

    The Programs are stored as a zipped Archive. The Archive includes seven TP source files (hereafter Program Files):
    bullet pCommon.pas:   The common declarations used by the Compiler and Interpreter (encapsulated in a TP unit).
    bullet pTexim.pas:        Declarations of common tables and common export-import procedures used by the Compiler and Interpreter encapsulated in a TP unit.
    bullet pScan.pas:          The Compiler procedure that performs lexical analysis (encapsulated in a TP unit).
    bullet pParse.pas:         The Compiler procedure that performs syntax, scope, and type analysis (encapsulated in a TP unit).
    bullet pAssem.pas:        The Compiler procedure that assembles interpreted code (encapsulated in a TP unit).
    bullet pComp.pas:         The Compiler main program.
    bullet pInter.pas:           The Interpreter main program.

    <^>2. Credit to Others

    The Paradigm/SP language (designed by AR) is a modular object-oriented extension of  the SuperPascal language [Brinch Hansen 1994]. The principle new features of Paradigm/SP are extensible modules, classes and class overriding.  The parallel features of SuperPascal have been inherited by Paradigm/SP and enhanced with modularity and object-orientation.  The Paradigm/SP Manuals:
    bullet extend and modify the SuperPascal  manuals to reflect the language extensions and modification adopted in Paradigm/SP;
    bullet repeat literally parts of the SuperPascal manuals on language features that have been inherited from SuperPascal without changes.
    The Programs are based (1) on the SuperPascal compiler and interpreter described and listed in [Brinch Hansen 1993], (2) on the Oberon compiler described and listed in [Wirth and Gutknecht, 1992] and (3) on original components developed by AR.

    <^>3. Terms and Conditions

    This Implementation is in the public domain. The Implementation is not guaranteed for any particular purpose. The Implementation is supplied "as is" without any warranties. The Implementation developers do not accept any liabilities with respect to the Implementation. The user is responsible for selecting the Implementation, and for the use and results obtained from the Implementation. Your use of the Implementation indicates your acceptance of these terms and conditions.

    <^>4. Software Limits

    The Program File pCommon.pas (hereafter Common Declarations) defines common constants, types, functions, and procedures used by the Programs. The limits of software arrays are defined by common constants (hereafter Software Limits). If the Software Limits are too small for compilation or execution of a user program, these limits should be increased by editing the Common Declarations and recompiling the Programs.

    <^>    5. Program Installation

    Create an empty Implementation Directory. Download the zipped Archive in the Implementation Directory and unzip it. You may use the WinZip program that is available at http://www.winzip.com/winzip.

    You can build the Compiler and the Interpreter in the TP IDE.  Before compilation, you must select the 8087 Numeric Processing Mode. To do so, select Compiler Options from the Options menu and mark the 8087 mode.

    In order to build the Compiler perform the following steps:
    bullet From the Compile menu, execute the Primary File command and select pComp.pas as a primary file;
    bullet From the Compile menu, select Disk as Destination;
    bullet From the Compile menu, execute the Build command.
    You can build the Interpreter in a similar way by selecting pInter.pas as a primary file.

    <^>    6. References

    Brinch Hansen, P. (1993), anonymous ftp://top.cis.syr.edu/pbh/, Syracuse University, Syracuse, NY.

    Brinch Hansen, P. (1994) The Programming Language SuperPascal. Software-Practice and Experience, 24 (5), May 1994, 467-483.

    Wirth, N., and J. Gutknecht (1992) Project Oberon. ACM Press, New York, NY.

    < ^ >    7. Related Links

    *Index of Manuals
    *The Paradigm Language and Its Implementation
    *Research
    *Contact

     

     

    -------------
    Last updated: October 1999.