Class 04: The Source and Target Languages

Held: Wednesday, 28 January 2004

Summary: Today we consider the main languages involved in a sample compiler: the output language (PAL) and the input language (STUPID).

Related Pages:

• EBoard.
• Outline of class 3.
• PAL Code.
• TestPAL.java, a sample program.

Notes:

• Be careful what subject you choose for your email. In particular, when homework is due, I assume that email titled Homework or Assignment is your submission of the assignment. If you need help on the assignment, you should title your email Help! or something similar.
• My to do list just got insanely long. I probably won't respond to your surveys until early next week.

Overview:

• Pascal, continued.
• This week's focus.
• The input language: PAL.
• The output language: STUPID.

A Sample Compiler

• We will spend this week looking at the components of a sample compiler.
• I developed this sample compiler last year as an attempt to help the students better understand the compilation process.
• I expect that this year we'll use it as the basis of our own compilers.
• Today: Output and Input Languages
• Wednesday: Lexical and Syntactic Analysis
• Friday: Translation

PAL, The Pseudo-Assembly Language

• Intended as an intermediate code.
• Implemented as a Java data structure.
• Permits a large number of temporaries (like registers).
• Three named registers: Register.pc, Register.sp, Register.fp
• Permits trees of code (surprisingly useful to build during compilation).
• Also permits complex memory references.
• Still shows some design flaws.
• Typed: Different instructions have different types
• Data model:
  • Separate instructions and data
  • Data has a stack that starts at the end of memory
• (Programmer expected to manage heap starting at start of memory)
• Data types:
  • Kinds of "memory": Register, Temporary, Constants, Memory, Offsets in Memory
  • A computer: Runs programs (also prints them)
  • Instructions
    • Comments (inserted in program)
    • Addition, Multiplication, Division, Subtraction for Integers and Floats
    • Conversion: I2F and F2I
    • Control: Jump, JumpEqual, JumpLessEqual, JumpNotEqual
    • Input: IRead, FRead
    • Output: IWrite, FWrite, SWrite, NewLine
    • Stack manipulation: Push, Pop
    • Assignment: Move (type insensitive, you're just moving bits)
    • Building Programs: InstructionSequence (an instruction, so trees are permitted)
    • Miscellaneous: Halt, Label, NoOp
• A sample program

  import java.io.PrintWriter;
  import rebelsky.pal.*;
  
  public class TestPAL
  {
    public static void main(String[] args)
      throws Exception
    {
      PrintWriter out = new PrintWriter(System.out,true);
      Computer hal = new Computer(1000);
      Temporary input = new Temporary();
      Temporary result = new Temporary();
      Label startLabel = new Label("START");
      Label endLabel = new Label("END");
  
      InstructionSequence convert = new InstructionSequence();
      Temporary f = new Temporary();
      convert.add(new Label("CONVERT"));
      convert.add(new Comment("Experiments with Conversion"));
      convert.add(new FWrite(input));
      convert.add(new I2F(input,f));
      convert.add(new FWrite(f));
  
      InstructionSequence count = new InstructionSequence();
      Label countloop = new Label("LOOP");
      Label endcount = new Label("END");
      Temporary counter = new Temporary();
      count.add(new Comment("Print numbers from 1 to 10"));
      count.add(new Label("COUNT"));
      count.add(new Move(new IConstant(1), counter));
      count.add(countloop);
      count.add(new IWrite(counter));
      count.add(new JumpLessEqual(new IConstant(10), counter, endcount));
      count.add(new IAdd(new IConstant(1), counter, counter));
      count.add(new Jump(countloop));
      count.add(endcount);
  
      InstructionSequence code = new InstructionSequence();
      code.add(new Comment("Read values and test until 0 entered."));
      code.add(startLabel);
      code.add(new IRead(input));
      code.add(new IWrite(input));
      code.add(new IAdd(new IConstant(3), input, result));
      code.add(new IWrite(result));
      code.add(convert);
      code.add(new JumpNotEqual(input, new IConstant(0), startLabel));
      code.add(count);
      code.add(endLabel);
      code.add(new Halt());
  
      hal.setCode(code);
      out.println("----- DUMP -----");
      hal.dump(out);
      out.println("----- RUN ------");
      hal.run(true);
    } // main(String[])
  } // class TestPAL
  

Output Language

• I call out output language STUPID, for Sam's Totally Unintelligible Programming Instrution Doohickey.
• It was once called SAMPLE, for Sam's Amazingly Minor Programming Language Example.
• It looks a whole lot like Pascal, except that it avoids most of the cool parts.
• Three parts to every program:
  • Variable declarations (optional)
  • Function declarations (optional, may not be implemented yet)
  • Body (required)
• A simple program

  var
    x: integer;
  begin
    read(x);
    write(x+2);
  end