High-Level Language

(1)

www.nand2tetris.org

Building a Modern Computer From First Principles

High-Level Language

(2)

Where we are at:

Assembler Chapter 6

H.L. Language

&

Operating Sys.

abstract interface

Compiler

Chapters 10 - 11

VM Translator

Chapters 7 - 8

Computer Architecture

Chapters 4 - 5

Gate Logic

Chapters 1 - 3

Electrical

Engineering

Physics Virtual

Machine

abstract interface

Software hierarchy

Assembly Language

abstract interface

Hardware hierarchy

Machine Language

abstract interface

Hardware Platform

abstract interface

Chips &

Logic Gates

abstract interface

Human Thought

Abstract design

Chapters 9, 12

(3)

Some milestones in the evolution of programming 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

 Fancy object-oriented languages (with inheritance):

C++, Java, C#

Jack

(4)

Programming languages

 Procedural programming (e.g. C, Fortran, Pascal)

 Object-oriented programming (e.g. C++, Java, Python)

 Functional programming (e.g. Lisp, ML, Haskell)

 Logic programming (e.g. Prolog)

(5)

ML

 fun fac(x) = if x=0 then 1 else x*fac(x-1);

 fun length(L) = if (L=nil) then 0

else 1+length(tl(L));

(6)

Prolog

 Facts

 human(kate).

 human(bill).

 likes(bill,kate).

 likes(kate,john).

 likes(john,kate).

 Rules

 friend(X,Y) :- likes(X,Y),likes(Y,X).

(7)

Prolog

 Absolute value

abs(X, X) :- X>=0, !.

abs(X, Y) :- Y is –X.

?- abs(-9,R).

R=9 ?- abs(-9,8).

No

 Length of a list

my_length([], 0).

(8)

(9)

Procedure oriented programming

(10)

Object oriented programming

message

(11)

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

(12)

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.

(13)

Roadmap for learning Jack

 Start with examples

 Hello World

 Procedure and array

 Abstract data types

 Linked list

 ...

 Formal Jack Spec.

 More complex examples

(14)

Hello world

/** Hello World program. */

class Main {

function void main () {

// Prints some text using the standard library do Output.printString("Hello World");

do Output.println(); // New line return;

} }

Some observations:

 Java-like syntax

 Classes

 Entry point: Main.main

 Typical comments format

 do for function calls

 Class_name.method_name

 Standard library a set of OS services (methods and functions)

organized in 8 supplied classes:

Math , ^String . ^Array , ^Output ,

Keyboard , ^Screen , ^Memory , ^Sys

(15)

Jack standard library ^aka language extensions ^aka Jack OS

class Math {

function void init() function int abs(int x)

function int multiply(int x, int y) function int divide(int x, int y) function int min(int x, int y) function int max(int x, int y) function int sqrt(int x)

}

(16)

Jack standard library ^aka language extensions ^aka Jack OS

Class String {

constructor String new(int maxLength) method void dispose()

method int length()

method char charAt(int j)

method void setCharAt(int j, char c) method String appendChar(char c)

method void eraseLastChar() method int intValue()

method void setInt(int j) function char backSpace() function char doubleQuote() function char newLine()

}

(17)

Jack standard library ^aka language extensions ^aka Jack OS

Class Array {

function Array new(int size) method void dispose()

}

class Memory {

function int peek(int address)

function void poke(int address, int value)

function Array alloc(int size)

(18)

class Output {

function void moveCursor(int i, int j) function void printChar(char c)

function void printString(String s) function void printInt(int i)

function void println() function void backSpace() }

Jack standard library ^aka language extensions ^aka Jack OS

Class Screen {

function void clearScreen()

function void setColor(boolean b)

function void drawPixel(int x, int y)

function void drawLine(int x1, int y1, int x2, int y2)

function void drawRectangle(int x1, int y1, int x2, int y2) function void drawCircle(int x, int y, int r)

}

(19)

Jack standard library ^aka language extensions ^aka Jack OS

Class Keyboard {

function char keyPressed() function char readChar()

function String readLine(String message) function int readInt(String message)

}

Class Sys {

function void halt():

function void error(int errorCode)

function void wait(int duration)

}

(20)

Typical programming tasks in Jack

Jack can be used to develop any app that comes to my mind, for example:

 Array processing reading/storing numbers in an array

 Procedural programming: a program that computes 1 + 2 + ... + 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 We will now discuss the above 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.

(21)

Array example

class Main {

function void main () { var Array a;

var int length;

var int i, sum;

let length = Keyboard.readInt(“#number:”) let a = Array.new(length);

let i = 0;

while (i < length) {

let a[i] = Keyboard.readInt("next: ");

let sum = sum + a[i];

let i = i+1;

}

do Output.printString("The average: ");

 var: variable declaration

 type: int, Array

 let: assignment

 Array: provided by OS.

No type for an array.

Actually, it can contain any type and even

different types in an array.

 Primitive types: int, boolean, char.

 All types in Jack occupy

one word. When declaring

(22)

Procedural programming example

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

 function (static method)

 (the example on the left has functions only, as it is

“object-less”)

class Main {

/** Sums up 1 + 2 + 3 + ... + n */

function int sum (int n) { var int sum, i;

let sum = 0;

let i = 1;

while (~(i > n)) { let sum = sum + i;

let i = i + 1;

}

return sum;

}

function void main () { var int n;

let n = Keyboard.readInt("Enter n: ");

do Output.printString("The result is: ");

do Output.printInt(sum(n));

return;

}

(23)

Object-oriented programming example

/** Represents a bank account.

A bank account has an owner, an id, and a balance.

The id values start at 0 and increment by 1 each time a new account is created. */

class BankAccount {

/** Constructs a new bank account with a 0 balance. */

constructor BankAccount new(String owner)

/** Deposits the given amount in this account. */

method void deposit(int amount)

/** Withdraws the given amount from this account. */

method void withdraw(int amount)

The BankAccount class (skeletal)

(24)

Object-oriented programming example (continues) /** Represents a bank account. */

class BankAccount {

// class‐level variable static int newAcctId;

// Private variables(fields/properties) field int id;

field String owner;

field int balance;

/** Constructs a new bank account */

constructor BankAccount new (String owner) {

let id = newAcctId;

let newAcctId = newAcctId + 1;

let this.owner = owner;

let balance = 0;

return this;

}

// More BankAccount methods.

}

// Code in any other class:

var int x;

var BankAccount b;

let b = BankAccount.new("joe");

Explain b = BankAccount.new("joe") Calls the constructor (which creates a new BankAccount object)

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") stores in variable b a pointer to the object’s base memory address

2

3

1

(25)

Object-oriented programming example (continues) /** Represents a bank account. */

class BankAccount {

// class‐level variable static int newAcctId;

// Private variables(fields/properties) field int id;

field String owner;

field int balance;

/** Constructs a new bank account */

constructor BankAccount new (String owner) {

let id = newAcctId;

let newAcctId = newAcctId + 1;

let this.owner = owner;

let balance = 0;

// Code in any other class:

var int x;

var BankAccount b;

let b = BankAccount.new("joe");

Behind the scene (following compilation):

// b = BankAccount.new("joe") push "joe"

call BankAccount.new pop b

Explanation: the calling code pushes an argument and calls the constructor; the constructor’s code (not shown above; the compiler generates Memory.alloc(n) for constructors) creates a new object, pushes its base address onto the stack, and returns;

3

1

(26)

class BankAccount {

static int nAccounts;

field int id;

field String owner;

field int balance;

// Constructor ... (omitted) /** Handles deposits */

method void deposit (int amount) { let balance = balance+amount;

return;

}

/** Handles withdrawls */

method void withdraw (int amount){

if (~(amount > balance)) {

let balance = balance‐amount;

}

return;

}

// More BankAccount methods.

}

...

var BankAccount b1, b2;

...

let b1 = BankAccount.new("joe");

let b2 = BankAccount.new("jane");

do b1.deposit(5000);

do b1.withdraw(1000);

...

Object-oriented programming example (continues)

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 fancy way to express the procedural semantics

deposit(b1,5000)

Behind the scene (following compilation):

// do b1.deposit(5000) push b1

push 5000

call BankAccount.deposit

(27)

Object-oriented programming example (continues) class BankAccount {

static int nAccounts;

field int id;

field String owner;

field int balance;

// Constructor ... (omitted)

/** Prints information about this account. */

method void printInfo () { do Output.printInt(id);

do Output.printString(owner);

do Output.printInt(balance);

return;

}

/** Disposes this account. */

// Code in any other class:

...

var int x;

var BankAccount b;

let b = BankAccount.new("joe");

// Manipulates b...

do b.printInfo();

do b.dispose();

Explain

do Memory.deAlloc(this) This is a call to an OS

function that knows how to

recycle the memory block

whose base-address is this.

(28)

Object-oriented programming example (continues) class BankAccount {

static int nAccounts;

field int id;

field String owner;

field int balance;

// Constructor ... (omitted)

/** Prints information about this account. */

method void printInfo () { do Output.printInt(id);

do Output.printString(owner);

do Output.printInt(balance);

return;

}

/** Disposes this account. */

method void dispose () {

do Memory.deAlloc(this);

return;

}

// More BankAccount methods.

}

// Code in any other class:

...

var int x;

var BankAccount b;

let b = BankAccount.new("joe");

// Manipulates b...

do b.printInfo();

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. If you don’t

do so, you may run out of

memory.

(29)

Abstract data type example

/** A fraction consists of a numerator and a denominator, both int values */

class Fraction {

/** Constructs a fraction from the given data */

constructor Fraction new(int numerator, int denominator) /** Reduces this fraction, e.g. changes 20/100 to 1/5. */

method void reduce() /** Accessors

method int getNumerator() method int getDenominator()

/** Returns the sum of this fraction and the other one */

method Fraction plus(Fraction other)

/** Returns the product of this fraction and the other one */

method Fraction product(Fraction other)

The Fraction class API (method signatures)

(30)

Abstract data type example (continues) class Fraction {

field int numerator, denominator;

constructor Fraction new (int numerator, int denominator) { let this.numerator = numerator;

let this.denominator = denominator;

do reduce() // Reduces the new fraction return this

}

/** Reduces this fraction */

method void reduce () { // Code omitted }

// A static method computing the greatest common denominator of a and b.

function int gcd (int a, int b) { // Code omitted } method int getNumerator () {

return numerator;

}

method int getDenominator () { return denominator;

}

// More Fraction methods follow.

// Code in any other class:

...

var Fraction a, b;

let a = Fraction.new(2,5);

let b = Fraction.new(70,210);

do b.print() // prints "1/3"

...

// (print method in next slide)

(31)

Abstract data type example (continues) ...

// Constructor and previously defined methods omitted /** Returns the sum of this fraction the other one */

method Fraction plus (Fraction other) { var int sum;

let sum = (numerator * other.getDenominator()) +

(other.getNumerator() * denominator());

return Fraction.new(sum , denominator * other.getDenominator());

}

// Similar fraction arithmetic methods follow, code omitted.

/** Prints this fraction */

method void print () {

do Output.printInt(numerator);

do Output.printString("/");

// Code in any other class:

var Fraction a, b, c;

(32)

Data structure example

/** Represents a sequence of int values, implemented as a linked list.

The list consists of an atom, which is an int value, and a tail, which is either a list or a null value. */

class List {

field int data;

field List next;

/* Creates a new list */

constructor List new (int car, List cdr) { let data = car;

let next = cdr;

return this;

}

/* Disposes this list by recursively disposing its tail. */

method void dispose() { if (~(next = null)) {

do next.dispose();

}

do Memory.deAlloc(this);

return;

} ...

} // class List.

// Code in any other class:

...

// Creates a list holding 2,3, and 5:

var List v;

let v = List.new(5 , null);

let v = List.new(2 , List.new(3,v));

...

v 5

3 5

v 2

(33)

Jack language specification

 Syntax

 Program structure

 Data types

 Variable kinds

 Expressions

 Statements

 Subroutine calling

(34)

Jack syntactic elements

 A jack program is a sequence of tokens separated by an arbitrary amount of white space and comments.

 Tokens can be symbols, reserved words, constants and identifiers.

/** Hello World program. */

class Main {

function void main () {

// Prints some text using the standard library do Output.printString("Hello World");

do Output.println(); // New line return;

}

(35)

Jack syntactic elements

(36)

Jack syntactic elements

(37)

Jack program structure

A Jack program:

 Each class is written in a separate file (compilation unit)

class ClassName {

field variable declarations;

static variable declarations;

constructor type { parameterList ) { local variable declarations;

statements }

method type { parameterList ) { local variable declarations;

statements }

function type { parameterList ) { local variable declarations;

statements }

About this spec:

 Every part in this spec can appear 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.

(38)

Jack data types

Primitive types (Part of the language; Realized by the compiler):

 int 16-bit 2’s complement (from ‐32768 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)

(39)

Jack data types

Jack is weakly typed. The language does not define the results of attempted assignment or conversion from one type to another, and different compilers may allow or forbid it.

var char c; var String s;

Let c = 33; // ‘A’

// Equivalently

Let s = “A”; let c=s.charAt(0);

var Array a;

Let a = 5000;

Let a[100] = 77; // RAM[5100]=77

(40)

Jack variable kinds and scope

(41)

Jack Statements (five types)

let varName = expression;

or

let varName[expression] = expression;

if (expression) { statements }

else {

statements }

while (expression) { statements

}

(42)

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 ( arithmetic negation )

 ~expression ( 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 )

(43)

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 function ( static method ): function int sqrt(int n) This function 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:

(44)

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: (language does not define, compiler-dependent) 1 + 2 * 3 yields ⁹ , 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 function

 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?