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

Size: px
Start display at page:

Transcription

1 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) Late binding general leads to greater flexibility Q2. For the following grammar: S a S b c E E d f E a (1) Circle the strings that can be generated by the grammar and cross out those that cannot: cfda (T) acfab (F) aacdbb (T) aacfdab (F) (2) The grammar is ambiguous. True or false (circle one) False 1

2 Q3. a. Using grammar G, draw a parse tree (also known as a derivation tree) for the following sentence: ( ( a. b ) c ( d ) ( ( ) ) ) In this parse tree, the root node is labelled S; leaf nodes are labelled with terminal symbols. 2

3 3

4 b. Write down a rightmost derivation for the sentence given in part (a). Hints: In a derivation, the first line is the goal symbol and the last line is the sentence; the derivation is rightmost if the rightmost nonterminal symbol is expanded at each step. 4

5 Q4. Do a top down leftmost derivation of the following string given the grammar listed below: a = b * (c + a) Is the grammar from above ambiguous or not? Why or why not? Yes. An expression such as: a + b * c can generate two different parse trees. 5

6 Q5. LR parser How a string like "1 + 1" would be parsed by LR parser. Grammar: (1) E E * B (2) E E + B (3) E B (4) B 0 (5) B 1 6

7 Stack Input Action 0 1+1\$ Shift \$ Reduce 5 (Use GOTO[0, B]) 0 B \$ Reduce 3 (Use GOTO[0, E]) 0 E \$ Shift 6 0 E \$ Shift 2 0 E \$ Reduce 5 (Use GOTO[6, B]) 0 E B 8 \$ Reduce 2 (Use GOTO[0, E]) 0E3 \$ Accept 7

8 Type Checking The process of checking that for each operation, the types of its operands are appropriate, i.e. the operation is legal for these types. In all programming languages, every value has a certain type, and the compiler and/or the runtime system knows what the type is. Static versus Dynamic Type-Checking Static type-checking: type-checking done by the compiler, before executing the program. int i; int j; i = j; 8

9 Java and C# are Strongly Typed = the compiler checks that every assignment and every method call is type correct. public class Num { // class providing useful numeric routines public static int gcd (int n, int d) { while (n!= d) if (n > d) n = n - d; else d = d - n; return n; int y = 7, z = 3; int x =Num.gcd (z,y); C and C++ are not strongly typed language because both include union types, which are not type checked. 9

10 Type checking is the activity of ensuring that the operands of an operator are of compatible types. A compatible type is one that is either legal for the operator, or is allowed under language rules to be implicitly converted, by compiler- generated code, to a legal type. int i; double c = i; Object o1 = new Car(); This automatic conversion is called a coercion. A type error is the application of an operator to an operand of an inappropriate type 10

11 The advantages of static type-checking Potential errors can be identified earlier. More care is needed in the program design and implementations can take advantage of the additional information to produce more efficient programs with less runtime checking code. The penalty of static checking is reduced programmer flexibility. Dynamic type-checking: type-checking done while executing the program. Shape s = new Circle(); Shape s = new Triangle(); Shape s = new Line(); Shape s = new Circle(); s.draw(); Shape s = new Line(); s.draw(); Dynamic type checking gives more freedom and flexibility to the programmer. At run-time, type-checking can know the actual values of variables, not just their initial value or declared type. This flexibilty is at the cost that type checking errors now occur unpredictably at run-time. All languages combine run-time and compiletime type-checking (Java, etc.) Some languages, such as JavaScript and PHP, allow only dynamic type checking. 11

12 Scope: The range of statements over which it is visible Local variable Declared in the same program subunit (program, subprogram, function, etc.) in which it is used. Nonlocal variable (static-scoped language. Such as Ada.) A variable not declared in the same program subunit in which it is used, but not available to every subunit in the program. Global variable A variable not declared in the same program subunit in which it is used, and available to every subunit in the program. void foo (int x) { // begin scope of x int y; // begin scope of y... y=0; // end scope of x and y 12

13 In most block-structured languages, the scope of a name is its enclosing block. void foo (int x) { // begin scope of x if (x == 0) { // begin scope of y int y = 0;... // end scope of y... for (int z=0; // begin scope of z z<5; z++) {... // end scope of z... // end scope of x 13

14 Static Scope versus Dynamic Scope Static Scope: the scope of a variable can be statically determined prior to execution. Called static scoping. (Introduced by ALGOL 60) Two categories of Static-scoped language: (1) Subprograms can be nested, which created nested static scope, (Ada, JavaScript, and PHP) (2) Subprograms cannot be nested (C-based languages). (3) We focus on languages that allow nested subprograms. 14

15 To connect a name reference to a variable, you must find the declaration. Consider the following Ada procedure procedure Big is X: Integer; Search process: search declarations, first locally, procedure Sub1 is then in increasingly larger enclosing scopes, until begin one is found for the given name.. X.. Enclosing static scopes (to a specific scope) are end; procedure Sub2 is called its static ancestors; the nearest static X : Integer; ancestor is called a static parent Begin end; Static Scope is associated with the static text of begin --- of Big program.. Can determine scope by looking at structure of End --- of Big program rather than execution path telling how got there. 15

16 Variables can be hidden from a unit by having a "closer" variable with the same name C++ and Ada allow access to these "hidden" variables In Ada: unit.name X declared in Big can be accessed in Sub2 by the reference Big.X In C++: using scope operator (::) ::name #include < iostream > void func(); int i = 5; int j = 3; float f = 10.0; int main() { int j = 7; cout << "i in main: " << i << endl; cout << "j in main: " << j << endl; cout << "global j: " << ::j << endl; func(); return 0; void func() { float f = 20.0; cout << "f in func: " << f << endl; cout << "global f: " << ::f << endl; 16

17 Blocks A method of creating static scopes inside program units--from ALGOL 60 Examples: C and C++: for (...) { int index;... Ada: declare LCL : FLOAT; begin... end The scope created by blocks are treated exactly like those created by subprograms. Reference to variables in a block that are not declared there are connected to declarations by searching enclosing scopes in order of increasing size. 17

18 C++ allow variables definition to appear anywhere in function. When a definition appears at a position other than at the beginning of a function, that variable s scope is from its definition statement to the end of function. In C, all data declarations in a function must appear at the beginning of the function. The for statement of C++, Java and C# allow variable definition in their initialization expression. The scope is restricted to the for construct, as the case with Java and C#. The classes of C++, Java and C# treat their instance variable differently from the variable defined in their methods. The scope of a variable defined in a method start at the definition. However, regardless of where a variable is defined in a class, its scope is the whole class 18

19 Dynamic Scope Based on calling sequences of program units References to variables are connected to declarations by searching back through the chain of subprogram calls that forced execution to this point MAIN - declaration of x SUB1 - declaration of x -... call SUB2... SUB reference to x call SUB1 MAIN calls SUB1 SUB1 calls SUB2 SUB2 uses x Dynamic Scope is associated with the execution path of program. LISP and APL use dynamic scoping Scope Example Static scoping Reference to x of SUB2 is to MAIN's x Dynamic scoping Reference to x of SUB2 is to SUB1's x Evaluation of Dynamic Scoping: Advantage: convenience Disadvantage: poor readability 19

20 program... var A : integer; procedure Y(...); begin end; {Y procedure Z(...);...; B := A + B;... var A: integer; begin end; {Z begin {main...; Z(...);......; Y(...);... end. Question: Which variable with name A is used when Y is called from Z? In static, clearly globally defined A. In dynamic, local A in Z (since declaration of A in Z is most recent). 20

21 Variable categories by lifetime and memory location: 1. static variables 2. stack-dynamic variables 3. heap-dynamic variables 21

22 #include <iostream.h> void showstat( int curr ) { static int nstatic=0; // Value of nstatic is retained between each function call nstatic += curr; cout << "nstatic is " << nstatic << endl; void main() { for ( int i = 0; i < 5; i++ ) showstat( i ); Java: public class Counter { public static int count=0; public Counter (){ public static void counting_function(){ System.out.println("count = " + ++count); public static void main (String[] args) { counting_function(); // 1 counting_function(); // 2 counting_function(); // 3 counting_function(); // 4 counting_function(); // 5 22

23 Imagine you wanted to count how many Duck instances are being created while your program is running. Non-static variable: class Duck { int duckcount = 0; public Duck() { duckcount++; Static variable: public class Duck { private int size; private static int duckcount = 0; public Duck () { duckcount++; Programming Language Support: C, C++, Java: include the "static" specifier on a local variable definition. FORTRAN I, II, IV: all variables static. Pascal: no support. - Static variable is a class variable, rather than an instance variable. 23

24 24

25 In most current programming languages, the formal parameters and local variables of subroutines (functions, methods) are stack-dynamic variables. int foo (int a, int b) { int x = 4; a = a + bar(b); return x + a + b; 25

26 Heap-dynamic variables nameless variables allocated on the heap for dynamic data structures or for instances of objects in OO programming languages. 26

27 In Java or C++, heap-dynamic variables are allocated by the new operator. Car c = new Car(); In C, the allocation operator is the function malloc(size), #include <stdlib.h> /* Allocate space for an array with 10 elements of type int */ int *ptr = (int *) malloc ( sizeof(int) * 10 ); if (ptr == NULL) exit(1); /* We could not allocate any memory, so exit */ Memory allocated via malloc is persistent: it will continue to exist until the program terminates or the memory is deallocated by the programmer. void free(ptr) 27

28 dynamic objects in C++ (via new and delete), int *intnode;... intnode = new int;... delete intnode; Heap-Dynamic Variables Advantage: high flexibility, convenient to implement data structures, such as liked list and trees. Disadvantage: (1) difficult to use pointer and reference correctly. (2) low reliability, complexity of storage management implementation. - Solutions in Java: - remove pointers (only use references) - array bound checking - garbage collection 28

29 Referencing Environments referencing environment of a statement is the collection of all names that are visible in the statement In a static-scoped language, it is the local variables plus all of the visible variables in all of the enclosing scopes procedure Example is A, B, : Integer;... procedure Sub1 is X, Y : Integer; begin -- Sub1... <============ 1 end; procedure Sub2 is X : Integer;... procedure Sub3 is X : Integer; begin - Sub3... <============= 2 end; Point begin -- Sub2... <============= 3 end; begin -- Example... <============= 4 endl; Referencing Environment 29

30 In a dynamic-scoped language, the referencing environment is the local variables plus all visible variables in all active subprograms A subprogram is active if its execution has begun but has not yet terminated void sub1() { int a, b; 1 / * end of sub1 */ void sub2() { int b, c; 2 sub1; /* end of sub2 */ void main() { int c, d;. 3 sub2(); /* end of main */ The reference environments of the indicated program points are as follows: Point Referencing Environment 1. a and b of sub1, c of sub2, d of main, (c of main and b of sub2 are hidden) 2. b and c of sub2, d of main, (c of main is hidden) 3. c and d of main 30

31 Named Constants a variable that is bound to a value only once when it is bound to storage Advantages: readability can be improved, for example, by using pi instead of Used to parameterize programs void example(){ int [] intlist = new int[100];. for (index = 0; index<100; index++){ for (index = 0; index<100; index++){. Average=sum/100; void example(){ final int len =100; int [] intlist = new int[len];. for (index = 0; index<len; index++){ for (index = 0; index<len; index++){. Average=sum/len; 31

### 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?

### 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

### Chapter 5 Names, Bindings, Type Checking, and Scopes

Chapter 5 Names, Bindings, Type Checking, and Scopes 長庚大學資訊工程學系 陳仁暉 助理教授 Tel: (03) 211-8800 Ext: 5990 E-mail: jhchen@mail.cgu.edu.tw URL: http://www.csie.cgu.edu.tw/jhchen All rights reserved. No part

### Type Bindings. Static Type Binding

Type Bindings Two key issues in binding (or associating) a type to an identifier: How is type binding specified? When does the type binding take place? N. Meng, S. Arthur 1 Static Type Binding An explicit

### 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

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

### 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

### Binding and Variables

Binding and Variables 1. DEFINITIONS... 2 2. VARIABLES... 3 3. TYPE... 4 4. SCOPE... 4 5. REFERENCES... 7 6. ROUTINES... 9 7. ALIASING AND OVERLOADING... 10 8. GENERICS AND TEMPLATES... 12 A. Bellaachia

### 9/7/17. Outline. Name, Scope and Binding. Names. Introduction. Names (continued) Names (continued) In Text: Chapter 5

Outline Name, Scope and Binding In Text: Chapter 5 Names Variable Binding Type bindings, type conversion Storage bindings and lifetime Scope Lifetime vs. Scope Referencing Environments N. Meng, S. Arthur

### Chapter 5 Names, Bindings, Type Checking, and Scopes

Chapter 5 Names, Bindings, Type Checking, and Scopes Names Variables The Concept of Binding Scope and Lifetime Type Checking Referencing Environments Named Constants Names Used for variables, subprograms

### Lecture 7: Type Systems and Symbol Tables. CS 540 George Mason University

Lecture 7: Type Systems and Symbol Tables CS 540 George Mason University Static Analysis Compilers examine code to find semantic problems. Easy: undeclared variables, tag matching Difficult: preventing

### CS 415 Midterm Exam Spring 2002

CS 415 Midterm Exam Spring 2002 Name KEY Email Address Student ID # Pledge: This exam is closed note, closed book. Good Luck! Score Fortran Algol 60 Compilation Names, Bindings, Scope Functional Programming

### 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

### 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

### 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 10. Implementing Subprograms ISBN

Chapter 10 Implementing Subprograms ISBN 0-321-33025-0 Chapter 10 Topics The General Semantics of Calls and Returns Implementing Simple Subprograms Implementing Subprograms with Stack-Dynamic Local Variables

### 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

### Implementing Subprograms

1 Implementing Subprograms CS 315 Programming Languages Pinar Duygulu Bilkent University CS315 Programming Languages Pinar Duygulu The General Semantics of Calls and Returns 2 The subprogram call and return

### 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

### 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

### Lecture 4 Memory Management

Lecture 4 Memory Management Dr. Wilson Rivera ICOM 4036: Programming Languages Electrical and Computer Engineering Department University of Puerto Rico Some slides adapted from Sebesta s textbook Lecture

### The Compiler So Far. CSC 4181 Compiler Construction. Semantic Analysis. Beyond Syntax. Goals of a Semantic Analyzer.

The Compiler So Far CSC 4181 Compiler Construction Scanner - Lexical analysis Detects inputs with illegal tokens e.g.: main 5 (); Parser - Syntactic analysis Detects inputs with ill-formed parse trees

### Fundamentals of Programming Languages

Fundamentals of Programming Languages 1. DEFINITIONS... 2 2. BUILT-IN TYPES AND PRIMITIVE TYPES... 3 TYPE COMPATIBILITY... 9 GENERIC TYPES... 14 MONOMORPHIC VERSUS POLYMORPHIC... 16 TYPE IMPLEMENTATION

### Programming Language Concepts Scoping. Janyl Jumadinova January 31, 2017

Programming Language Concepts Scoping Janyl Jumadinova January 31, 2017 Scope Rules A scope is a program section of maximal size in which no bindings change, or at least in which no re-declarations are

### 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

### MIDTERM EXAM (Solutions)

MIDTERM EXAM (Solutions) Total Score: 100, Max. Score: 83, Min. Score: 26, Avg. Score: 57.3 1. (10 pts.) List all major categories of programming languages, outline their definitive characteristics and

### 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?

### Properties of an identifier (and the object it represents) may be set at

Properties of an identifier (and the object it represents) may be set at Compile-time These are static properties as they do not change during execution. Examples include the type of a variable, the value

### An Activation Record for Simple Subprograms. Activation Record for a Language with Stack-Dynamic Local Variables

Activation Records The storage (for formals, local variables, function results etc.) needed for execution of a subprogram is organized as an activation record. An Activation Record for Simple Subprograms.

### Short Notes of CS201

#includes: Short Notes of CS201 The #include directive instructs the preprocessor to read and include a file into a source code file. The file name is typically enclosed with < and > if the file is a system

### CS201 - Introduction to Programming Glossary By

CS201 - Introduction to Programming Glossary By #include : The #include directive instructs the preprocessor to read and include a file into a source code file. The file name is typically enclosed with

### LECTURE 14. Names, Scopes, and Bindings: Scopes

LECTURE 14 Names, Scopes, and Bindings: Scopes SCOPE The scope of a binding is the textual region of a program in which a name-to-object binding is active. Nonspecifically, scope is a program region of

### 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

### Names, Scope, and Bindings

Names, Scope, and Bindings COMS W4115 Prof. Stephen A. Edwards Spring 2007 Columbia University Department of Computer Science What s In a Name? Name: way to refer to something else variables, functions,

### Chapter 10. Implementing Subprograms

Chapter 10 Implementing Subprograms Chapter 10 Topics The General Semantics of Calls and Returns Implementing Simple Subprograms Implementing Subprograms with Stack-Dynamic Local Variables Nested Subprograms

### Programming Languages: Lecture 12

1 Programming Languages: Lecture 12 Chapter 10: Implementing Subprograms Jinwoo Kim jwkim@jjay.cuny.edu Chapter 10 Topics 2 The General Semantics of Calls and Returns Implementing Simple Subprograms Implementing

### Concepts of Programming Languages

Concepts of Programming Languages COMP322 Fall 2012/2013 1-1 Textbook ISBN 0-321-49362-1 Chapter 1 Preliminaries ISBN 0-321-49362-1 Chapter 1 Topics Reasons for Studying Concepts of Programming Languages

### Names, Scopes, and Bindings II. Hwansoo Han

Names, Scopes, and Bindings II Hwansoo Han Scope Rules A scope is textual region where bindings are active A program section of maximal size Bindings become active at the entry No bindings change in the

### Chapter 6. Data Types ISBN

Chapter 6 Data Types ISBN 0-321 49362-1 Chapter 6 Topics Introduction Primitive Data Types Character String Types User-Defined Ordinal Types Array Types Associative Arrays Record Types Union Types Pointer

### Names, Scope, and Bindings

Names, Scope, and Bindings COMS W4115 Prof. Stephen A. Edwards Fall 2003 Columbia University Department of Computer Science What s In a Name? Name: way to refer to something else variables, functions,

### Semantic Analysis. Compiler Architecture

Processing Systems Prof. Mohamed Hamada Software Engineering Lab. The University of Aizu Japan Source Compiler Architecture Front End Scanner (lexical tokens Parser (syntax Parse tree Semantic Analysis

### Names, Scope, and Bindings

Names, Scope, and Bindings COMS W4115 Prof. Stephen A. Edwards Fall 2007 Columbia University Department of Computer Science What s In a Name? Name: way to refer to something else variables, functions,

### 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

### Scope. CSC 4181 Compiler Construction. Static Scope. Static Scope Rules. Closest Nested Scope Rule

Scope CSC 4181 Compiler Construction Scope and Symbol Table A scope is a textual region of the program in which a (name-to-object) binding is active. There are two types of scope: Static scope Dynamic

### Implementing Subprograms

Implementing Subprograms 1 Topics The General Semantics of Calls and Returns Implementing Simple Subprograms Implementing Subprograms with Stack-Dynamic Local Variables Nested Subprograms Blocks Implementing

### Organization of Programming Languages CS3200 / 5200N. Lecture 06

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

### Chapter 9. Def: The subprogram call and return operations of a language are together called its subprogram linkage

Def: The subprogram call and return operations of a language are together called its subprogram linkage Implementing FORTRAN 77 Subprograms Call Semantics: 1. Save the execution status of the caller 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

### CS 415 Midterm Exam Spring SOLUTION

CS 415 Midterm Exam Spring 2005 - SOLUTION Name Email Address Student ID # Pledge: This exam is closed note, closed book. Questions will be graded on quality of answer. Please supply the best answer you

### CS201- Introduction to Programming Current Quizzes

CS201- Introduction to Programming Current Quizzes Q.1 char name [] = Hello World ; In the above statement, a memory of characters will be allocated 13 11 12 (Ans) Q.2 A function is a block of statements

### Subprograms. Bilkent University. CS315 Programming Languages Pinar Duygulu

1 Subprograms CS 315 Programming Languages Pinar Duygulu Bilkent University Introduction 2 Two fundamental abstraction facilities Process abstraction Emphasized from early days Data abstraction Emphasized

### 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

### CS 314 Principles of Programming Languages

CS 314 Principles of Programming Languages Lecture 13: Names, Scopes and Bindings Zheng (Eddy) Zhang Rutgers University February 28, 2018 Review: Names, Scopes and Binding What s in a name? Each name means

### 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

### 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

### CSCI312 Principles of Programming Languages!

CSCI312 Principles of Programming Languages! Scope Xu Liu ! 4.1 Syntactic Issues! 4.2 Variables! 4.3 Scope! 4.4 Symbol Table! 4.5 Resolving References! 4.6 Dynamic Scoping! 4.7 Visibility! 4.8 Overloading!

Subprograms Introduction Fundamentals of Subprograms Design Issues for Subprograms Local Referencing Environments Parameter-Passing Methods Parameters That Are Subprograms Calling Subprograms Indirectly

### Prof. Mohamed Hamada Software Engineering Lab. The University of Aizu Japan

Language Processing Systems Prof. Mohamed Hamada Software Engineering Lab. The University of Aizu Japan Semantic Analysis Compiler Architecture Front End Back End Source language Scanner (lexical analysis)

### Chapter 10 Implementing Subprograms

Chapter 10 Implementing Subprograms The General Semantics of Calls and Returns - Definition: The subprogram call and return operations of a language are together called its subprogram linkage Implementing

### 12/4/18. Outline. Implementing Subprograms. Semantics of a subroutine call. Storage of Information. Semantics of a subroutine return

Outline Implementing Subprograms In Text: Chapter 10 General semantics of calls and returns Implementing simple subroutines Call Stack Implementing subroutines with stackdynamic local variables Nested

### CSE 307: Principles of Programming Languages

1 / 57 CSE 307: Principles of Programming Languages Course Review R. Sekar Course Topics Introduction and History Syntax Values and types Names, Scopes and Bindings Variables and Constants Expressions

### The SPL Programming Language Reference Manual

The SPL Programming Language Reference Manual Leonidas Fegaras University of Texas at Arlington Arlington, TX 76019 fegaras@cse.uta.edu February 27, 2018 1 Introduction The SPL language is a Small Programming

### Run-Time Environments

CS308 Run-Time Environments Li Jiang Department of Computer Science and Engineering Shanghai Jiao Tong University Current Progress Source Language Lexical Analyzer Syntax Analyzer Semantic Analyzer Intermediate

### 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

### 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

### Chapter 8 ( ) Control Abstraction. Subprograms Issues related to subprograms How is control transferred to & from the subprogram?

Control Abstraction Chapter 8 (81 84) Control Abstraction: Subroutines and parameters Programmer defined control structures Subprograms Procedures Functions Coroutines Exception handlers Processes Subprograms

### 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

### Time : 1 Hour Max Marks : 30

Total No. of Questions : 6 P4890 B.E/ Insem.- 74 B.E ( Computer Engg) PRINCIPLES OF MODERN COMPILER DESIGN (2012 Pattern) (Semester I) Time : 1 Hour Max Marks : 30 Q.1 a) Explain need of symbol table with

### Informal Semantics of Data. semantic specification names (identifiers) attributes binding declarations scope rules visibility

Informal Semantics of Data semantic specification names (identifiers) attributes binding declarations scope rules visibility 1 Ways to Specify Semantics Standards Documents (Language Definition) Language

### Compiler Theory. (Semantic Analysis and Run-Time Environments)

Compiler Theory (Semantic Analysis and Run-Time Environments) 005 Semantic Actions A compiler must do more than recognise whether a sentence belongs to the language of a grammar it must do something useful

### LECTURE 18. Control Flow

LECTURE 18 Control Flow CONTROL FLOW Sequencing: the execution of statements and evaluation of expressions is usually in the order in which they appear in a program text. Selection (or alternation): a

### Programming Languages

Programming Languages Tevfik Koşar Lecture - VIII February 9 th, 2006 1 Roadmap Allocation techniques Static Allocation Stack-based Allocation Heap-based Allocation Scope Rules Static Scopes Dynamic Scopes

### Exam 3 Chapters 7 & 9

Exam 3 Chapters 7 & 9 CSC 2100-002/003 29 Mar 2017 Read through the entire test first BEFORE starting Put your name at the TOP of every page The test has 4 sections worth a total of 100 points o True/False

### A Fast Review of C Essentials Part II

A Fast Review of C Essentials Part II Structural Programming by Z. Cihan TAYSI Outline Fixed vs. Automatic duration Scope Global variables The register specifier Storage classes Dynamic memory allocation

### Every language has its own scoping rules. For example, what is the scope of variable j in this Java program?

Lexical Binding There are two ways a variable can be used in a program: As a declaration As a "reference" or use of the variable Scheme has two kinds of variable "declarations" -- the bindings of a let-expression

### R13 SET Discuss how producer-consumer problem and Dining philosopher s problem are solved using concurrency in ADA.

R13 SET - 1 III B. Tech I Semester Regular Examinations, November - 2015 1 a) What constitutes a programming environment? [3M] b) What mixed-mode assignments are allowed in C and Java? [4M] c) What is

### 10. Abstract Data Types

10. Abstract Data Types 11.1 The Concept of Abstraction The concept of abstraction is fundamental in programming Nearly all programming languages support process abstraction with subprograms Nearly all

### References and pointers

References and pointers Pointers are variables whose value is a reference, i.e. an address of a store location. Early languages (Fortran, COBOL, Algol 60) had no pointers; added to Fortran 90. In Pascal,

### ! Those values must be stored somewhere! Therefore, variables must somehow be bound. ! How?

A Binding Question! Variables are bound (dynamically) to values Subprogram Activation! Those values must be stored somewhere! Therefore, variables must somehow be bound to memory locations! How? Function

### Names, Scopes, and Bindings. CSE 307 Principles of Programming Languages Stony Brook University

Names, Scopes, and Bindings CSE 307 Principles of Programming Languages Stony Brook University http://www.cs.stonybrook.edu/~cse307 1 Names, Scopes, and Bindings Names are identifiers (mnemonic character

### Qualifying Exam in Programming Languages and Compilers

Qualifying Exam in Programming Languages and Compilers University of Wisconsin Fall 1991 Instructions This exam contains nine questions, divided into two parts. All students taking the exam should answer

### Topic IV. Parameters. Chapter 5 of Programming languages: Concepts & constructs by R. Sethi (2ND EDITION). Addison-Wesley, 1996.

References: Topic IV Block-structured procedural languages Algol and Pascal Chapters 5 and 7, of Concepts in programming languages by J. C. Mitchell. CUP, 2003. Chapter 5 of Programming languages: Concepts

### CSE 452: Programming Languages. Outline of Today s Lecture. Expressions. Expressions and Control Flow

CSE 452: Programming Languages Expressions and Control Flow Outline of Today s Lecture Expressions and Assignment Statements Arithmetic Expressions Overloaded Operators Type Conversions Relational and

### Homework #3 CS2255 Fall 2012

Homework #3 CS2255 Fall 2012 MULTIPLE CHOICE 1. The, also known as the address operator, returns the memory address of a variable. a. asterisk ( * ) b. ampersand ( & ) c. percent sign (%) d. exclamation

### CS 314 Principles of Programming Languages. Lecture 11

CS 314 Principles of Programming Languages Lecture 11 Zheng Zhang Department of Computer Science Rutgers University Wednesday 12 th October, 2016 Zheng Zhang 1 eddy.zhengzhang@cs.rutgers.edu Class Information

### Names, Scopes, and Bindings. CSE 307 Principles of Programming Languages Stony Brook University

Names, Scopes, and Bindings CSE 307 Principles of Programming Languages Stony Brook University http://www.cs.stonybrook.edu/~cse307 1 Names, Scopes, and Bindings Names are identifiers (mnemonic character

### 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

### Names, Scope, and Bindings

Names, Scope, and Bindings Stephen A. Edwards Columbia University Fall 2010 What s In a Name? Name: way to refer to something else variables, functions, namespaces, objects, types if ( a < 3 ) { int bar

### Procedure and Object- Oriented Abstraction

Procedure and Object- Oriented Abstraction Scope and storage management cs5363 1 Procedure abstractions Procedures are fundamental programming abstractions They are used to support dynamically nested blocks

### Topic IV. Block-structured procedural languages Algol and Pascal. References:

References: Topic IV Block-structured procedural languages Algol and Pascal Chapters 5 and 7, of Concepts in programming languages by J. C. Mitchell. CUP, 2003. Chapters 10( 2) and 11( 1) of Programming

### Midterm 2 Solutions Many acceptable answers; one was the following: (defparameter g1

Midterm 2 Solutions 1. [20 points] Consider the language that consist of possibly empty lists of the identifier x enclosed by parentheses and separated by commas. The language includes { () (x) (x,x) (x,x,x)

### 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

### Advances in Programming Languages: Regions

Advances in Programming Languages: Regions Allan Clark and Stephen Gilmore The University of Edinburgh February 22, 2007 Introduction The design decision that memory will be managed on a per-language basis

### Chapter 3:: Names, Scopes, and Bindings (cont.)

Chapter 3:: Names, Scopes, and Bindings (cont.) Programming Language Pragmatics Michael L. Scott Review What is a regular expression? What is a context-free grammar? What is BNF? What is a derivation?

### 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