Storage. Outline. Variables and Updating. Composite Variables. Storables Lifetime : Programming Languages. Course slides - Storage

Size: px
Start display at page:

Download "Storage. Outline. Variables and Updating. Composite Variables. Storables Lifetime : Programming Languages. Course slides - Storage"

Transcription

1 Storage 1 Variables and Updating Outline Composite Variables Total and selective updating Array variables Storables Lifetime Local and global variables Heap variables Persistent variables Garbage collection 2 Storage 1

2 Variables and Updating Variable: an entity that contains a value. Values may be primitive or composite There are two basic operations that can be performed on a variable: Inspect Update Model real-world objects with state: e.g. a country s population Variables in imperative languages vs. mathematical variables: Mathematical variables stand for fixed but unknown values Variables in imperative languages may change over time (n := n+1) They don t necessarily have a value at all Variables may be: Short-lived - created and used within one program, or Long-lived (persistent) exist independently of programs: files and databases. Variable are realized by a storage medium (memory, disk, etc.). 3 A Model of Storage Store: a collection of cells Cells: allocated or unallocated. An allocated cell has content: a storable value or undefined. STORE??? Example: var n: Integer; { Some unallocated cell changes status to allocated } n := 1 { Content changes from undefined to 1 } n := n + 1 { Content changes from 1 to 2 } end; { Cells changes status to unallocated } 4 Storage 2

3 Composite Variables Composite value: Has subcomponent values, which may be inspected selectively. Composite variable: Has subcomponent variables. These may be inspected and (in principle) updated separately. It is always possible to make selective inspection, since once the value in a variable is inspected, you can selectively inspect each component. 5 The Structure of Composite Variables In most languages: a variable of type T is structured like a value of type T Exception: Packed arrays in Pascal, which cannot be accessed before the array is unpacked Consider bignums A record variable is a tuple of variables: type Date = record m: Month; todayd: end; var today: Date; today.m today.d Array variable is a mapping into variables: var holidays: array[1..30] of Date; Other type constructors? Sets? Unions? 6 Storage 3

4 Total and Selective Updating Total updating (and selective inspection): today := holidays[1]; Selective updating: holidays[1] := today; Can be viewed as total updating that happens to leave some components unchanged. Selective updating is not essential: ML Variables: T ref a variable which can store a value of type T. If T is a record then no selective updating is possible. datatype month = jan feb mar... dec type date = month * int val today: date ref = ref(feb, 23)... today := (feb, 29) This is an aggregate! If the components are a reference type, then the whole cannot be updated. ML arrays - only selective updating is possible: All array components are references. 7 Array Variables An array is a mapping from an index set to a collection of variables. When is the index set determined? Static arrays: fixed at compile time. Dynamic arrays: on creation of the array variable. In Ada: m: Integer :=...;... type Vector is array (Integer range <>) of Float; a: Vector(1..10); b: Vector(0..m) procedure ReadVec(v: out Vector) is...;-- Use v first & v last ReadVec(a); ReadVec(b)... a := b; -- Succeeds only if b has exactly 10 elements. Flexible arrays: not fixed; bounds may change whenever index is changed. The type of these arrays (flexible or dynamic) is: Integer Integer (Integer Real) 8 Storage 4

5 Generalized Arrays Ordinary arrays: mappings from integral types. Advantages of integral indices: Only values are stored, not indices. The bounds of the array define its legal indices. Disadvantages: When data are sparse, packing techniques are needed. Inflexible programming. Generalized (associative) arrays: mappings from non-integral types. Example: Element "dog" Value "chien" Element "cat" Value "chat" Element "one" Value "un" Element 1 Value "un" 9 Generalized Arrays in AWK In AWK any string can serve as an index of an array. Built-in constructs to loop over all valid indices of an array Built-in constructs to check if a value is a valid index of an array. Type: Since for any potential string we can determine whether it is a valid index and access the value at that index, the type of an array of strings indexed by strings is: (String) X (String String) An array in AWK can be viewed as a pair <S,f>, where S is a set of strings and f is a function from strings to strings. In AWK, if you try to access an undefined index, an element with this index is automatically created and updated with the null string. Then the null string is returned. Note: this is different from having only a mapping f:string String, which does not distinguish indices not in the array from indices whose cell is empty. Thus, AWK defines for every array <S,f>: f maps every string not in S to the empty string An expression like <S,f>[x] (accessing the cell with index x) has the value f(x), with the side effect S:=S {x} 10 Storage 5

6 Storables Storables: values which can be stored in a single cell and cannot be selectively updated. The atoms of storage. Pascal storables: primitive types sets: cannot be selectively updated pointers Pascal non-storables: Arrays, records and files: can be selectively updated. Procedure and functions: cannot be stored. References: cannot be stored. ML storables: everything except arrays primitive values. records, constructions and lists. functions. references. 11 Lifetime The interval between the creation (allocation) and the deletion (deallocation) of a variable is called its lifetime. Lifetime management is important for economic usage of memory. Kinds of lifetime: Block activation: local variables Programmer s decision: global variables Program activation: heap variables Permanent: persistent variables Just once in a lifetime 12 Storage 6

7 Local and Global Variables Block: Pascal functions and procedures ML s let expressions C s { } She lives in my block, but for me she is global! Block variables: Local: declared within a block to be used only there. Usually, to make the compiler s job easier, declarations are made at the ning of the block, but not always. In C++ declarations can be made anywhere in a block. Global: a local variable declared in the outermost block. Block activation: The time interval during which the block is executed. One local variable name may stand in fact for different variables: Separate definitions in disjoint blocks Several lifetimes - when the block containing it is activated several times Multiple lives - when the block is furthermore activated recursively 13 Static Variables C and PL/I: static variables variables whose lifetime is the whole program execution, independently of their declaration s location. The goal is to allow to store values that are needed in different activations of the same block/module, regardless of the block structure. However, this goal is better achieved with OOP. 14 Storage 7

8 Heap Variables Can be created and deleted at will, using the operations: allocate deallocate Anonymous. I love you heaps! Accessed by pointers: Pointers are first class values. Allow arbitrary directed graphs. Allow modifications that are more radical than selective updating, modifying the actual structure of a variable. No need to be radical. 15 type var Using Heap Variables IntList = ^ IntNode; IntNode = record head: Integer; tail: IntList; end; odds, primes: IntList; function cons (h: Integer; t: IntList): IntList var l: IntList new(l); end;... l^.head := h; l^.tail := t; cons := l; odds := cons(3, cons(5, cons(7, nil))); primes := cons(2, odds); A pointer value is either nil or an address of a variable primes nil odds 16 Storage 8

9 Pointers + Heap Variables = Recursive Types Pointers and heap variables are error-prone: What s p^.tail := q? Which list is selectively updated? Is it only one list which is updated? Did it change a data structure by introducing a cycle? Must use discipline, care and debuggers. Suppose that Pascal had list type: var primes, odds: list of Integer; What is the meaning of: primes := odds? Reference copying: Inconsistent with arrays, records and primitive types. Pointers in disguise. Selective updates to one will affect the other. Data copying: Inefficient, but natural. Possible solutions: prohibit selective update (Lisp), or lazy copying 17 Reference vs. Value Semantics Copying and comparison of pointers have potentially two semantics: Value semantics: the actual values are copied and compared. Deep semantics: the whole network of objects which can be accessed are copied and compared. Shallow semantics: only the first level is copied and compared. Reference semantics: only the references are copied. Comparison: Value semantics: slow, defines ownership relationship between objects, requires run-time type information stored with each composite object (for deep value semantics). Reference semantics: fast, objects could be shared, allows values which are more complicated than what can be captured by algebraic types, no need to store type with objects. 18 Storage 9

10 Value vs. Reference Semantics (cont. d) Value vs. reference semantics in contemporary languages: Value semantics languages: Lisp, ML, Prolog. Reference semantics languages: Java, Smalltalk. Mixed semantics languages: Eiffel, C++. Most languages have some kind of a mix: In Java, primitive types have value semantics. There are hacks in Lisp that allow reference semantics. References in ML allow reference semantics. Lazy copying: an implementation technique of value semantics, where a copy of a large object is made by using a reference. The actual value copy operation is made when (and if) the source or the destination variables are modified. 19 Persistent Variables Lifetime: Transient: lifetime bounded by the activation of the program that created it. Local, Global, Heap variables Other file variables Persistent: lifetime transcends an activation of any particular program. In Pascal persistent variables are program parameters, which cannot be deleted or created by the program. In C and Ada there are standard I/O libraries/packages that deal with files. Files are composite variables: Serial file: a sequence of components. Direct file: an array of components. Access is restricted for efficiency reasons. Pascal examples: Inspect: sequential reading. Update: emptying and sequential write. Assignment: forbidden. 20 Storage 10

11 Using Files as Persistent Variables (Pascal) program POP (st_file); type Country = (DK,GB,...,NL); Statistics = record population: ; end; var stats : array [Country] of Statistics; st_file : file of Statistics; cy : Country; procedure readstats; var cy : Country; reset(st_file); for cy:=dk to NL do read(st_file, stats[cy]); end; readstats;... stats[cy].population... end. 21 Inherent Persistent Variables (hypothetical...) program POP(stats); type Country = (DK,GB,...,NL); Statistics = record population: ; end; var stats : array [Country] of Statistics; (* Removed:st_file: file of Statistics; *) cy : Country; (* Removed: procedure readstats; var cy : Country; reset(st_file); for cy:=dk to NL do read(st_file, stats[cy]); end; *) (* Removed: readstats; *)... stats[cy].population... end. 22 Storage 11

12 Reflection on Persistent Variables Similar to variables: Arbitrary lifetime Nested lifetime on some systems File store is just like the ordinary store model Unlike variables (in Pascal): Transient variables can be of any type, including file Persistent variables must be of type file Type completeness principle requires persistent variables of all types. For instance: Persistent variables of primitive types Persistent array variables = direct files If files were like ordinary variables, then all I/O programming work would be saved. 23 Dangling References Suppose that Pascal was like C... var r: ^Integer; procedure P; var v: Integer; r := &v end; P; r ^:= 1 end; Mixing heap and stack variables. Dangling Reference: an attempt to access a variable which is no longer alive. Pascal prevents this type of dangling reference. 24 Storage 12

13 Function Variables and Dangling References Suppose that Pascal had function variables... var fv: Integer -> Char; procedure P; var v:...; function f(n: Integer): Char;...v... end; fv := &f end P;... fv(0)... end; This is one of the reasons why C doesn t have nested functions. 25 More on Dangling References Another form of the previous problem occurs with a function returning a procedure variable. Above problems can be solved by: Algol-68: a reference to a local variable cannot be assigned to a variable with a longer lifetime: Run time check. Can you explain why? Awkward restrictions on programmer. Heap variables: reference to a variable which was deallocated: Elimination of dispose Garbage collection The ultimate solution: treat all variables as heap variables: All functional languages, Prolog. Inefficient. 26 Storage 13

14 Garbage Collection With pointers, memory management becomes quite complicated, and errors of two kinds often occur: Memory leaks: unused memory that is not deallocated. Dangling references: access to variables which are no longer alive. Garbage collection: automatic management of memory. User never deallocates memory. When memory becomes scarce, a garbage collection procedure is applied to collect all unused memory locations Mark and sweep: the simplest mechanism for collecting unused memory cells. Mark: mark all cells as unused. Sweep: unmark all cells in use (stack, global variables), and cells which can be accessed from these. Release: all cells which remain marked. 27 Inefficiency of Garbage Collection In a garbage collecting system, there are no stack variables. It is unsafe to deallocate automatic variables. The following code may slow the Java language processor (which provides garbage collecting) down to a halt, whereas it would be a snap in C/C++. void f() { data a[10000]; } for (i = 0; i < 10000; i++) f(); Escape analysis: an active area of research in Java. Try to determine for each automatic variable if it can escape a function, and if not, treat it like a stack variable. 28 Storage 14

15 Memory Leaks and Garbage Collection? Memory leaks: usually happen in a non-garbage collecting system, when a programmer forgets to deallocate memory. Garbage collecting systems rely on the programmer to nullify pointers so that the system would know that they are unused. If the programmer forgets to assign nil to pointers, then the memory is held even though it is not used. Common problem in Java programming! 29 Storage 15

Storage. Outline. Variables and updating. Copy vs. Ref semantics Lifetime. Dangling References Garbage collection

Storage 1 Variables and updating Outline Copy vs. Ref semantics Lifetime Local and global variables Heap variables Persistent variables Dangling References Garbage collection 2 Variables and Updating Variable:

CS 330 Lecture 18. Symbol table. C scope rules. Declarations. Chapter 5 Louden Outline

CS 0 Lecture 8 Chapter 5 Louden Outline The symbol table Static scoping vs dynamic scoping Symbol table Dictionary associates names to attributes In general: hash tables, tree and lists (assignment ) can

CS321 Languages and Compiler Design I Winter 2012 Lecture 13

STATIC SEMANTICS Static Semantics are those aspects of a program s meaning that can be studied at at compile time (i.e., without running the program). Contrasts with Dynamic Semantics, which describe how

Programmin Languages/Variables and Storage

Programmin Languages/Variables and Storage Onur Tolga Şehitoğlu Computer Engineering 4 Mart 2007 Outline 1 Storage Array Variables 2 Semantics of Assignment 3 Variable Lifetime Global Lifetime Local Lifetime

Types II. Hwansoo Han

Types II Hwansoo Han Arrays Most common and important composite data types Homogeneous elements, unlike records Fortran77 requires element type be scalar Elements can be any type (Fortran90, etc.) A mapping

Chapter 5. Names, Bindings, and Scopes

Chapter 5 Names, Bindings, and Scopes Chapter 5 Topics Introduction Names Variables The Concept of Binding Scope Scope and Lifetime Referencing Environments Named Constants 1-2 Introduction Imperative

CSC 533: Organization of Programming Languages. Spring 2005

CSC 533: Organization of Programming Languages Spring 2005 Language features and issues variables & bindings data types primitive complex/structured expressions & assignments control structures subprograms

G Programming Languages - Fall 2012

G22.2110-003 Programming Languages - Fall 2012 Lecture 4 Thomas Wies New York University Review Last week Control Structures Selection Loops Adding Invariants Outline Subprograms Calling Sequences Parameter

Compiler Construction

Compiler Construction Thomas Noll Software Modeling and Verification Group RWTH Aachen University https://moves.rwth-aachen.de/teaching/ss-16/cc/ Recap: Static Data Structures Outline of Lecture 18 Recap:

CA341 - Comparative Programming Languages

CA341 - Comparative Programming Languages and David Sinclair Data, Values and Types In 1976 Niklaus Wirth (inventor of Pascal, Modula, Oberon, etc) wrote a book called Algorithms + Data Structures = Programs

Chapter 8 :: Composite Types

Chapter 8 :: Composite Types Programming Language Pragmatics, Fourth Edition Michael L. Scott Copyright 2016 Elsevier 1 Chapter08_Composite_Types_4e - Tue November 21, 2017 Records (Structures) and Variants

Example: Haskell algebraic data types (1)

Example: Haskell algebraic data types (1) Type declaration: data Number = Exact Int Inexact Float Set of values: Each Number value consists of a tag, together with either an Integer variant (if the tag

Compiler Construction

Compiler Construction Lecture 18: Code Generation V (Implementation of Dynamic Data Structures) Thomas Noll Lehrstuhl für Informatik 2 (Software Modeling and Verification) noll@cs.rwth-aachen.de http://moves.rwth-aachen.de/teaching/ss-14/cc14/

CMSC 330: Organization of Programming Languages

CMSC 330: Organization of Programming Languages Memory Management and Garbage Collection CMSC 330 Spring 2017 1 Memory Attributes Memory to store data in programming languages has the following lifecycle

CMSC 330: Organization of Programming Languages

CMSC 330: Organization of Programming Languages Memory Management and Garbage Collection CMSC 330 - Spring 2013 1 Memory Attributes! Memory to store data in programming languages has the following lifecycle

Fifth Generation CS 4100 LISP. What do we need? Example LISP Program 11/13/13. Chapter 9: List Processing: LISP. Central Idea: Function Application

Fifth Generation CS 4100 LISP From Principles of Programming Languages: Design, Evaluation, and Implementation (Third Edition, by Bruce J. MacLennan, Chapters 9, 10, 11, and based on slides by Istvan Jonyer

Concepts Introduced in Chapter 7

Concepts Introduced in Chapter 7 Storage Allocation Strategies Static Stack Heap Activation Records Access to Nonlocal Names Access links followed by Fig. 7.1 EECS 665 Compiler Construction 1 Activation

Example. program sort; var a : array[0..10] of integer; procedure readarray; : function partition (y, z :integer) :integer; var i, j,x, v :integer; :

Runtime Environment Relationship between names and data objects (of target machine) Allocation & de-allocation is managed by run time support package Each execution of a procedure is an activation of the

Design Issues. Subroutines and Control Abstraction. Subroutines and Control Abstraction. CSC 4101: Programming Languages 1. Textbook, Chapter 8

Subroutines and Control Abstraction Textbook, Chapter 8 1 Subroutines and Control Abstraction Mechanisms for process abstraction Single entry (except FORTRAN, PL/I) Caller is suspended Control returns

CMSC 330: Organization of Programming Languages. Memory Management and Garbage Collection

CMSC 330: Organization of Programming Languages Memory Management and Garbage Collection CMSC330 Fall 2018 1 Memory Attributes Memory to store data in programming languages has the following lifecycle

G Programming Languages - Fall 2012

G22.2110-003 Programming Languages - Fall 2012 Lecture 2 Thomas Wies New York University Review Last week Programming Languages Overview Syntax and Semantics Grammars and Regular Expressions High-level

Programming Languages Third Edition. Chapter 7 Basic Semantics

Programming Languages Third Edition Chapter 7 Basic Semantics Objectives Understand attributes, binding, and semantic functions Understand declarations, blocks, and scope Learn how to construct a symbol

Chapter 5 Names, Binding, Type Checking and Scopes

Chapter 5 Names, Binding, Type Checking and Scopes Names - We discuss all user-defined names here - Design issues for names: -Maximum length? - Are connector characters allowed? - Are names case sensitive?

Programming Languages, Summary CSC419; Odelia Schwartz

Programming Languages, Summary CSC419; Odelia Schwartz Chapter 1 Topics Reasons for Studying Concepts of Programming Languages Programming Domains Language Evaluation Criteria Influences on Language Design

Lecture 13: Complex Types and Garbage Collection

Lecture 13: Complex Types and Garbage Collection COMP 524 Programming Language Concepts Stephen Olivier March 17, 2009 Based on slides by A. Block, notes by N. Fisher, F. Hernandez-Campos, and D. Stotts

22c:111 Programming Language Concepts. Fall Types I

22c:111 Programming Language Concepts Fall 2008 Types I Copyright 2007-08, The McGraw-Hill Company and Cesare Tinelli. These notes were originally developed by Allen Tucker, Robert Noonan and modified

Data Types (cont.) Subset. subtype in Ada. Powerset. set of in Pascal. implementations. CSE 3302 Programming Languages 10/1/2007

CSE 3302 Programming Languages Data Types (cont.) Chengkai Li Fall 2007 Subset U = { v v satisfies certain conditions and v V} Ada subtype Example 1 type Digit_Type is range 0..9; subtype IntDigit_Type

Programming Languages

Programming Languages Tevfik Koşar Lecture - XVIII March 23 rd, 2006 1 Roadmap Arrays Pointers Lists Files and I/O 2 1 Arrays Two layout strategies for arrays Contiguous elements Row pointers Row pointers

Data Types. (with Examples In Haskell) COMP 524: Programming Languages Srinivas Krishnan March 22, 2011

Data Types (with Examples In Haskell) COMP 524: Programming Languages Srinivas Krishnan March 22, 2011 Based in part on slides and notes by Bjoern 1 Brandenburg, S. Olivier and A. Block. 1 Data Types Hardware-level:

SE352b Software Engineering Design Tools W3: Programming Paradigms Feb. 3, 2005 SE352b, ECE,UWO, Hamada Ghenniwa SE352b: Roadmap CASE Tools: Introduction System Programming Tools Programming Paradigms

Imperative Programming

Naming, scoping, binding, etc. Instructor: Dr. B. Cheng Fall 2004 1 Imperative Programming The central feature of imperative languages are variables Variables are abstractions for memory cells in a Von

CMSC 331 Final Exam Section 0201 December 18, 2000

CMSC 331 Final Exam Section 0201 December 18, 2000 Name: Student ID#: You will have two hours to complete this closed book exam. We reserve the right to assign partial credit, and to deduct points for

Programming Languages Third Edition. Chapter 10 Control II Procedures and Environments

Programming Languages Third Edition Chapter 10 Control II Procedures and Environments Objectives Understand the nature of procedure definition and activation Understand procedure semantics Learn parameter-passing

Questions? Static Semantics. Static Semantics. Static Semantics. Next week on Wednesday (5 th of October) no

Questions? First exercise is online: http://www.win.tue.nl/~mvdbrand/courses/glt/1112/ Deadline 17 th of October Next week on Wednesday (5 th of October) no lectures!!! Primitive types Primitive value

Principles of Programming Languages

Principles of Programming Languages h"p://www.di.unipi.it/~andrea/dida2ca/plp- 14/ Prof. Andrea Corradini Department of Computer Science, Pisa Lesson 23! Type systems Type safety Type checking Equivalence,

Weeks 6&7: Procedures and Parameter Passing

CS320 Principles of Programming Languages Weeks 6&7: Procedures and Parameter Passing Jingke Li Portland State University Fall 2017 PSU CS320 Fall 17 Weeks 6&7: Procedures and Parameter Passing 1 / 45

4 Bindings and Scope. Bindings and environments. Scope, block structure, and visibility. Declarations. Blocks. 2004, D.A. Watt, University of Glasgow

4 Bindings and Scope Bindings and environments. Scope, block structure, and visibility. Declarations. Blocks. 2004, D.A. Watt, University of Glasgow 1 Bindings and environments PL expressions and commands

Data Types. Outline. In Text: Chapter 6. What is a type? Primitives Strings Ordinals Arrays Records Sets Pointers 5-1. Chapter 6: Data Types 2

Data Types In Text: Chapter 6 1 Outline What is a type? Primitives Strings Ordinals Arrays Records Sets Pointers Chapter 6: Data Types 2 5-1 Data Types Two components: Set of objects in the type (domain

Attributes, Bindings, and Semantic Functions Declarations, Blocks, Scope, and the Symbol Table Name Resolution and Overloading Allocation, Lifetimes,

Chapter 5 Basic Semantics Attributes, Bindings, and Semantic Functions Declarations, Blocks, Scope, and the Symbol Table Name Resolution and Overloading Allocation, Lifetimes, and the Environment Variables

CS558 Programming Languages

CS558 Programming Languages Winter 2017 Lecture 7b Andrew Tolmach Portland State University 1994-2017 Values and Types We divide the universe of values according to types A type is a set of values and

Name, Scope, and Binding. Outline [1]

Name, Scope, and Binding In Text: Chapter 3 Outline [1] Variable Binding Storage bindings and lifetime Type bindings Type Checking Scope Lifetime vs. Scope Referencing Environments N. Meng, S. Arthur 2

6. Names, Scopes, and Bindings

Copyright (C) R.A. van Engelen, FSU Department of Computer Science, 2000-2004 6. Names, Scopes, and Bindings Overview Names Binding time Object lifetime Object storage management Static allocation Stack

Types and Type Inference

CS 242 2012 Types and Type Inference Notes modified from John Mitchell and Kathleen Fisher Reading: Concepts in Programming Languages, Revised Chapter 6 - handout on Web!! Outline General discussion of

Principles of Programming Languages Topic: Scope and Memory Professor Louis Steinberg Fall 2004

Principles of Programming Languages Topic: Scope and Memory Professor Louis Steinberg Fall 2004 CS 314, LS,BR,LTM: Scope and Memory 1 Review Functions as first-class objects What can you do with an integer?

Run-time Environments

Run-time Environments Status We have so far covered the front-end phases Lexical analysis Parsing Semantic analysis Next come the back-end phases Code generation Optimization Register allocation Instruction

Run-time Environments

Run-time Environments Status We have so far covered the front-end phases Lexical analysis Parsing Semantic analysis Next come the back-end phases Code generation Optimization Register allocation Instruction

CPS 506 Comparative Programming Languages. Programming Language

CPS 506 Comparative Programming Languages Object-Oriented Oriented Programming Language Paradigm Introduction Topics Object-Oriented Programming Design Issues for Object-Oriented Oriented Languages Support

G Programming Languages Spring 2010 Lecture 4. Robert Grimm, New York University

G22.2110-001 Programming Languages Spring 2010 Lecture 4 Robert Grimm, New York University 1 Review Last week Control Structures Selection Loops 2 Outline Subprograms Calling Sequences Parameter Passing

CPSC 3740 Programming Languages University of Lethbridge. Data Types

Data Types A data type defines a collection of data values and a set of predefined operations on those values Some languages allow user to define additional types Useful for error detection through type

CS558 Programming Languages

CS558 Programming Languages Fall 2017 Lecture 3a Andrew Tolmach Portland State University 1994-2017 Binding, Scope, Storage Part of being a high-level language is letting the programmer name things: variables

1. true / false By a compiler we mean a program that translates to code that will run natively on some machine.

1. true / false By a compiler we mean a program that translates to code that will run natively on some machine. 2. true / false ML can be compiled. 3. true / false FORTRAN can reasonably be considered

Heap, Variables, References, and Garbage. CS152. Chris Pollett. Oct. 13, 2008.

Heap, Variables, References, and Garbage. CS152. Chris Pollett. Oct. 13, 2008. Outline. Dynamic Allocation. Variables and Constants. Aliases and Problems. Garbage. Introduction. On Wednesday, we were talking

CS558 Programming Languages

CS558 Programming Languages Winter 2017 Lecture 4a Andrew Tolmach Portland State University 1994-2017 Semantics and Erroneous Programs Important part of language specification is distinguishing valid from

Answer: Early binding generally leads to greater efficiency (compilation approach) Late binding general leads to greater flexibility

Quiz Review Q1. What is the advantage of binding things as early as possible? Is there any advantage to delaying binding? Answer: Early binding generally leads to greater efficiency (compilation approach)

CS321 Languages and Compiler Design I. Fall 2013 Week 8: Types Andrew Tolmach Portland State University

CS321 Languages and Compiler Design I Fall 2013 Week 8: Types Andrew Tolmach Portland State University 1 THE TYPE ZOO int x = 17 Z[1023] := 99; double e = 2.81828 type emp = {name: string, age: int} class

SEMANTIC ANALYSIS TYPES AND DECLARATIONS

SEMANTIC ANALYSIS CS 403: Type Checking Stefan D. Bruda Winter 2015 Parsing only verifies that the program consists of tokens arranged in a syntactically valid combination now we move to check whether

Data Types In Text: Ch C apter 6 1

Data Types In Text: Chapter 6 1 Outline What is a type? Primitives Strings Ordinals Arrays Records Sets Pointers 2 Data Types Two components: Set of objects in the type (domain of values) Set of applicable

The role of semantic analysis in a compiler

Semantic Analysis Outline The role of semantic analysis in a compiler A laundry list of tasks Scope Static vs. Dynamic scoping Implementation: symbol tables Types Static analyses that detect type errors

Programming Languages

Programming Languages Types CSCI-GA.2110-001 Summer 2011 What is a type? A type consists of a set of values The compiler/interpreter defines a mapping of these values onto the underlying hardware. 2 /

Types. Chapter Six Modern Programming Languages, 2nd ed. 1

Types Chapter Six Modern Programming Languages, 2nd ed. 1 A Type Is A Set int n; When you declare that a variable has a certain type, you are saying that the values the variable can have are elements of

CS558 Programming Languages

CS558 Programming Languages Fall 2016 Lecture 3a Andrew Tolmach Portland State University 1994-2016 Formal Semantics Goal: rigorous and unambiguous definition in terms of a wellunderstood formalism (e.g.

Lecture 6 Introduction to Objects and Classes

Lecture 6 Introduction to Objects and Classes Outline Basic concepts Recap Computer programs Programming languages Programming paradigms Object oriented paradigm-objects and classes in Java Constructors

Structure of Programming Languages Lecture 10

Structure of Programming Languages Lecture 10 CS 6636 4536 Spring 2017 CS 6636 4536 Lecture 10: Classes... 1/23 Spring 2017 1 / 23 Outline 1 1. Types Type Coercion and Conversion Type Classes, Generics,

Thanks! Review. Course Goals. General Themes in this Course. There are many programming languages. Teaching Assistants. John Mitchell.

1 CS 242 Thanks! Review John Mitchell Final Exam Wednesday Dec 8 8:30 11:30 AM Gates B01, B03 Teaching Assistants Mike Cammarano TJ Giuli Hendra Tjahayadi Graders Andrew Adams Kenny Lau Vishal Patel and

INITIALISING POINTER VARIABLES; DYNAMIC VARIABLES; OPERATIONS ON POINTERS

INITIALISING POINTER VARIABLES; DYNAMIC VARIABLES; OPERATIONS ON POINTERS Pages 792 to 800 Anna Rakitianskaia, University of Pretoria INITIALISING POINTER VARIABLES Pointer variables are declared by putting

Memory Allocation. Static Allocation. Dynamic Allocation. Dynamic Storage Allocation. CS 414: Operating Systems Spring 2008

Dynamic Storage Allocation CS 44: Operating Systems Spring 2 Memory Allocation Static Allocation (fixed in size) Sometimes we create data structures that are fixed and don t need to grow or shrink. Dynamic

Types and Type Inference

Types and Type Inference Mooly Sagiv Slides by Kathleen Fisher and John Mitchell Reading: Concepts in Programming Languages, Revised Chapter 6 - handout on the course homepage Outline General discussion

DATA TYPES. CS 403: Types and Classes DATA TYPES (CONT D)

DATA TYPES CS 403: Types and Classes Stefan D. Bruda Fall 2017 Algorithms + data structures = programs Abstractions of data entities highly desirable Program semantics embedded in data types Data types

Semantic Analysis. Outline. The role of semantic analysis in a compiler. Scope. Types. Where we are. The Compiler Front-End

Outline Semantic Analysis The role of semantic analysis in a compiler A laundry list of tasks Scope Static vs. Dynamic scoping Implementation: symbol tables Types Static analyses that detect type errors

Lecture 14. No in-class files today. Homework 7 (due on Wednesday) and Project 3 (due in 10 days) posted. Questions?

Lecture 14 No in-class files today. Homework 7 (due on Wednesday) and Project 3 (due in 10 days) posted. Questions? Friday, February 11 CS 215 Fundamentals of Programming II - Lecture 14 1 Outline Static

Note 3. Types. Yunheung Paek. Associate Professor Software Optimizations and Restructuring Lab. Seoul National University

Note 3 Types Yunheung Paek Associate Professor Software Optimizations and Restructuring Lab. Seoul National University Topics Definition of a type Kinds of types Issues on types Type checking Type conversion

Organization of Programming Languages CS320/520N. Lecture 06. Razvan C. Bunescu School of Electrical Engineering and Computer Science

Organization of Programming Languages CS320/520N Razvan C. Bunescu School of Electrical Engineering and Computer Science bunescu@ohio.edu Data Types A data type defines a collection of data objects and

G Programming Languages Spring 2010 Lecture 6. Robert Grimm, New York University

G22.2110-001 Programming Languages Spring 2010 Lecture 6 Robert Grimm, New York University 1 Review Last week Function Languages Lambda Calculus SCHEME review 2 Outline Promises, promises, promises Types,

Lecture 13: Object orientation. Object oriented programming. Introduction. Object oriented programming. OO and ADT:s. Introduction

Lecture 13: Object orientation Object oriented programming Introduction, types of OO languages Key concepts: Encapsulation, Inheritance, Dynamic binding & polymorphism Other design issues Smalltalk OO

Tail Calls. CMSC 330: Organization of Programming Languages. Tail Recursion. Tail Recursion (cont d) Names and Binding. Tail Recursion (cont d)

CMSC 330: Organization of Programming Languages Tail Calls A tail call is a function call that is the last thing a function does before it returns let add x y = x + y let f z = add z z (* tail call *)

Scope. Chapter Ten Modern Programming Languages 1

Scope Chapter Ten Modern Programming Languages 1 Reusing Names Scope is trivial if you have a unique name for everything: fun square a = a * a; fun double b = b + b; But in modern languages, we often use

Chapter 11. Categories of languages that support OOP: 1. OOP support is added to an existing language

Categories of languages that support OOP: 1. OOP support is added to an existing language - C++ (also supports procedural and dataoriented programming) - Ada 95 (also supports procedural and dataoriented

Types. What is a type?

Types What is a type? Type checking Type conversion Aggregates: strings, arrays, structures Enumeration types Subtypes Types, CS314 Fall 01 BGRyder 1 What is a type? A set of values and the valid operations

HANDLING NONLOCAL REFERENCES

SYMBOL TABLE A symbol table is a data structure kept by a translator that allows it to keep track of each declared name and its binding. Assume for now that each name is unique within its local scope.

Informatica 3 Syntax and Semantics

Informatica 3 Syntax and Semantics Marcello Restelli 9/15/07 Laurea in Ingegneria Informatica Politecnico di Milano Introduction Introduction to the concepts of syntax and semantics Binding Variables Routines

Test 1 Summer 2014 Multiple Choice. Write your answer to the LEFT of each problem. 5 points each 1. Preprocessor macros are associated with: A. C B.

CSE 3302 Test 1 1. Preprocessor macros are associated with: A. C B. Java C. JavaScript D. Pascal 2. (define x (lambda (y z) (+ y z))) is an example of: A. Applying an anonymous function B. Defining a function

Semantic Analysis. Outline. The role of semantic analysis in a compiler. Scope. Types. Where we are. The Compiler so far

Outline Semantic Analysis The role of semantic analysis in a compiler A laundry list of tasks Scope Static vs. Dynamic scoping Implementation: symbol tables Types Statically vs. Dynamically typed languages

Lecture Overview. [Scott, chapter 7] [Sebesta, chapter 6]

1 Lecture Overview Types 1. Type systems 2. How to think about types 3. The classification of types 4. Type equivalence structural equivalence name equivalence 5. Type compatibility 6. Type inference [Scott,

CS 314 Principles of Programming Languages

CS 314 Principles of Programming Languages Lecture 15: Review and Functional Programming Zheng (Eddy) Zhang Rutgers University March 19, 2018 Class Information Midterm exam forum open in Sakai. HW4 and

Heap storage. Dynamic allocation and stacks are generally incompatible.

Heap storage Dynamic allocation and stacks are generally incompatible. 1 Stack and heap location Pointer X points to stack storage in procedure Q's activation record that no longer is live (exists) when

CITS3211 FUNCTIONAL PROGRAMMING. 14. Graph reduction

CITS3211 FUNCTIONAL PROGRAMMING 14. Graph reduction Summary: This lecture discusses graph reduction, which is the basis of the most common compilation technique for lazy functional languages. CITS3211

Heap Management. Heap Allocation

Heap Management Heap Allocation A very flexible storage allocation mechanism is heap allocation. Any number of data objects can be allocated and freed in a memory pool, called a heap. Heap allocation is

CSE 307: Principles of Programming Languages

CSE 307: Principles of Programming Languages Variables and Constants R. Sekar 1 / 22 Topics 2 / 22 Variables and Constants Variables are stored in memory, whereas constants need not be. Value of variables

Functions in C C Programming and Software Tools

Functions in C C Programming and Software Tools N.C. State Department of Computer Science Functions in C Functions are also called subroutines or procedures One part of a program calls (or invokes the

Names and Abstractions: What s in a Name?

Copyright R.A. van Engelen, FSU Department of Computer Science, 2000 Names, Scopes, and Bindings Binding time Object lifetime Object storage management Static allocation Stack allocation Heap allocation

St. MARTIN S ENGINEERING COLLEGE Dhulapally, Secunderabad

St. MARTIN S ENGINEERING COLLEGE Dhulapally, Secunderabad-00 014 Subject: PPL Class : CSE III 1 P a g e DEPARTMENT COMPUTER SCIENCE AND ENGINEERING S No QUESTION Blooms Course taxonomy level Outcomes UNIT-I

Names, Bindings, Scopes

Names, Bindings, Scopes Variables In imperative l Language: abstractions of von Neumann machine Variables: abstraction of memory cell or cells Sometimes close to machine (e.g., integers), sometimes not

Data Types. CSE 307 Principles of Programming Languages Stony Brook University

Data Types CSE 307 Principles of Programming Languages Stony Brook University http://www.cs.stonybrook.edu/~cse307 1 Data Types We all have developed an intuitive notion of what types are; what's behind

COP4020 Programming Languages. Names, Scopes, and Bindings Prof. Robert van Engelen

COP4020 Programming Languages Names, Scopes, and Bindings Prof. Robert van Engelen Overview Abstractions and names Binding time Object lifetime Object storage management Static allocation Stack allocation

Course Overview. Arrays. Static Arrays. Static Arrays. Static Arrays with different lower bound. Static Arrays. PART I: overview material

PART I: overview material Course Overview Introduction Language processors (tombstone diagrams, bootstrapping) Architecture of a compiler PART II: inside a compiler Syntax analysis Contextual analysis

CS 241 Honors Memory

CS 241 Honors Memory Ben Kurtovic Atul Sandur Bhuvan Venkatesh Brian Zhou Kevin Hong University of Illinois Urbana Champaign February 20, 2018 CS 241 Course Staff (UIUC) Memory February 20, 2018 1 / 35

CS 430 Spring Mike Lam, Professor. Data Types and Type Checking

CS 430 Spring 2015 Mike Lam, Professor Data Types and Type Checking Type Systems Type system Rules about valid types, type compatibility, and how data values can be used Benefits of a robust type system