High-Level Language. Building a Modern Computer From First Principles.

Transcription

1 High-Level Language Building a Modern Computer From First Principles Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 1

2 Where we are at: Human Thought Abstract design Chapters 9, 12 abstract interface H.L. Language & Operating Sys. Compiler Chapters abstract interface Virtual Machine Software hierarchy VM Translator Chapters 7-8 abstract interface Assembly Language Assembler Chapter 6 abstract interface Machine Language Computer Architecture Chapters 4-5 Hardware hierarchy abstract interface Hardware Platform Gate Logic Chapters 1-3 abstract interface Chips & Logic Gates Electrical Engineering Physics Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 2

3 A brief evolution of object-oriented languages Machine language (binary code) Assembly language (low-level symbolic programming) Simple procedural languages, e.g. Fortran, Basic, Pascal, C Simple object-based languages (without inheritance), e.g. early versions of Visual Basic, JavaScript Jack Fancy object-oriented languages (with inheritance): C++, Java, C# Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 3

4 The Jack programming language Jack: a simple, object-based, high-level language with a Java-like syntax Some sample applications written in Jack: procedural programming Pong game Space Invaders Tetris Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 4

5 Disclaimer Although Jack is a real programming language, we don t view it as an end Rather, we use Jack as a means for teaching: How to build a compiler How the compiler and the language interface with the operating system How the topmost piece in the software hierarchy fits into the big picture Jack can be learned (and un-learned) in one hour. Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 5

6 Hello world /** /** Hello Hello World World program. program. */ */ class class Main Main { void void main main () (){ // // Prints Prints some some text text using using the the standard standard library library do do Output.printString("Hello World"); World"); do do Output.println(); // // New New line line return; return; Some observations: Java-like syntax Typical comments format Standard library Language-specific peculiarities. Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 6

7 Typical programming tasks in Jack Jack can be used to develop any app that comes to my mind, for example: Procedural programming: a program that computes n Object-oriented programming: a class representing bank accounts Abstract data type representation: a class representing fractions (like 2/5) Data structure representation: a class representing linked lists Etc. We will now discuss the above app examples As we do so, we ll begin to unravel how the magic of a high-level object-based language is delivered by the compiler and by the VM These insights will serve us in the next lectures, when we build the Jack compiler. Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 7

8 Procedural programming example class class Main Main { /** /** Sums Sums up up n */ */ int int sum sum (int (int n) n) { var var int int sum, sum, i; i; let let sum sum = 0; 0; let let i = 1; 1; while while (~(i (~(i > n)) n)) { let let sum sum = sum sum + i; i; let let i = i + 1; 1; return return sum; sum; void void main main () (){ var var int int n; n; let let n = Keyboard.readInt("Enter n: n: "); "); do do Output.printString("The result result is: is: "); "); do do Output.printInt(sum(n)); return; return; Jack program = a collection of one or more classes Jack class = a collection of one or more subroutines Execution order: when we execute a Jack program, Main.main() starts running. Jack subroutine: method constructor (static method) (the example on the left has s only, as it is object-less ) Standard library: a set of OS services (methods and s) organized in 8 supplied classes: Math, String. Array, Output, Keyboard, Screen, Memory, Sys (OS API in the book). Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 8

9 Object-oriented programming example The BankAccount class API (method sigantures) /** /** Represents Represents a bank bank account. account. A bank bank account account has has an an owner, owner, an an id, id, and and a balance. balance. The The id id values values start start at at 0 and and increment increment by by 1 each each time time a new new account account is is created. created. */ */ class class BankAccount { /** /** Constructs Constructs a new new bank bank account account with with a 0 balance. balance. */ */ constructor BankAccount new(string new(string owner) owner) /** /** Deposits Deposits the the given given amount amount in in this this account. account. */ */ method method void void deposit(int amount) amount) /** /** Withdraws Withdraws the the given given amount amount from from this this account. account. */ */ method method void void withdraw(int amount) amount) /** /** Prints Prints the the data data of of this this account. account. */ */ method method void void printinfo() /** /** Disposes Disposes this this account. account. */ */ method method void void dispose() dispose() Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 9

10 Object-oriented programming example (continues) /** /** Represents Represents a bank bank account. account. */ */ class class BankAccount { // // class-level variable variable static static int int newacctid; newacctid; // // Private Private variables variables (aka (aka fields fields / / properties) properties) field field int int id; id; field field String String owner; owner; field field int int balance; balance; /** /** Constructs Constructs a new new bank bank account account */ */ constructor BankAccount new new (String (String owner) owner) { let let id id = newacctid; newacctid; let let newacctid newacctid = newacctid newacctid + 1; 1; let let this.owner this.owner = owner; owner; let let balance balance = 0; 0; return return this; this; 2 // // More More BankAccount methods. methods. 3 // // Code Code in in any any other other class: class: var var int int x; x; var var BankAccount b; 1 b; let let b = BankAccount.new("joe"); Explain: return this The constructor returns the RAM base address of the memory block that stores the data of the newly created BankAccount object Explain: b = BankAccount.new("joe") Calls the constructor (which creates a new BankAccount object), then stores a pointer to the object s base memory address in variable b Behind the scene (following compilation): // b = BankAccount.new("joe") push "joe" call BankAccount.new pop b Explanation: the VM code calls the constructor; the constructor creates a new object, pushes its base address onto the stack, and returns; The calling code then pops the base address into a variable that will now point to the new object. Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 10

11 Object-oriented programming example (continues) class class BankAccount { static static int int naccounts; naccounts; field field int int id; id; field field String String owner; owner; field field int int balance; balance; // // Constructor......(omitted) /** /** Handles Handles deposits deposits */ */ method method void void deposit deposit (int (int amount) amount) { let let balance balance = balance balance + amount; amount; return; return; /** /** Handles Handles withdrawls withdrawls */ */ method method void void withdraw withdraw (int (int amount){ amount){ if if (~(amount (~(amount > balance)) balance)) { let let balance balance = balance balance - amount; amount; return; return; // // More More BankAccount methods. methods var var BankAccount b1, b1, b2; b2; let let b1 b1 = BankAccount.new("joe"); let let b2 b2 = BankAccount.new("jane"); do do b1.deposit(5000); do do b1.withdraw(1000); Explain: do b1.deposit(5000) In Jack, void methods are invoked using the keyword do (a compilation artifact) The object-oriented method invocation style b1.deposit(5000) is a fabcy way to expres the procedural semantics deposit(b1,5000) Behind the scene (following compilation): // do b1.deposit(5000) push b1 push 5000 call BanAccount.deposit Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 11

12 Object-oriented programming example (continues) class class BankAccount { static static int int naccounts; naccounts; field field int int id; id; field field String String owner; owner; field field int int balance; balance; // // Constructor......(omitted) /** /** Prints Prints information about about this this account. account. */ */ method method void void printinfo printinfo () (){ do do Output.printInt(id); do do Output.printString(owner); do do Output.printInt(balance); return; return; /** /** Disposes Disposes this this account. account. */ */ method method void void dispose dispose () (){ do do Memory.deAlloc(this); return; return; // // Code Code in in any any other other class: class: var var int int x; x; var var BankAccount b; b; let let b = BankAccount.new("joe"); // // Manipulates b... b... do do b.printinfo(); do do b.dispose(); Explain do b.dispose() Jack has no garbage collection; The programmer is responsible for explicitly recycling memory resources of objects that are no longer needed. // // More More BankAccount methods. methods. Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 12

13 Abstract data type example The Fraction class API (method sigantures) /** /** Represents Represents a fraction fraction data data type. type. A fraction fraction consists consists of of a numerator numerator and and a denominator, both both int int values values */ */ class class Fraction Fraction { /** /** Constructs Constructs a fraction fraction from from the the given given data data */ */ constructor Fraction Fraction new(int new(intnumerator, numerator, int int denominator) /** /** Reduces Reduces this this fraction, fraction, e.g. e.g. changes changes 20/100 20/100 to to 1/5. 1/5. */ */ method method void void reduce() reduce() /** /** Accessors Accessors method method int int getnumerator() method method int int getdenominator() /** /** Returns Returns the the sum sum of of this this fraction fraction and and the the other other one one */ */ method method Fraction Fraction plus(fraction other) other) /** /** Returns Returns the the product product of of this this fraction fraction and and the the other other one one */ */ method method Fraction Fraction product(fraction other) other) /** /** Prints Prints this this fraction fraction */ */ method method void void print() print() /** /** Disposes Disposes this this fraction fraction */ */ method method void void dispose() dispose() Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 13

14 Abstract data type example (continues) /** /** Represents Represents a fraction fraction data data type. type. A fraction fraction consists consists of of a numerator numerator and and a denominator, both both int int values values */ */ class class Fraction Fraction { field field int int numerator, numerator, denominator; constructor Fraction Fraction new new (int (int numerator, numerator, int int denominator) { let let this.numerator = numerator; numerator; let let this.denominator = denominator; do do reduce() reduce() // // Reduces Reduces the the new new fraction fraction return return this this /** /** Reduces Reduces this this fraction fraction */ */ method method void void reduce reduce () (){ // // Code Code omitted omitted // // A static static method method that that computes computes the the greatest greatest common common denominator of of a and and b. b. int int gcd gcd (int (int a, a, int int b) b) { // // Code Codeomitted omitted // // Code Code in in any any other other class: class: method method int int getnumerator () (){ var var Fraction Fraction a, a, b; b; return return numerator; numerator; let let a = Fraction.new(2,5); let let b = Fraction.new(70,210); method method int int getdenominator () (){ do do b.print() b.print() // // prints prints "1/3" "1/3" return return denominator; // //(print method method in in next next slide) slide) // // More More Fraction Fraction methods methods follow. follow. Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 14

15 Abstract data type example (continues) /** /** Represents Represents a fraction fraction data data type. type. A fraction fraction consists consists of of a numerator numerator and and a denominator, both both int int values values */ */ class class Fraction Fraction { field field int int numerator, numerator, denominator; // // Constructor and and previously previously defined defined methods methods omitted omitted /** /** Returns Returns the the sum sum of of this this fraction fraction the the other other one one */ */ method method Fraction Fraction plus plus (Fraction (Fraction other) other) { var var int int sum; sum; let let sum sum = (numerator (numerator* other.getdenominator()) + (other.getnumerator() * denominator()); return return Fraction.new(sum, denominator * other.getdenominator()); // // Similar Similar fraction fraction arithmetic arithmetic methods methods follow, follow, code code omitted. omitted. /** /** Prints Prints this this fraction fraction */ */ method method void void print print () (){ do do Output.printInt(numerator); do do Output.printString("/"); do do Output.printInt(denominator); return return // // Code Code in in any any other other class: class: var var Fraction Fraction a, a, b, b, c; c; let let a = Fraction.new(2,3); let let b = Fraction.new(1,5); // // computes computes c = a + b let let c = a.plus(b); a.plus(b); do do c.print(); c.print(); // // prints prints "13/15" "13/15" Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 15

16 Data structure example /** /** Represents Represents a sequence sequence of of int int values, values, implemented as as a linked linkedlist. list. The The list list consists consists of of an an atom, atom, which which is is an an int int value, value, and and a tail, tail, which which is is either either a list list or or a null null value. value. */ */ class class List List { field field int int data; data; field field List List next; next; /* /* Creates Creates a new new list list */ */ constructor List List new new (int (int car, car, List List cdr) cdr) { let let data data = car; car; let let next next = cdr; cdr; return return this; this; v 2 v /* /* Disposes Disposes this this list list by by recursively disposing disposing its its tail. tail. */ */ method method void void dispose() dispose() { if if (~(next (~(next = null)) null)) { // do do next.dispose(); // Code Code in in any any other other class: class: do do Memory.deAlloc(this); // // Creates Creates a list list holding holding the the numbers numbers 2,3, 2,3, and and 5: 5: return; return; var var List List v; v; let let v = List.new(5 List.new(5, null); null); let let v = List.new(2 List.new(2, List.new(3,v)); // // class class List. List Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 16

17 Jack language specification Syntax Data types Variable kinds Expressions Statements Subroutine calling Program structure Standard library (for complete language specification, see the book). Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 17

18 Jack syntax Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 18

19 Jack syntax (continues) Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 19

20 Jack data types Primitive types (Part of the language; Realized by the compiler): int 16-bit 2 s complement (from to 32767) boolean 0 and 1, standing for true and false char unicode character ( a, x, +, %,...) Abstract data types (Standard language extensions; Realized by the OS / standard library): String Array... (extensible) Application-specific types (User-defined; Realized by user applications): BankAccount Fraction List Bat / Ball... (as needed) Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 20

21 Jack variable kinds and scope Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 21

22 Jack expressions A Jack expression is any one of the following: A constant A variable name in scope (the variable may be static, field, local, or a parameter) The keyword this, denoting the current object An array element using the syntax arrayname[expression], where arraynname is a variable name of type Array in scope A subroutine call that returns a non-void type An expression prefixed by one of the unary operators or ~ : -expression ~expression (arithmetic negation) (logical negation) An expression of the form expression op expression where op is one of the following: + - * / (integer arithmetic operators) & < > = (boolean and and or operators, bit-wise) (comparison operators) ( expression ) (an expression within parentheses) Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 22

23 Jack Statements let let varname = expression; expression; or or let let varname[expression] = expression; expression; if if (expression) { statements else else { statements while while (expression) { statements do do -or-method-call; return return expression; expression; or or return; return; Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 23

24 Jack subroutine calls General syntax: subroutinename(arg0, arg1, ) where each argument is a valid Jack expression Parameter passing is by-value (primitive types) or by-reference (object types) Example 1: Consider the (static method): int sqrt(int n) This can be invoked as follows: sqrt(17) sqrt(x) sqrt((b * b) (4 * a * c)) sqrt(a * sqrt(c - 17) + 3) Etc. In all these examples the argument value is computed and passed by-value Example 2: Consider the method: method Matrix plus (Matrix other); If u and v were variables of type Matrix, this method can be invoked using: u.plus(v) The v variable is passed by-reference, since it refers to an object. Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 24

25 Noteworthy features of the Jack language The (cumbersome) let keyword, as in let x = 0; The (cumbersome) do keyword, as in do reduce(); No operator priority: * 3 yields 9, since expressions are evaluated left-to-right; To effect the commonly expected result, use 1 + (2 * 3) Only three primitive data types: int, boolean, char; In fact, each one of them is treated as a 16-bit value No casting; a value of any type can be assigned to a variable of any type Array declaration: Array x; followed by x = Array.new(); Static methods are called Constructor methods are called constructor; Invoking a constructor is done using the syntax ClassName.new(argsList) Q: Why did we introduce these features into the Jack language? A: To make the writing of the Jack compiler easy! Any one of these language features can be modified, with a reasonable amount of work, to make them conform to a more typical Java-like syntax. Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 25

26 Jack program structure class class ClassName { field fieldvariable declarations; static staticvariable declarations; constructor type type { parameterlist ) { local local variable declarations; statements method method type type { parameterlist ) { local local variable declarations; statements type type { parameterlist ) { local local variable declarations; statements About this spec: Every part in this spec can apper 0 or more times The order of the field / static declarations is arbitrary The order of the subroutine declarations is arbitrary Each type is either int, boolean, char, or a class name. A Jack program: Each class is written in a separate file (compilation unit) Jack program = collection of one or more classes, one of which must be named Main The Main class must contain at least one method, named main() Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 26

27 Jack standard library aka language extensions aka Jack OS class class Math Math { void void init() init() Class Class String String int int abs(int { abs(int x) x) constructor int int multiply(int String String new(int new(int x, x, int maxlength) int y) y) method Class method Class Array int void Array { int void divide(int dispose() dispose() x, x, int int y) y) method method int int int int min(int length() min(int Array Array length() x, x, new(int new(int y) y) size) method class size) method class int char Output int char max(int Output charat(int { max(int x, x, int y) j) y) j) method method method method int void int void void sqrt(int void setcharat(int dispose() void sqrt(int dispose() void movecursor(int x) j, x) j, char char c) i, c) i, int int j) j) method method String Class String Class Screen appendchar(char Screen void void printchar(char { c) c) c) c) method method void void eraselastchar() void void void void printstring(string clearscreen() s) s) method method int class int class Memory intvalue() void Memory void void void printint(int setcolor(boolean { i) b) i) b) method method void void setint(int void void void void println() drawpixel(int println() j) x, x, int int y) peek(int peek(int address) y) j) Class address) char char backspace() void Class void Keyboard void void backspace() Keyboard drawline(int { x1, x1, int int y1, y1, void void poke(int poke(int x2, address, x2, address, int int y2) y2) int int value) value) char char doublequote() char void void drawrectangle(int char keypressed() Class x1, x1, int int y1, y1, char char newline() Class Sys int newline() Array Sys { Array alloc(int alloc(int size) int size) x2, x2, int int y2) char char readchar() y2) void void drawcircle(int x, x, int int y, y, int int r) void r) void void dealloc(array void halt(): halt(): o) o) String String readline(string message) message) void void error(int error(int errorcode) int int readint(string message) message) void void wait(int wait(int duration) duration) Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 27

28 Perspective Jack is an object-based language: no inheritance Primitive type system Standard library Our hidden agenda: gearing up to learn how to develop the... Compiler (projects 10 and 11) OS (project 12). Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High-Level Language slide 28