Principles of Programming Languages

Transcription

1 Principles of Programming Languages Lecture 10 Variables and Assignment 1

2 Variable Variable (Math) (CS) Math π CS pi symbol R definite singular description 3.14 referent symbol R indefinite singular description referent e.g. Prolog & FP (IFP) e.g. Pascal & Algol 68 2

3 Constants Algol 68: pi = ; C: (not quite) #define PI Pascal: const pi = ; Ada: pi: constant FLOAT := ; pi same logical status as a literal No reference available No object eists pi replaced by literal No stack (or any other) space allocated (stored in instruction) Pure definition 3

4 Variables Algol 68: begin,y; C: { float,y; Pascal: var,y: ; Ada:,y: FLOAT; y alloc on stack := 2.0; y := 3.0;

5 Assignment (after y gets 3) Algol 68: := y; C: = y; Bliss:.y y

6 Variables: Bliss v. C Bliss Eplicit dereferencing Contet dereferencing C (lvalue). =.y +.z a +.j.(a +.i) const (rvalue) = y + z a[j] = a[i] lvalue rvalue Synonym: *(a+j) = *(a+i) { Only lvalue is actually computed 6

7 Algol 68 aside: identity declaration := c NOT same as = c Identity declaration = 2.718; means Initialized variable := 2.718; means Why? Implicit local (stack) allocation 7

8 identity declaration (cont d) ; abbreviates loc ; which abbreviates the following identity declaration: = loc ; Local generator Yields a (lvalue) Ascribed to identifier 8

9 Initialized Variables Algol 68: begin p := ; C: { float p = ; Pascal: var p: ; begin p := ; Ada: p: FLOAT := ; p What is ``variable about a variable?! Not reference (location, lvalue) Ref cannot be changed; ``ascribed to or ``possessed by ident! Not identifier! Not type (in most languages)! The value (rvalue) stack 9

10 Algol 68 identity declaration: unifies variable m & constant declaration 1. loc m := 3; 2. = m; 3 m = m; m 3 10

11 Algol 68 identity declaration (cont d) 4. := m; loc :=m; = loc := m; t = *m; 9 t const. In new environment *m evaluated when declaration encountered 11

12 Pointers Refs to variable refs Algol 68: p ; C: float *p ; Pascal: var p: ^; Ada: type PTR is access FLOAT; p : PTR; (PTR=``access type to ``base type ) p ref 12

13 Algol 68 pointer declaration p ref p = loc ; ref stack 13

14 Pointers (cont d) Algol 68: p := ; C: p = & ; Bliss: p p ref stack 2.0 NOT Pascal, Ada picture. Closest is:! Pascal: new(p); p^ := ; Ada: p := new FLOAT(); ``anonymous variable 14

15 Pointers in Pascal/Ada: point into heap Defeats ``dangling pointers at block eit Pointers cannot point into the stack var : ; var p, py: ^; p py stack heap

16 Pascal/Ada pointers (cont d) new(p); p^ := ; p py stack heap ``anonymous variable p^ Pascal/Ada pointers point only to ``unnamed data objects 16

17 Pascal/Ada pointers (cont d) := 4.0; new(py); py := p; 1. p py stack heap

18 Pascal/Ada pointers (cont d) := 4.0; py^ := p^; 2. p py stack heap ``pointer value out of legal range 18

19 Pascal/Ada pointers (cont d) := 4.0; new(py); py^ := p^; 3. p py stack heap

20 Algol68 has a heap allocator ref p = heap ; h = heap ;! Abbreviated heap h; p stack h heap Pascal: lvalues of all var identifiers are in stack! lvalues of all anonymous variables are in the heap Algol68: no restriction! allocation orthogonal to declaration 20

21 Refs and Aliasing Algol68: py; py := p; p py stack p py ``pointer aliasing :

22 Refs and Aliasing (cont d) Algol 68: y = ; (identity declaration) y y no alloc! : ``name aliasing 2.0 ``equivalencing (Fortran) 22

23 Bliss: untyped bit strings = local ; 2; local p; p p p p ``ptr to stored in p picture after assignment

24 Semantics of Variable Uses: C v. Bliss On LHS = / On RHS C: = & Meaning of contet-sensitive Not ``referentially transparent Bliss:. Meaning of is ``referentially transparent. 24

25 Variable Uses: C v. Bliss (cont d) C: & not a unary operator! &(+y) meaningless! && meaningless (can t reverse a pointer)! &2 meaningless Bliss:. is a unary operator!.(+y) sensible!.. sensible!.2 sensible 2 = : :

26 C * Bliss. Bliss: C: On RHS. lvalue of rvalue of * Bliss variable occurrences are ``referentially transparent Semantics of is independent of contet 26