CS 345 Project Presentation

CS 345 Project Presentation

OOHA More Object-Oriented Hmm++

Alysha Behn

Jesse Vera

Project Overview: Hmm++

Revise existing BNF to facilitate inheritance and instanceof syntax

Near-complete revision of runtime stack usage Add an object-oriented feature: inheritance

BNF: what existed previously

Program : {[ Declaration ]|retType Identifier Function | MyClass | MyObject}

Function : ( ) Block

MyClass: Class Idenitifier { {retType Identifier Function}Constructor {retType Identifier Function } }

MyObject: Identifier Identifier = create Identifier callArgs

Constructor: Identifier ([{ Parameter } ]) block

Declaration : Type Identifier [ [Literal] ]{ , Identifier [ [ Literal ] ] }


Type : int|bool| float | list |tuple| object | string | void

Statements : { Statement }

Statement : ; | Declaration| Block |ForEach| Assignment |IfStatement|WhileStatement|CallStatement|ReturnStatement

Block : { Statements }

ForEach: for( Expression <- Expression ) Block

Assignment : Identifier [ [ Expression ] ]= Expression ;

Parameter : Type Identifier


IfStatement: if ( Expression ) Block

Expression : Conjunction {|| Conjunction }

Conjunction : Equality {&&Equality }

Equality : Relation [EquOp Relation ]

EquOp: == | !=

Relation : Addition [RelOp Addition ]

RelOp: <|<= |>|>=

Addition : Term {AddOp Term }


AddOp: + | -

Term : Factor {MulOp Factor }

MulOp: * | / | %

Factor : [UnaryOp]Primary

UnaryOp: - | !

Changes to BNF

RelOp: <|<= |>|>= → RelOp: <|<= |>|>= instanceof

MyClass: Class Identifier { {retType Identifier Function} Constructor {retType Identifier Function } }

→ MyClass: Class Identifier {extends Identifier} { {retType Identifier Function} Constructor {retType Identifier Function } }

ObjFunc : Class Dot MyObject Dot Function ( ) Block

→ ObjFunc : MyObject Dot Function ( ) Block

Revising stack

Old Stack

<main>

//Main calls foo

int foo(int num) {

Obj thing = create Obj(20, 4);

int result = 0;

thing.fun(num);

return result;

}

Revising stack

Old Stack

param numfoo::ret<main>

//Main calls foo

int foo(int num) {


int result = 0;

thing.fun(num);

return result;

}

Revising stack

Old Stack

myYmyX


//Main calls foo

int foo(int num) {


int result = 0;

thing.fun(num);

return result;

}

Revising stack

Old Stack

Y = 4myY X = 20

myXparam num

foo::ret<main>

//Main calls foo

int foo(int num) {


int result = 0;

thing.fun(num);

return result;

}

Revising stack

Old Stack

var resultmyYmyX


//Main calls foo

int foo(int num) {


int result = 0;

thing.fun(num);

return result;

}

Revising stack

Old Stack

var valuevar result arg num

myY fun::retmyX


//Main calls foo

int foo(int num) {


int result = 0;

result = thing.fun(num);

return result;

}

Revising stack

Old Stack

var valuevar result arg num

myY fun::retmyX


//Main calls foo

int foo(int num) {


int result = 0;


return result;

}?

Revising stack

New Stack

<main>

//Main calls foo

int foo(int num) {


int result = 0;


return result;

}

Revising stack

New Stack


//Main calls foo

int foo(int num) {


int result = 0;


return result;

}

Revising stack

New Stack

myYmyXthing


//Main calls foo

int foo(int num) {


int result = 0;


return result;

}

Revising stack

New Stack

y = 4x = 20myYmyXthing


//Main calls foo

int foo(int num) {


int result = 0;


return result;

}

Revising stack

New Stack

var resultmyYmyXthing


//Main calls foo

int foo(int num) {


int result = 0;


return result;

}

Revising stack

New Stackarg numfun::ret

var resultmyYmyXthing


//Main calls foo

int foo(int num) {


int result = 0;


return result;

}

Changes for inheritance

MyClasses ”point” to their parent classes MyClass copy parent data in constructor MyObjects keep track of runtime type and

compileTime type MyObjects treated like a variable, placed on the

stack Instance Variables referenced by an offset of

their object

Demo continued

int main() {

int x = foo();

println( "It worked!" );

}

int foo()

int temp = 0;

Test objOne = create Test(20, 4);

temp = objOne.fun(2);

Test_2 objTwo = create Test_2(15);

temp = objTwo.fun_2();

temp = objOne.fun(7);

return temp;

}

Inheritance : Demo

Class Test{

int myX;

int myY;

Test(int x, int y){

myX = x;

myY = y;

}

int fun (int match){

println("The result from method fun is: ");

println(myX);

println(myY);

int value = myX + myY;

return value;

}

}

Class Test_2 extends Test{

Test(int x){

myY = 5;

myX = x;

}

int fun_2(){

println("the result from method fun_2 is: ");

println(myX);

println(myY);

return (myX + myY);

}

}

Demo abstract syntax treeProgram (abstract syntax):

Function = main; Return type = int

params =

Block:

int x =

Call: foo, stackOffset=2

args =

Call: println, stackOffset=0

args =

StringValue: It worked!

Function = foo; Return type = int

params =

Block:

int temp =

IntValue: 0

Object = objOne; Object type = Test

args =

IntValue: 20

IntValue: 4

Assignment:

Variable: temp, LOCAL addr=1

Object Function = objOne; Function Name = fun

args =

IntValue: 2

Object = objTwo; Object type = Test_2

args =

IntValue: 15

Assignment:


Object Function = objTwo; Function Name = fun_2

args =

Abstract syntax Tree cont.

Assignment:


Object Function = objOne; Function Name = fun

args =

IntValue: 7

Return:

Variable: return#foo, LOCAL addr=0


Class: Test

int myX

int myY

Function = fun; Return type = int

params =

int match

Block:


args =

StringValue: The result from method fun is:


args =

Variable: myX, INSTANCE addr=1


args =

Variable: myY, INSTANCE addr=2

int value =

Abstract syntax Tree cont.

args =



args =


Return:

Variable: return#fun_2, LOCAL addr=8

Binary:

Operator: INT+



Constructor = Test

params =

int x

Block:

Assignment:


IntValue: 5

Assignment:


Variable: x, LOCAL addr=8

Demo output

The result from method fun is:

20

4

the result from method fun_2 is:

15

5

The result from method fun is:

20

4

It worked!

Changes to AbstractSyntax.java

Modified the class MyObject to extend Value instead of Statement to help treat MyObjects like variable

Each object gets individual copies of class data MyClass extends Value and implements Type to

compute instanceof Instanceof is added to the enum of Operators

StaticTypeChecker/SymbolTable

Beyond checking types of assignments, these classes set the static offsets for referencing data within a scope

Calling a constructor now creates a new scope Instance variables no longer remain in the

scope indefinitely Calls to functions now account for local

variables when moving the stack pointer

Interpreter

Interface with the stack is brand newGlobal map of objects and their instancesSpecial interpretation of variables used for instanceof

Questions

CS 345 Project Presentation

Documents

Transcript of CS 345 Project Presentation