Lecture 29 - December 6, 2007

Snobol_Tree_Scoring.xls - so you can see what rows the comments refer to

DEFINE('LLIST(head)','LLIST_start') :(LLIST_end)

LLIST_start

* Print the current node's value

OUTPUT = VALUE(head)

* Check if the left son of the current node is NULL

DIFFER(LSON(head),NULL) :S(one)F(return)

* Recurse through the left side of the tree

one llist(LSON(head))

* Check if the right son of the current node is NULL

DIFFER(RSON(head),NULL) :S(two)F(return)

* Recurse through the right side of the tree

two llist(RSON(head))

:(return)

LLIST_end

* I do not believe that this code will work properly if the tree is

* not a complete tree. In the earlier class I said it would!!!

* The LLIST subprogram that prints the value in every node

DEFINE('LLIST(P)','LLIST_START') :(LLIST_END)

LLIST_START

* Prints off the value in the current node

OUTPUT = value(P)

* Checks if the left child is NULL

IDENT(leftSon(P)) :S(RIGHT)

* Recursively calls itself with the left child as the parameter

LLIST(leftSon(P))

* Checks if the right child is NULL

RIGHT IDENT(rightSon(P)) :S(DONE)

* Recursively calls itself with the right child as the parameter

LLIST(rightSon(P))

DONE :(RETURN)

LLIST_END

* Define the BNODE data type

DATA('BNODE(VALUE,LSON,RSON)')

* Inform the user of what the program does

OUTPUT = 'This program generates a binary tree with three '

OUTPUT = 'nodes such that the value of the root is +, the '

OUTPUT = 'value of the left son is X, and the value of the '

OUTPUT = 'right son is Y. Finally the tree is printed using '

OUTPUT = 'a pre-order traversal recursive algorithm.'

OUTPUT =

* Assign the value '+' to the root node

root = BNODE('+')

* Assign the value 'X' to the left son node

leftSon = BNODE('X')

* Assign the value 'Y' to the right son

rightSon = BNODE('Y')

* Make the root's LSON reference the left son node

LSON(root) = leftSon

* Make the root's RSON reference the right son node

RSON(root) = rightSon

* Call LLIST to print the tree in pre-order traversal

LLIST(root)

P = BNODE('+', BNODE('*',BNODE(5), BNODE(7)),BNODE('-',BNODE(16),BNODE(7)))

Q = BNODE('+', BNODE('*', BNODE('+',BNODE('J'),BNODE('K')),

+ BNODE('+', BNODE('L'),BNODE('M'))),

+ BNODE('-',BNODE('+', BNODE('O'), BNODE('P')),

+ BNODE('+', BNODE('R'),BNODE('S'))))

OUTPUT = "Binary tree in pre order"

LLIST(P)

OUTPUT =

LLIST(Q)

* Inform the user the program ended successfully

OUTPUT =

OUTPUT = 'This program has ended successfully.'

END

My comment that Snobol requires the code for a function to precede the call to the function appears not to be correct. Please change it in your notes.

Final is comprehensive – whole semester’s material will be tested

FORTRAN

· FORTRAN’s do loop was the only iteration available in early FORTRAN

o It came in two forms, the “standard form” and the implied form

· Has 2 types of subprograms:

o Functions which return a single value, by assignment to function name

§ function names are implicitly typed (i.e. integer function stamp or function istamp as function name if you want an integer returned

o Subroutines which eturn 0,1, or many values, through the parameter list

§ Parameters are passed by reference

· Transfer of control is accomplished using GO TO statements using labels which are integers which appear in columns 1thru 5

· Input and output are accomplished using function calls READ and WRITE to devices referred to by integers, 5 is generally used for input, 6 for output using FORMAT statements which specify the form of the output

· Had implicit data typing , variables beginning with i..n are integers, others are reals.

· Code had to be written using specific columns: 7-72 is for code, 73-80 for sequencing of punched cards, 6 was for continuation of previous line, C in column 1 for comments, 1-5 for labels.

· Case sensitivity: code was supposed to be in upper case

· Arrays were the only composite data type in early FORTRAN, their indexes start at 1, they are stored in column major order

· Horizontal spaces were ignored even within variable names

· The assignment operator is a = sign

· Selection statements, only one kind, an IF statement

o The IF statement generally required the use of a GO TO (because there was no IF…THEN constructs)

· The relational operators are: .LT. .GT. .LE. .EQ. .NE. .GE.

· The logical operators are: .AND. .OR. .NOT.

· Data types: INTEGER , REAL, COMPLEX, LOGICAL, CHARACTER(?), DOUBLE

Other LANGUAGES we worked with: Pascal, Alice, Snobol4, Prolog, Lisp, project language

Other things to know about above languages

· Paradigms

· Characteristics that make a programming language good

· Parameter passing modes

· Alternative implementations (use) of

§ Parameter modes

§ Selection statements

§ Iteration statement

§ Subprogram types

§ Input statements

§ Output statements

§ Keywords vs reserved words vs neither

§ Precedence rules for operators

§ Error handling mechanisms

§ Computation of address of item in an array stored in row or column major order

§ Different types of equivalence: declaration, name, structure