Course
Project Description:
Each
team can choose one of the five projects:
Project
A: Design and implement a short
version of SIC/XE assembler.
Project
B: Design and implement a short
version of linking loader.
Project
C: Design and implement a one-pass
macro processor.
Project
D: Design and implement a short
version of C# or C++ compiler.
Project
E: Design and implement other
system software.
For all the fiver projects, each team is required to turn in a document (in paper format) for the following work. The project work requirements are subject to change.
Please also include additional requirements mentioned in the class.
1. Project introduction and
background.
2. Architecture and design of the software.
3. Algorithms and data
structures
used in the implementation.
4. Design results (design
analysis and flow charts and documentation).
5. Conclusions (summary and your insight
gained from your work of project design and implementation).
6. Source code and implementation
results (source code of your programs and execution results with various
cases of input data).
Project
A Description:
To demonstrate major functions of a two-pass
SIC/XE assembler: Pass 1 and Pass 2. Select 40 or more SIC/XE instructions from
the textbook as the instruction set for your assembler design and
implementation. Please ensure to include Format 2, 3 and 4 instructions in the
set.
Input to the project:
-
Assembler source programs (e.g. several control sections) using the
instructions in the set you have selected.
-
Algorithms of Assembler Pass 1 and Pass 2.
Output (mandatory) required:
-
Symbol Table from Pass 1.
-
Relocatable object program with object code assembled from Pass 2
(object code assembled from each instruction to the assembler).
-
Each object program should include the following types of record: H, D,
R, T, M, and E types.
Project
B Description:
To demonstrate major functions of a
two-pass linking loader: Pass 1 (assigns addresses to all external references
in ESTAB) and Pass 2 (performs the actual loading, relocation and linking).
Input to the project:
-
Object programs (you can provide them using the samples in the textbook
or your own samples).
-
Source program listing (to show all external references used in the
programs).
-
Linking loader algorithms for Pass 1 and Pass 2.
Output (mandatory) required:
-
Addresses assigned to all the external reference symbols used from
Pass1.
-
Load Map from Pass 2, which should include names of control sections,
symbol names defined in each control section, symbol actual addresses, and
control section length.
-
Actual address and value (after loading) for each variable defined in
your programs (such as REF1-8, etc. in the Figure 3.8 in the textbook).
-
Printout of the executable program (in memory) after all programs are
linked, relocated, and loaded into memory.
Description
of Project C:
To demonstrate the major functions of one-pass macro processor: macro definition, invocation and expansion.
Input to the project:
-
SIC/XE assembly source programs with macro definitions and invocation
statements.
-
Algorithm of one-pass macro processor in Fig. 4.5.
-
Data structures of DEFTAB, NAMTAB and ARGTAB.
-
Use of SET statement and macro processor functions, such as %NITEMS.
Output (mandatory) required:
-
Expanded source program listing with at least 8 different macros
defined and used (invoked in the program).
-
Contents of DEFTAB (no comments allowed), NAMTAB and ARGTAB.
-
Conditional macro expansion (you can use the conditional statements
shown in the Figure 4.8 of the textbook, such as IF, ELSE, ESLEIF, ENDIF,
WHILE, and ENDW).
-
The implementation of IFs and WHILEs should allow nested structure
forms (e.g. IF(WHILE) structure within another IF(WHILE) structure).
-
Keyword macro parameters implementation.
-
Implementation of at least three macro processor functions, such as
%NITEMS.
-
Implementations of concatenation of macro parameters and generation of
unique labels.
Description
of Project D:
To demonstrate major functions of modern object-oriented language compilers in the areas of lexical analysis, syntactic analysis, and code generation.
Input to the project:
-
Subset of C# or C++ source language statement structures.
-
Related parsing and analysis algorithms and data structures.
-
Language grammar rules.
-
Microsoft’s Common Language Runtime (CLR).
Output (mandatory) required:
-
Microsoft Intermediate
Language (IL) source code statements.
-
IL programs (called assemblies) are workable or executable with the MS
Just-In-Time (JIT) compiler in the Common Language Runtime environment.
-
Implementations of the compilation processes: lexical analysis,
syntactic analysis, and code generation.
-
Language grammar rules used.
-
Lexical tokens used.
-
Parsing trees used.
-
Demonstration of the successful execution of at least five sample
source programs with various kinds of language structures.
-
Demonstration of the process of code optimization is optional, but the
additional work will be credited.
Description
of Project E:
To demonstrate major functions of other system software (e.g. text editor).
Input to the project:
-
Purpose of system software.
-
Typical input provided for the system software chosen by the team.
-
It is preferred to design the system software so that it can used in
the same context of other projects (such as Projects A and D).
-
A set of well designed data structures and algorithms.
Output (mandatory) required:
-
Typical functions (which are supposed to be available) for the chosen
system software.
-
Demonstration of good performance in the functions.
-
User manual (integrated with the software) on how to use the software.
-
Error messages and user support information.
-
Demonstration the use of design principles (such as data structures, algorithms,
symbol table, and passes) used in the class.
-
Demonstration of good software usability and portability.