4 Bindings and Scope. Bindings and environments. Scope, block structure, and visibility. Declarations. Blocks. 2004, D.A. Watt, University of Glasgow
|
|
- Lynne Snow
- 5 years ago
- Views:
Transcription
1 4 Bindings and Scope Bindings and environments. Scope, block structure, and visibility. Declarations. Blocks. 2004, D.A. Watt, University of Glasgow 1
2 Bindings and environments PL expressions and commands contain identifiers, which are declared elsewhere. Their meanings depend on these declarations. A binding is a (fixed) association between an identifier and an entity such as a value, variable, or procedure. Each declaration produces one or more bindings. An environment (or name space) is a set of bindings. Each expression or command is interpreted in a particular environment. Each identifier used in the expression or command must have a 2
3 Bindings in general Binding is used for many associations, usually an association (function) between a syntactical and a semantical entity 3
4 Binding time (1) Binding time is the moment in the development and deployment process when the binding is defined Possible binding times: Language design time Language implementation time Compile time Load time Runtime e.g., bind operator symbols to operations e.g., bind floating point type to a representation e.g., bind a variable to a type in C or Java e.g., bind a FORTRAN 77 variable to a memory cell (or a C static variable) e.g., bind a nonstatic local variable to a memory cell 4
5 Binding time (2) Def: A binding is static if it first occurs before run time and remains unchanged throughout program execution. Def: A binding is dynamic if it first occurs during execution or can change during execution of the program. 5
6 Example: Ada environments Ada program outline: procedure p is!!z: constant Integer := 0;!c: Character;!!procedure q (x: in Float) is! c: constant Float := 3.0e6;! b: Boolean;!begin!!end q;! begin! end p; Environment {" b a Boolean variable, s: " c the floating-point number , " p a procedure with no parameter, " q a procedure with a Float {" parameter, c a Character variable, "" p x a procedure Float variable, with no parameter, " z the integer 0 } " q a procedure with a Float parameter, 6
7 Scope The scope of a declaration (or of a binding) is the portion of the program text over which it has effect. In some early PLs (such as Cobol), the scope of each declaration was the whole program. In modern PLs, the scope of each declaration is controlled by the program s block structure. 7
8 Block structure A block is a program construct that delimits the scope of any declarations within it. Each PL has its own forms of blocks: C: block commands ({ }), function bodies, compilation units. Java: block commands, method bodies, class declarations, packages. Ada: block commands (declare begin end;), procedure bodies, packages, tasks, etc. A PL s block structure is the way in which blocks are arranged in the program text. 8
9 Example: Ada block structure Ada program outline: " procedure P is!! begin!!declare!!begin!!end;! end P;! procedure Q is! begin! end Q; 9
10 Monolithic block structure Some PLs (such as Cobol) have monolithic block structure: the whole program is a single block. The scope of every declaration is the whole program. declaration of declaration x of y declaration of z scope of declaratio ns of x, y, z 10
11 Flat block structure Some PLs (such as Fortran) have flat block structure: the program is partitioned into nonoverlapping blocks. declaration of x declaration of of y y scope of decl-aration of x scope of decl-aration of y declaration of of z z scope of decl-aration of z 11
12 Nested block structure Modern PLs have nested block structure: blocks may be nested within other blocks. declaration of x declaration of y declaration of z scope of decl-aration of x scope of decl-aration of y scope of decl-aration of z 12
13 Scope and visibility A binding occurrence of identifier I is an occurrence of I where I is bound to some entity X. An applied occurrence of identifier I is an occurrence of I where use is made of the entity X to which I is bound. At this applied occurrence, we say that I denotes X. If the PL is statically scoped (see later), every applied occurrence of I should correspond to exactly one binding occurrence of I. 13
14 Example: Ada binding and applied occurrences Ada program outline: procedure p is!! z : constant Integer := 0;!c : Character;!!procedure q (x : in Float) is! c : constant Float := 3.0e6;! b : Boolean;!begin! b c x z!end q;! begin! c z end p; 14
15 Hiding If identifier I is declared in two different blocks, I denotes a different entity in each block. If identifier I is declared in two nested blocks, I denotes one entity in the outer block and a different entity in the inner block. The inner declaration hides the outer one. declaration of x declaration of x declaration of x declaration of x Here the outer declaration of x is hidden. 15
16 Static vs dynamic scoping (1) A PL is statically scoped if the body of a procedure is executed in the environment of the procedure definition. We can decide at compile-time which binding occurrence of an identifier corresponds to a given applied occurrence. A PL is dynamically scoped if the body of a procedure is executed in the environment of the procedure call. We cannot decide until run-time which binding occurrence of an identifier corresponds to a given applied occurrence, since the environment may vary from one procedure call to another. 16
17 Example: static vs dynamic scoping (1) Program in Ada (which is statically scoped): s : constant Integer := 2;! function f (x : Integer) return Integer is begin!return s * x; end f;! procedure q (y : Integer) is begin!put(f(y)); end q;! procedure q (z : Integer) is!s : constant Integer := 3; begin!put(f(z)); end q; The value of s here is always 2. 17
18 Example: static vs dynamic scoping (2) Same program in a hypothetical dynamically scoped PL: s : constant Integer := 2;! function f (x : Integer) return Integer The value is of begin s here!return s * x; depends on end f; the call site.! procedure q (y : Integer) is begin!put(f(y)); end q;! procedure q (z : Integer) is!s : constant Integer := 3; begin!put(f(z)); end q; multiplies value of y by 2 multiplies value of z by 3 18
19 Static vs dynamic scoping (2) Dynamic scoping fits badly with static typing. In the previous slide, what if the two declarations of s had different types? Nearly all PLs (including C, Java, and Ada) are statically scoped. Only a few PLs (such as Smalltalk and Lisp) are dynamically scoped. Natural language has both: Yesterday he said: I will come tomorrow. (static scoping) Yesterday he said that he would come today. (dynamic scoping) 19
20 Declarations (1) A declaration is a program construct that will be elaborated to produce binding(s). A declaration may have side effects (such as creating a variable). A definition is a declaration whose only effect is to produce binding(s). 20
21 Declarations (2) Forms of declarations: type declarations constant declarations variable declarations procedure definitions collateral declarations sequential declarations recursive declarations. The repertoire of simple declarations depends on the PL. 21
22 Type declarations A type declaration binds an identifier to a type. A type definition binds an identifier to an existing type. Alternatively, a type declaration may introduce a new type, distinct from all existing types. 22
23 Example: C type declarations typedef binds an identifier to an existing type: typedef char* Alpha; Alpha s; char* t; s = t; bound to exist-ing type char* legal " But enum, struct, or union binds an identifier to a new type:! struct Book {Alpha title, int edition}; struct Author {Alpha name, int age}; Book b; Author a; bound to new a = b; types illega l 23
24 Example: Ada type declarations Every Ada type declaration introduces a new and distinct type: type Alpha is array (1.. 32) of Character;! type Book is record!! title: Alpha;!! edition: Integer;! end record; type Author is record!! name: Alpha;!! age: Integer;! end record; b: Book; a: Author; a := b; bound to new types illega l 24
25 Constant declarations A constant declaration binds an identifier to a (constant) value. In Ada, a constant declaration has the form: I : constant T := E; This binds I to the value of the expression E, which must be of type T. Some PLs restrict the expression E to be a literal, or an expression that can be evaluated at compile-time. Some PLs restrict the constant s type T. 25
26 Variable declarations A variable declaration binds an identifier to a variable. In Ada, ordinary variable declarations have the form: I : T := E; This creates a variable of type T, binds I to that variable, and initialises it to the value of the expression E. In Ada, renaming variable declarations have the form: I : T renames V; This binds I to the existing variable V. 26
27 Example: Ada renaming variable declaration Ada code:! type Country is (UK, FR, ); pop : array (Country) of Natural;! declare!c : Country := ;!p : Integer renames pop(c); begin!!p := p + 1;! end; bound to existing variable pop(c) more efficient than pop(c) := pop(c) + 1; 27
28 Procedure definitions A procedure definition binds an identifier to a procedure. In most PLs, we can define both proper procedures and function procedures. 28
29 Example: Ada procedure definitions Function procedure definition:! function even (n: Integer) return Boolean is begin!return (n mod 2 = 0); bound to a function end; proced-ure that tests whether its Integer argument is even " Proper procedure definition:! procedure double (n: in out Integer) is begin!n := n * 2; bound to a proper end; proced-ure that doubles its Integer argument 29
30 Collateral declarations A collateral declaration is a group of subdeclarations that are elaborated independently of one another. A subdeclaration may not use bindings produced by any other subdeclaration. Collateral declarations are found in Java and functional PLs, but not in C or Ada. 30
31 Sequential declarations A sequential declaration is a group of subdeclarations that are elaborated one after another. A subdeclaration may use bindings produced by previous subdeclarations, but not those produced by following subdeclarations. Sequential declarations are found in all imperative and OO PLs. 31
32 Recursive declarations A recursive declaration is one that uses the bindings it produces itself. Ada type declarations: A single type declaration may be recursive. A sequence of type declarations may be made mutually recursive, if preceded by incomplete type declarations. Ada procedure declarations: similarly. Java method definitions: One or more method definitions may be (mutually) recursive. 32
33 Example: Ada recursive type declarations Mutually recursive type declarations:! type IntNode; type IntList is access IntNode; type IntNode is record!! head: Integer;!! tail: IntList;! end record; incomplete type declaration: binds IntNode to an completes unknown type the binding of IntNode 33
34 Example: Ada recursive procedure definitions (1) Recursive procedure definition:! procedure print (n: Natural) is begin!if n < 10 then! put(digit(n));!else! print(n/10);! put(digit(n mod 10));!end if; end; 34
35 Example: Ada recursive procedure definitions (2) Mutually recursive procedure definitions: procedure parse_expression;! procedure parse_primary is begin!if acceptable('(') loop! accept('(');! parse_expression;! accept(')');!else! parse_variable;!end if; end; binds parse_ expression to an unknown procedure 35
36 Example: Ada recursive procedure definitions (3) Mutually recursive procedure definitions (continued):! procedure parse_expression is begin!parse_primary;!while acceptable('+') loop! accept('+');! parse_primary;!end loop; end; completes the binding of parse_ expression 36
37 Blocks A block is a program construct that delimits the scope of any declarations within it. Kinds of blocks: block commands block expressions. 37
38 Block commands A block command is a form of command that contains a local declaration (or group of declarations) D and a subcommand C. The bindings produced by D are used only for executing C. These bindings override any bindings for the same identifiers in the environment outside the block. Block commands are common in imperative and OO PLs. In C and Java: { D C } In Ada: 38
39 Example: Java block command To sort the values of int variables x and y into ascending order:! if (x > y) {! int z = x;!x = y;!y = z; } block command (scope of declaration of z) 39
40 Block expressions A block expression is a form of expression that contains a local declaration (or group of declarations) D and a subexpression E. The bindings produced by D are used only for evaluating E. These bindings override any bindings for the same identifiers in the environment outside the block. Block expressions are uncommon in imperative and OO PLs, but common in functional PLs. Form of block expression in Haskell: let D in E 40
41 Example: Haskell block expression To compute the area of a triangle whose sides have lengths a, b, c:! let!s = (a + b + c)/2.0 in!sqrt(s*(s-a)*(s-b)*(s-c)) The only way to achieve the same effect in Ada (or C) is to declare and call a suitable function:! function area (a, b, c: Float)! return Float is!s: constant Float := (a + b + c)/2.0; begin!return sqrt(s*(s-a)*(s-b)*(s-c)); end; 41
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
More informationQuestions? 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
More informationInformal 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
More informationStatic Semantics. Lecture 15. (Notes by P. N. Hilfinger and R. Bodik) 2/29/08 Prof. Hilfinger, CS164 Lecture 15 1
Static Semantics Lecture 15 (Notes by P. N. Hilfinger and R. Bodik) 2/29/08 Prof. Hilfinger, CS164 Lecture 15 1 Current Status Lexical analysis Produces tokens Detects & eliminates illegal tokens Parsing
More informationChapter 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
More informationCSE 307: Principles of Programming Languages
1 / 26 CSE 307: Principles of Programming Languages Names, Scopes, and Bindings R. Sekar 2 / 26 Topics Bindings 1. Bindings Bindings: Names and Attributes Names are a fundamental abstraction in languages
More informationProgramming 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
More informationChapter 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?
More information9/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
More informationLecture 16: Static Semantics Overview 1
Lecture 16: Static Semantics Overview 1 Lexical analysis Produces tokens Detects & eliminates illegal tokens Parsing Produces trees Detects & eliminates ill-formed parse trees Static semantic analysis
More informationProgramming 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
More informationExample: 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
More informationCompiler construction
Compiler construction Martin Steffen March 13, 2017 Contents 1 Abstract 1 1.1 Symbol tables. 1 1.1.1 Introduction 1 1.1.2 Symbol table design and interface.. 2 1.1.3 Implementing symbol tables 3 1.1.4
More informationProgramming Languages 2nd edition Tucker and Noonan"
Programming Languages 2nd edition Tucker and Noonan" " Chapter 1" Overview" " A good programming language is a conceptual universe for thinking about programming. " " " " " " " " " " " " "A. Perlis" "
More informationProgramming Languages Third Edition. Chapter 9 Control I Expressions and Statements
Programming Languages Third Edition Chapter 9 Control I Expressions and Statements Objectives Understand expressions Understand conditional statements and guards Understand loops and variation on WHILE
More informationSemantic 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
More informationThe 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
More informationConcepts of Programming Languages
Concepts of Programming Languages Lecture 1 - Introduction Patrick Donnelly Montana State University Spring 2014 Patrick Donnelly (Montana State University) Concepts of Programming Languages Spring 2014
More information1 Lexical Considerations
Massachusetts Institute of Technology Department of Electrical Engineering and Computer Science 6.035, Spring 2013 Handout Decaf Language Thursday, Feb 7 The project for the course is to write a compiler
More informationImperative 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
More informationIEEE LANGUAGE REFERENCE MANUAL Std P1076a /D3
LANGUAGE REFERENCE MANUAL Std P1076a-1999 2000/D3 Clause 10 Scope and visibility The rules defining the scope of declarations and the rules defining which identifiers are visible at various points in the
More informationTypes. 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
More informationStorage. Outline. Variables and Updating. Composite Variables. Storables Lifetime : Programming Languages. Course slides - Storage
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
More informationCompiler 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
More informationCS558 Programming Languages. Winter 2013 Lecture 3
CS558 Programming Languages Winter 2013 Lecture 3 1 NAMES AND BINDING One essential part of being a high-level language is having convenient names for things: variables constants types functions etc. classes
More informationInformatica 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
More informationThe PCAT Programming Language Reference Manual
The PCAT Programming Language Reference Manual Andrew Tolmach and Jingke Li Dept. of Computer Science Portland State University September 27, 1995 (revised October 15, 2002) 1 Introduction The PCAT language
More informationTypes 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
More informationProgrammiersprachen (Programming Languages)
2016-05-13 Preface Programmiersprachen (Programming Languages) coordinates: lecturer: web: usable for: requirements: No. 185.208, VU, 3 ECTS Franz Puntigam http://www.complang.tuwien.ac.at/franz/ps.html
More informationTypes 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
More informationCSC 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
More informationNames, 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
More informationHANDLING 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.
More informationScope. 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
More informationAnatomy of a Compiler. Overview of Semantic Analysis. The Compiler So Far. Why a Separate Semantic Analysis?
Anatomy of a Compiler Program (character stream) Lexical Analyzer (Scanner) Syntax Analyzer (Parser) Semantic Analysis Parse Tree Intermediate Code Generator Intermediate Code Optimizer Code Generator
More informationLexical Considerations
Massachusetts Institute of Technology Department of Electrical Engineering and Computer Science 6.035, Spring 2010 Handout Decaf Language Tuesday, Feb 2 The project for the course is to write a compiler
More informationSyntax Errors; Static Semantics
Dealing with Syntax Errors Syntax Errors; Static Semantics Lecture 14 (from notes by R. Bodik) One purpose of the parser is to filter out errors that show up in parsing Later stages should not have to
More informationSemantic 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
More informationChapter 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
More informationCSC312 Principles of Programming Languages : Functional Programming Language. Copyright 2006 The McGraw-Hill Companies, Inc.
CSC312 Principles of Programming Languages : Functional Programming Language Overview of Functional Languages They emerged in the 1960 s with Lisp Functional programming mirrors mathematical functions:
More informationRSL Reference Manual
RSL Reference Manual Part No.: Date: April 6, 1990 Original Authors: Klaus Havelund, Anne Haxthausen Copyright c 1990 Computer Resources International A/S This document is issued on a restricted basis
More informationSpecial Topics: Programming Languages
Lecture #15 0 V22.0490.001 Special Topics: Programming Languages B. Mishra New York University. Lecture # 15 Lecture #15 1 Slide 1 Scope Issues Those features which describe and control the use of named
More informationThe 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
More informationCS 242. Fundamentals. Reading: See last slide
CS 242 Fundamentals Reading: See last slide Syntax and Semantics of Programs Syntax The symbols used to write a program Semantics The actions that occur when a program is executed Programming language
More informationFundamentals 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
More informationShort 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
More informationCompilers. Type checking. Yannis Smaragdakis, U. Athens (original slides by Sam
Compilers Type checking Yannis Smaragdakis, U. Athens (original slides by Sam Guyer@Tufts) Summary of parsing Parsing A solid foundation: context-free grammars A simple parser: LL(1) A more powerful parser:
More informationThe New C Standard (Excerpted material)
The New C Standard (Excerpted material) An Economic and Cultural Derek M. Jones derek@knosof.co.uk Copyright 2002-2008 Derek M. Jones. All rights reserved. 1456 6.7.2.3 Tags 6.7.2.3 Tags type contents
More informationProgramming Language Concepts, cs2104 Lecture 04 ( )
Programming Language Concepts, cs2104 Lecture 04 (2003-08-29) Seif Haridi Department of Computer Science, NUS haridi@comp.nus.edu.sg 2003-09-05 S. Haridi, CS2104, L04 (slides: C. Schulte, S. Haridi) 1
More informationCS201 - 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
More informationCSCI312 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!
More informationThe Compiler So Far. Lexical analysis Detects inputs with illegal tokens. Overview of Semantic Analysis
The Compiler So Far Overview of Semantic Analysis Adapted from Lectures by Profs. Alex Aiken and George Necula (UCB) Lexical analysis Detects inputs with illegal tokens Parsing Detects inputs with ill-formed
More informationScope. 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
More informationComputer Science Department Carlos III University of Madrid Leganés (Spain) David Griol Barres
Computer Science Department Carlos III University of Madrid Leganés (Spain) David Griol Barres dgriol@inf.uc3m.es Introduction He am a driver might be syntactically correct but semantically wrong. Semantic
More informationSemantics. Names. Binding Time
/24/ CSE 3302 Programming Languages Semantics Chengkai Li, Weimin He Spring Names Names: identif language entities variables, procedures, functions, constants, data tpes, Attributes: properties of names
More informationType 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
More informationChapter 5: Procedural abstraction. Function procedures. Function procedures. Proper procedures and function procedures
Chapter 5: Procedural abstraction Proper procedures and function procedures Abstraction in programming enables distinction: What a program unit does How a program unit works This enables separation of
More informationLexical Considerations
Massachusetts Institute of Technology Department of Electrical Engineering and Computer Science 6.035, Fall 2005 Handout 6 Decaf Language Wednesday, September 7 The project for the course is to write a
More informationSymbol Tables. ASU Textbook Chapter 7.6, 6.5 and 6.3. Tsan-sheng Hsu.
Symbol Tables ASU Textbook Chapter 7.6, 6.5 and 6.3 Tsan-sheng Hsu tshsu@iis.sinica.edu.tw http://www.iis.sinica.edu.tw/~tshsu 1 Definitions Symbol table: A data structure used by a compiler to keep track
More informationG 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,
More informationCSCE 314 Programming Languages. Type System
CSCE 314 Programming Languages Type System Dr. Hyunyoung Lee 1 Names Names refer to different kinds of entities in programs, such as variables, functions, classes, templates, modules,.... Names can be
More informationData Types. Every program uses data, either explicitly or implicitly to arrive at a result.
Every program uses data, either explicitly or implicitly to arrive at a result. Data in a program is collected into data structures, and is manipulated by algorithms. Algorithms + Data Structures = Programs
More informationQuestion No: 1 ( Marks: 1 ) - Please choose one One difference LISP and PROLOG is. AI Puzzle Game All f the given
MUHAMMAD FAISAL MIT 4 th Semester Al-Barq Campus (VGJW01) Gujranwala faisalgrw123@gmail.com MEGA File Solved MCQ s For Final TERM EXAMS CS508- Modern Programming Languages Question No: 1 ( Marks: 1 ) -
More informationCS412/CS413. Introduction to Compilers Tim Teitelbaum. Lecture 17: Types and Type-Checking 25 Feb 08
CS412/CS413 Introduction to Compilers Tim Teitelbaum Lecture 17: Types and Type-Checking 25 Feb 08 CS 412/413 Spring 2008 Introduction to Compilers 1 What Are Types? Types describe the values possibly
More information22c: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
More informationName, 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
More informationData 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:
More informationControl Flow February 9, Lecture 7
Chapter 6 Control Flow February 9, Lecture 7 Expressions A simple object Literal constant Named variable Constant Or a function applied to arguments For built-in functions we use the term operator (like
More informationCS558 Programming Languages Winter 2018 Lecture 4a. Andrew Tolmach Portland State University
CS558 Programming Languages Winter 2018 Lecture 4a Andrew Tolmach Portland State University 1994-2018 Pragmatics of Large Values Real machines are very efficient at handling word-size chunks of data (e.g.
More informationCS 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
More informationCSCI312 Principles of Programming Languages!
CSCI312 Principles of Programming Languages! Chapter 5 Types Xu Liu! ! 5.1!Type Errors! 5.2!Static and Dynamic Typing! 5.3!Basic Types! 5.4!NonBasic Types! 5.5!Recursive Data Types! 5.6!Functions as Types!
More informationSEMANTIC 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
More informationA Second Look At ML. Chapter Seven Modern Programming Languages, 2nd ed. 1
A Second Look At ML Chapter Seven Modern Programming Languages, 2nd ed. 1 Outline Patterns Local variable definitions A sorting example Chapter Seven Modern Programming Languages, 2nd ed. 2 Two Patterns
More informationCSE 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
More informationCS558 Programming Languages
CS558 Programming Languages Fall 2016 Lecture 4a Andrew Tolmach Portland State University 1994-2016 Pragmatics of Large Values Real machines are very efficient at handling word-size chunks of data (e.g.
More informationSubject: PROBLEM SOLVING THROUGH C Time: 3 Hours Max. Marks: 100
Code: DC-05 Subject: PROBLEM SOLVING THROUGH C Time: 3 Hours Max. Marks: 100 NOTE: There are 11 Questions in all. Question 1 is compulsory and carries 16 marks. Answer to Q. 1. must be written in the space
More informationTail 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 *)
More informationCS558 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.
More informationSemantic Analysis. How to Ensure Type-Safety. What Are Types? Static vs. Dynamic Typing. Type Checking. Last time: CS412/CS413
CS412/CS413 Introduction to Compilers Tim Teitelbaum Lecture 13: Types and Type-Checking 19 Feb 07 Semantic Analysis Last time: Semantic errors related to scopes Symbol tables Name resolution This lecture:
More information10. 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
More informationWeeks 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
More informationStorage. 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:
More informationCOMP 181. Agenda. Midterm topics. Today: type checking. Purpose of types. Type errors. Type checking
Agenda COMP 181 Type checking October 21, 2009 Next week OOPSLA: Object-oriented Programming Systems Languages and Applications One of the top PL conferences Monday (Oct 26 th ) In-class midterm Review
More informationG Programming Languages - Fall 2012
G22.2110-003 Programming Languages - Fall 2012 Lecture 3 Thomas Wies New York University Review Last week Names and Bindings Lifetimes and Allocation Garbage Collection Scope Outline Control Flow Sequencing
More informationMIDTERM EXAMINATION - CS130 - Spring 2005
MIDTERM EAMINATION - CS130 - Spring 2005 Your full name: Your UCSD ID number: This exam is closed book and closed notes Total number of points in this exam: 231 + 25 extra credit This exam counts for 25%
More informationAnswer: 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)
More informationIntroduction to Programming Using Java (98-388)
Introduction to Programming Using Java (98-388) Understand Java fundamentals Describe the use of main in a Java application Signature of main, why it is static; how to consume an instance of your own class;
More informationFundamental Concepts and Definitions
Fundamental Concepts and Definitions Identifier / Symbol / Name These terms are synonymous: they refer to the name given to a programming component. Classes, variables, functions, and methods are the most
More informationIntroduction Primitive Data Types Character String Types User-Defined Ordinal Types Array Types. Record Types. Pointer and Reference Types
Chapter 6 Topics WEEK E FOUR Data Types Introduction Primitive Data Types Character String Types User-Defined Ordinal Types Array Types Associative Arrays Record Types Union Types Pointer and Reference
More informationSE352b: Roadmap. SE352b Software Engineering Design Tools. W3: Programming Paradigms
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
More informationSymbol Tables Symbol Table: In computer science, a symbol table is a data structure used by a language translator such as a compiler or interpreter, where each identifier in a program's source code is
More informationThe compilation process is driven by the syntactic structure of the program as discovered by the parser
Semantic Analysis The compilation process is driven by the syntactic structure of the program as discovered by the parser Semantic routines: interpret meaning of the program based on its syntactic structure
More informationProgram Abstractions, Language Paradigms. CS152. Chris Pollett. Aug. 27, 2008.
Program Abstractions, Language Paradigms. CS152. Chris Pollett. Aug. 27, 2008. Outline. Abstractions for telling a computer how to do things. Computational Paradigms. Language Definition, Translation.
More informationChapter 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
More informationToday's Topics. CISC 458 Winter J.R. Cordy
Today's Topics Last Time Semantics - the meaning of program structures Stack model of expression evaluation, the Expression Stack (ES) Stack model of automatic storage, the Run Stack (RS) Today Managing
More informationPrinciples of Programming Languages. Lecture Outline
Principles of Programming Languages CS 492 Lecture 1 Based on Notes by William Albritton 1 Lecture Outline Reasons for studying concepts of programming languages Programming domains Language evaluation
More informationSMURF Language Reference Manual Serial MUsic Represented as Functions
SMURF Language Reference Manual Serial MUsic Represented as Functions Richard Townsend, Lianne Lairmore, Lindsay Neubauer, Van Bui, Kuangya Zhai {rt2515, lel2143, lan2135, vb2363, kz2219}@columbia.edu
More informationChapter 5. Variables. Topics. Imperative Paradigm. Von Neumann Architecture
Topics Chapter 5 Variables Imperative Paradigm Variables Names Address Types Assignment Binding Lifetime Scope Constants 2 Imperative Paradigm The most widely used and well-developed programming paradigm.
More informationTypes, Type Inference and Unification
Types, Type Inference and Unification Mooly Sagiv Slides by Kathleen Fisher and John Mitchell Cornell CS 6110 Summary (Functional Programming) Lambda Calculus Basic ML Advanced ML: Modules, References,
More informationNames and Types. standard hue names. Dr. Philip Cannata 1
Names and Types standard hue names Dr. Philip Cannata 1 10 High Level Languages This Course Jython in Java Java (Object Oriented) ACL2 (Propositional Induction) Relation Algorithmic Information Theory
More information