1. Expressions
Programming Language Design and Implementation (4th Edition)
by T. Pratt and M. Zelkowitz
Prentice Hall, 2001
Section

2. Execution-time representation
Machine code sequence
Tree representation
Pre-fix or post-fix
Expressions

3. Tree structure rules Slow  software interpreter Problem parse tree
Uniform evaluation rules
Eager evaluation ? Lazy evaluation (LISP, PROLOG)
Z+(Y==0 ? X : X/Y)
Side effect
a * fun(x) + a
Error conditions
Optimization, …
Short-circuit boolean expression
if((A==0) || (B/A)>C) {…}
while((I<=UB) && (V[I]>0)) {…}
Expressions

4. Postfix Infix notation: Operator appears between operands: 2 + 3  5
3 + 6  9
Implied precedence: * 4  2 + (3 * 4 ),
not (2 + 3 ) * 4
Prefix notation: Operator precedes operands:
+ 2 3  5
+ 2 * 3 5  (+ 2 ( * 3 5 ) )   17
Postfix notation: Operator follows operands:
2 3 +  5
2 3 * 5 + (( 2 3 * 5 +)   11
Called Polish postfix since few could pronounce Polish mathematician Lukasiewicz, who invented it.
An interesting, but unimportant mathematical curiosity when presented in 1920s. Only became important in 1950s when Burroughs rediscovered it for their ALGOL compiler.
Expressions

5. Evaluation of postfix 1. If argument is an operand, stack it.
2. If argument is an n-ary operator, then the n arguments are already onthe stack. Pop the n arguments from the stack and replace by the value of the operator applied to the arguments.
Example: * +
stack
stack
stack
replace 3 and 4 on stack by 7
stack
6. * - replace 5 and 7 on stack by 35
replace 35 and 2 on stack by 37
Expressions

6. Importance of Postfix to Compilers
Code generation same as expression evaluation.
To generate code for * +, do:
stack L-value of 2
stack L-value of 3
stack L-value of 4
generate code to take R-value of top stack element (L-value of 4) and add to R-value of next stack element (L-value of 3) and place L-value of result on stack
stack L-value of 5
6. * - generate code to take R-value of top stack element (L-value of 5) and multiply to R-value of next stack element (L-value of 7) and place L-value of result on stack
generate code to take R-value of top stack element (L-value of 35) and add to R-value of next stack element (L-value of 2) and place L-value of result (37) on stack
Expressions

7. Forth - A language based on postfix
Postfix source language leads to an efficient execution model, even though generally interpreted. System runs on two stacks - a subroutine return stack and an expression evaluation stack. Run-time model very small making it useful on small embedded computers.
Forth was developed by Charles Moore around The name was a contraction of “Fourth Generation Programming Language” with the program name limited to five characters. The language was a replacement for FORTRAN on small minicomputers in the 1970s where space was at a premium and the only input-output device was often a very slow and cumbersome paper tape. Having a resident translator/interpreter made for easy program development on the target system.
Expressions

8. Example Forth program Program to compute: 12+22+ ... +92+102$
[Notation: a,b,c is expression stack.
c is stack(top)]
: SQR DUP * ; (Defines square by: n  n,n (n*n))
: DOSUM SWAP 1 + SWAP OVER SQR + ;
Execution:
( N,S  N+1,S+(N+1)2)
( N,S  S,N  S,(N+1) (N+1),S 
(N+1),S, N+1) (N+1),S, N+1)2 
(N+1),S+(N+1)2)
3 6 DOSUM ok (Period (.) prints stack(top).
Output is 22 = 42+6)
DO DOSUM LOOP ok
(Apply DOSUM from 0 to 9 (Stop at 10)) }}
Expressions

9. Postscript Postscript is Forth with painting commands added.
1: %Same as Forth program
2: /Helvetica findfont
3: 20 scalefont
4: setfont
5: moveto
6: /formatit {10 10 string cvrs show} def
7: /sqr {dup mul} def
8: /dosum {exch 1 add exch 1 index sqr add} def
9: 3 6 dosum 2 copy formatit ( ) show formatit
10: clear
11: moveto
12: {pop dosum} for formatit
13: showpage
Expressions

10. Postscript painting commands
14: % Lets draw a truck
15: /box {newpath 0 0 moveto 0 1 lineto 3 1 lineto 3 0 lineto
16: closepath} def
17: .1 setlinewidth 0 setgray
18: gsave
19: scale
20: 2 5 translate box stroke
21: translate scale box fill
22: 0 1 translate scale box fill
23: grestore
24: /tire {newpath 1 0 moveto arc closepath} def
25: .5 setlinewidth scale
26: translate tire stroke
27: 3 0 translate tire stroke
28: 17 0 translate tire stroke
29: 3 0 translate tire stroke
30: 8 0 translate tire stroke
13: showpage
Expressions

11. Precedence of operators
Assumed order of evaluation for arithmetic expressions:
2*3+4*5 assumed to be 26 since assumed ordering is
(2*3)+(4*5).
This is specified by precedence of operators.
In any expression, the highest precedence operations are evaluated first, and so on.
Most languages have an implied precedence.
APL and Smalltalk do not. Neither language emphasizes arithmetic data, so it is not clear what precedence means in this case.
C has 17 levels of precedence (given next)
Expressions

12. C precedence levels Precedence Operators Operator names
tokens, a[k], f()Literals, subscripting, function call
.,-> Selection
, Postfix increment/decrement
15* , Prefix inc/dec
, -, sizeof Unary operators, storage
!,&,* Logical negation, indirection
typename Casts
*, /, % Multiplicative operators
, Additive operators
<<, >> Shift
<,>,<=, >= Relational
==, != Equality
& Bitwise and
 Bitwise xor
| Bitwise or
&& Logical and
|| Logical or
?: Conditional
=, +=, -=, *=, Assignment
/=, %=, <<=, >>=, &=, =, |=
, Sequential evaluation
Expressions