CS307: Principles of Programming Languages

Home , Scope (computer science), Static (keyword)

LECTURE 12: NAMES, SCOPES, AND BINDINGS II LECTURE OUTLINE • INTRODUCTION • BINDINGS • LIFETIME AND STORAGE MANAGEMENT • SCOPE RULES • STATIC SCOPING • DYNAMIC SCOPING • STATIC VS DYNAMIC SCOPING • DEEP VS SHALLOW BINDING • POLYMORPHISM, DYNAMIC BINDING, GENERIC PROGRAMMING • METHOD MATCHING VS BINDING • BINDING OF REFERENCE ENVIRONMENTS

• SEPARATE COMPILATION 2

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson SCOPE RULES

• BINDING SCOPE IS THE TEXTUAL REGION OF THE PROGRAM IN WHICH A BINDING IS ACTIVE • A SCOPE IS A PROGRAM SECTION OF MAXIMAL SIZE WHERE • NO BINDINGS CHANGE • MINIMALLY: NO RE-DECLARATIONS ARE PERMITTED • SCOPING RULE EXAMPLE 1: DECLARATION BEFORE USE • CAN A NAME BE USED BEFORE IT IS DECLARED? • JAVA LOCAL VARS: NO • JAVA CLASS PROPERTIES AND METHODS: YES • THE SCOPE OF A BINDING IS DETERMINED STATICALLY OR DYNAMICALLY

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson SCOPING RULES

• SCOPING RULE EXAMPLE 2:

TWO USES OF A GIVEN NAME. DO THEY REFER TO THE SAME BINDING? a = 1 ... def f(): a = 2 b = a SCOPING RULES DETERMINE WHETHER OR NOT THIS IS THE CASE

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson SCOPE RULES • KEY IDEA: IN STATIC SCOPE RULES -> BINDINGS DEFINED BY THE PHYSICAL (LEXICAL) STRUCTURE OF THE PROGRAM • STATIC SCOPING (ALSO CALLED LEXICAL SCOPING) EXAMPLES: • ONE BIG SCOPE: (BASIC) • SCOPE OF A FUNCTION (VARIABLES LIVE THROUGH A FUNCTION EXECUTION) • BLOCK SCOPE • NESTED SUBROUTINES • VARIABLES ACTIVE IN ONE OR MORE SCOPES • CLOSEST NESTED SCOPE RULE APPLIES • LEXICAL/STATIC SCOPING WAS USED BY ALGOL 5 • PICKED UP IN MOST LANGUAGES SINCE: (PASCAL, C, JAVA, ETC) CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson SCOPE RULES

• IN MOST LANGUAGES WITH SUBROUTINES: • OPEN A NEW SCOPE ON SUBROUTINE ENTRY: • CREATE BINDINGS FOR NEW LOCAL VARIABLES • DEACTIVATE BINDINGS FOR GLOBAL VARIABLES THAT ARE RE-DECLARED • THESE [GLOBAL] VARIABLES ARE SAID TO HAVE A "HOLE" IN THEIR SCOPE • ON SUBROUTINE EXIT: • DESTROY BINDINGS FOR LOCAL VARIABLES • REACTIVATE BINDINGS FOR DEACTIVATED GLOBAL VARIABLES

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson SCOPE RULES

• ELABORATION • PROCESS OF CREATING BINDINGS WHEN ENTERING A SCOPE • STORAGE MAY BE ALLOCATED • TASKS STARTED • EXCEPTIONS MAY BE PROPAGATED AS A RESULT OF THE ELABORATION OF DECLARATIONS

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson STATIC SCOPING

• STATIC (LEXICAL) SCOPE RULES • A SCOPE IS DEFINED IN TERMS OF THE PHYSICAL (LEXICAL) STRUCTURE OF THE PROGRAM: • SCOPES CAN BE DETERMINED BY COMPILER • ALL BINDINGS FOR IDENTIFIERS CAN BE RESOLVED BY EXAMINING PROGRAM • TYPICALLY, CHOOSE THE MOST RECENT, ACTIVE BINDING MADE AT COMPILE TIME • MOST COMPILED LANGUAGES, C, PASCAL, JAVA AND PYTHON INCLUDED, EMPLOY STATIC SCOPE RULES

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson STATIC SCOPING

• NESTED BLOCKS: • CLASSICAL EXAMPLE OF STATIC SCOPE RULES: “MOST CLOSELY NESTED RULE”: • AN IDENTIFIER IS • KNOWN IN THE SCOPE IN WHICH IT’S DECLARED AND IN EACH ENCLOSED SCOPE • UNLESS RE-DECLARED IN AN ENCLOSED SCOPE (ORIGINAL IDENTIFIER IS HIDDEN) • TO RESOLVE A REFERENCE TO AN IDENTIFIER: EXAMINE LOCAL SCOPE AND STATICALLY ENCLOSING SCOPES UNTIL A BINDING IS FOUND • CLASSES (IN ABSTRACTION AND OO LANGUAGES) HAVE EVEN MORE SOPHISTICATED (STATIC) SCOPE RULES

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson ILLUSTRATION

Pascal:

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione 10 (SUNY Korea) and Pearson STATIC SCOPING

• SIMPLEST WAY TO FIND FRAMES OF SURROUNDING SCOPES • MAINTAIN A STATIC LINK IN EACH FRAME • POINTS TO THE ‘PARENT’ FRAME: THE FRAME OF MOST RECENT INVOCATION OF A LEXICALLY SURROUNDING SUBROUTINE • SUBROUTINE DECLARED AT OUTERMOST NESTING WILL HAVE A NULL STATIC LINK TO ‘PARENT’ AT RUN TIME • SUBROUTINE NESTED K LEVELS DEEP • FRAME’S STATIC ‘PARENT’ LINK AND THOSE OF GRANDPARENT, ETC. FORM A STATIC CHAIN OF LENGTH K AT RUN TIME

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson ILLUSTRATION Nesting of subroutines: During run time (with links)

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione 12 (SUNY Korea) and Pearson STATIC SCOPING

• DECLARATION ORDER: • SOME EARLY LANGUAGES, (ALGOL 60, LISP, ETC), REQUIRED ALL DECLARATIONS APPEAR AT BEGINNING OF SCOPE • PASCAL REQUIREMENT: NAMES MUST BE DECLARED BEFORE USED • STILL USES A WHOLE-BLOCK SCOPE (ALSO IMPLEMENTED IN C#) • EXAMPLE (C#): DEFINING VARIABLE IN A BLOCK MAKES EVERY EXTERNAL DECLARATION HIDDEN • ➔ THE M=N ASSIGNMENT GENERATES A COMPILING ERROR!

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson DYNAMIC SCOPING

• DYNAMIC SCOPE RULES • BINDINGS DEPEND ON CURRENT STATE OF PROGRAM EXECUTION • CANNOT BE RESOLVED BY EXAMINING PROGRAM SOURCE SINCE THEY’RE DEPENDENT ON CALLING SEQUENCES • BINDING MIGHT DEPEND ON HOW A FUNCTION IS CALLED • TO RESOLVE A REFERENCE: USE THE MOST RECENT, ACTIVE BINDING MADE AT RUN TIME

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson DYNAMIC SCOPING OF BINDINGS

EXAMPLE: var total = 0 def add(): total += 1 def myfunc(): var total = 0 add()

add() myfunc() print total

VERY EASY TO IMPLEMENT (STACK OF NAMES) OFTEN HARD TO MAKE EFFICIENT

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione 15 (SUNY Korea) and Pearson SCOPE RULES

• DYNAMIC SCOPE RULES USUALLY IN INTERPRETED LANGUAGES • EXAMPLES: LISP, PERL, RUBY, C#, THE SHELL LANGUAGES BASH, DASH, AND POWERSHELL • SUCH LANGUAGES DO NOT ALWAYS HAVE COMPILE TIME TYPE CHECKING • TYPE DETERMINATION NOT ALWAYS POSSIBLE WITH DYNAMIC SCOPE RULES

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson BINDING OF REFERENCE ENVIRONMENTS

• REFERENCE ENVIRONMENT • ALL BINDINGS ACTIVE AT A GIVEN TIME • TO TAKE A REFERENCE TO A FUNCTION • NEED TO DECIDE WHICH REFERENCE ENVIRONMENT TO USE!! • DEEP BINDING BINDS ENVIRONMENT AT TIME PROCEDURE IS PASSED AS AN ARGUMENT • SHALLOW BINDING BINDS ENVIRONMENT AT THE TIME THE PROCEDURE IS ACTUALLY CALLED

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson EXAMPLE: STATIC VS. DYNAMIC SHALLOW VS. DYNAMIC DEEP

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione 18 (SUNY Korea) and Pearson BINDING OF REFERENCE ENVIRONMENTS

x: integer := 1 y: integer := 2 -DYNAMIC SCOPING WITH DEEP BINDING: -WHEN ADD IS PASSED INTO SECOND procedure add ENVIRONMENT OF ADD IS x = 1, y = 3 x := x + y -THE x IS THE GLOBAL x SO IT WRITES 4 INTO THE GLOBAL x, procedure second(P:procedure) -GLOBAL x IS THE ONE PICKED UP x:integer := 2 BY THE write_integer P() -SHALLOW BINDING: procedure first -JUST TRAVERSE UP CALL CHAIN y:integer := 3 -IT FINDS THE NEAREST VARIABLE second(add) THAT CORRESPONS TO THE NAME (THE LOCAL x) first() -INCREMENTS LOCAL x SO write_integer(x) ANSWER IS 1 CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione 19 (SUNY Korea) and Pearson SCOPE RULES EXAMPLE: STATIC VS. DYNAMIC program scopes (input, output ); • PROGRAM OUTPUT DEPENDS var a : integer; • ON SCOPE RULES procedure first(); begin • IN THE CASE OF DYNAMIC SCOPING, A VALUE READ AT RUN TIME a := 1; end; • STATIC SCOPING: THIS PROGRAM PRINTS A 1. procedure second(); • DYNAMIC SCOPING: var a : integer; • OUTPUT DEPENDS ON VALUE READ BY begin READ_INTEGER() AT RUN TIME: first(); • INPUT IS POSITIVE: THE PROGRAM PRINTS A 2 end; • OTHERWISE: PROGRAM PRINTS A 1 begin • THE ASSIGNMENT TO THE VARIABLE A IN FIRST() a := 2; REFERS EITHER if read_integer() > 0 second(); • TO GLOBAL VARIABLE DECLARED IN PROGRAM SCOPES OR else • TO THE LOCAL VARIABLE DECLARED INSIDE first(); SECOND() 20 write(a); end. CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson SCOPE RULES EXAMPLE: STATIC VS. DYNAMIC

• STATIC SCOPE RULES REQUIRE REFERENCE TO RESOLVE TO THE MOST RECENT, COMPILE-TIME BINDING • GLOBAL VARIABLE A • DYNAMIC SCOPE RULES REQUIRE CHOICE OF THE MOST RECENT, ACTIVE BINDING AT RUN TIME • MOST COMMON USE OF DYNAMIC SCOPE RULES MAY BE TO PROVIDE IMPLICIT PARAMETERS TO SUBROUTINES • THIS IS CONSIDERED BAD PROGRAMMING PRACTICE TODAY (EXCEPT IN FUNCTIONAL LANGUAGES) • ALTERNATIVE MECHANISMS EXIST • STATIC VARIABLES THAT CAN BE MODIFIED BY AUXILIARY ROUTINES • DEFAULT AND OPTIONAL PARAMETERS

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson SCOPE RULES EXAMPLE: STATIC VS. DYNAMIC

• AT RUN TIME: CREATE A BINDING FOR A WHEN ENTER MAIN PROGRAM IS ENTERED • CREATE ANOTHER BINDING FOR A WHEN CODE ENTERS SECOND() • MOST RECENT, ACTIVE BINDING WHEN FIRST() IS EXECUTED • SO VARIABLE LOCAL TO SECOND() IS MODIFIED, NOT GLOBAL VARIABLE • BUT, WRITE() PRINTS GLOBAL VARIABLE SINCE VARIABLE A LOCAL TO SECOND() IS NO LONGER ACTIVE!

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson THE MEANING OF NAMES WITHIN A SCOPE

• ALIASING: • TWO NAMES POINT TO THE SAME OBJECT • MAKES PROGRAM HARD TO UNDERSTAND • MAKES PROGRAM SLOW TO COMPILE

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson THE MEANING OF NAMES WITHIN A SCOPE

• ALIASING EXAMPLE • PASSING VARIABLE BY REFERENCE TO SUBROUTINE THAT ALSO ACCESSES SAME VARIABLE DIRECTLY double sum, sum_of_squares; ... void accumulate(double& x) // x is passed by reference { sum += x; sum_of_squares += x * x; } ... sum passed as an argument to accumulate(sum); accumulate(), so, sum and x

are aliases of one another24

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson THE MEANING OF NAMES WITHIN A SCOPE

• ALIASING (CONT.): • WHAT ARE ALIASES GOOD FOR? • SPACE SAVING - MODERN DATA ALLOCATION METHODS ARE BETTER • MULTIPLE REPRESENTATIONS - UNIONS ARE BETTER • LINKED DATA STRUCTURES – LEGIT USE

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson THE MEANING OF NAMES WITHIN A SCOPE

• OVERLOADING: • SAME NAME, MORE THAN ONE MEANING • SOME OVERLOADING HAPPENS IN ALMOST ALL LANGUAGES • INTEGER ‘+’ VS. REAL ‘+’ • READ AND WRITE IN PASCAL • METHODS OVERLOADED BASED ON THE NUMBER AND TYPES OF PARAMETERS (DEPENDS ON LANGUAGE). • FUNCTION RETURN IN PASCAL • SOME LANGUAGES GET INTO OVERLOADING IN A BIG WAY • JAVA • C++

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson OVERLOADING & AMBIGUOUS INVOCATION Java throws compile error public class AmbiguousOverloading{ ‘max(int,double) is ambiguous public static void main(String[] args) { System.out.println(max(1, 2)); } public static double max(int num1, double num2) { if (num1 > num2) return num1; else return num2; } public static double max(double num1, int num2) { if (num1 > num2) return num1; else return num2; } } CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione 27 (SUNY Korea) and Pearson THE MEANING OF NAMES WITHIN A SCOPE • WORTH DISTINGUISHING BETWEEN SOME CLOSELY RELATED CONCEPTS: • OVERLOADED FUNCTIONS - TWO DIFFERENT METHODS WITH THE SAME NAME. C++ => • OVERLOAD NORM int norm (int a) { return a>0 ? a : -a; } complex norm (complex c ) { // ...

• POLYMORPHIC FUNCTIONS - ONE FUNCTION THAT WORKS IN MORE THEN ONE WAY • OVERRIDING IN OO PROGRAMMING • GENERIC PROGRAMMING: FUNCTION MIN (A : ARRAY OF INTEGER); … • GENERIC FUNCTIONS - A SYNTACTIC TEMPLATE THAT CAN BE INSTANTIATED IN MORE THAN ONE WAY AT COMPILE TIME • VIA MACRO PROCESSORS IN C++ (BUILT-IN IN C++) 28

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson POLYMORPHISM, DYNAMIC BINDING AND GENERIC PROGRAMMING

public class PolymorphismDemo { public static void main(String[] args) { m(new GraduateStudent()); m(new Student()); m() takes parameter of Object type – m(new Person()); can be invoked with any object m(new Object()); } public static void m(Object x) { Polymorphism: an object of a subtype can be System.out.println(x.toString()); used wherever its super-type value is } required } class GraduateStudent extends Student{ } class Student extends Person { Dynamic binding: the Java Virtual Machine public String toString() { determines dynamically at runtime which return "Student"; implementation is used by the method } } class Person extends Object{ public String toString() { When m(Object x) is return "Person"; executed, the argument x’s toString() } method is invoked } CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione 29 (SUNY Korea) and Pearson DYNAMIC BINDING

• SUPPOSE AN OBJECT O IS AN INSTANCE OF CLASSES C1, C2, ..., CN-1, AND CN

• C1 IS A SUBCLASS OF C2, C2 IS A SUBCLASS OF C3, ..., AND CN-1 IS A

SUBCLASS OF CN

• CN IS MOST GENERAL CLASS; C1 IS MOST SPECIFIC CLASS • IF O INVOKES A METHOD P

• JVM SEARCHES IMPLEMENTATION FOR METHOD P IN C1, C2, ..., CN-1 AND CN, IN THIS ORDER, UNTIL FOUND • SEARCH STOPS AND FIRST-FOUND IMPLEMENTATION IS INVOKED

Since o is an instance of C1, o is also an instance of C2, C2, …, Cn-1, and Cn 30

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson DYNAMIC BINDING public class PolymorphismDemo { Output: public static void main(String[] args) { m(new GraduateStudent()); Student m(new Student()); Student m(new Person()); Person m(new Object()); } java.lang.Object@1234567 public static void m(Object x) { 8 System.out.println(x.toString()); } } class GraduateStudent extends Student { } class Student extends Person { public String toString() { return "Student"; } } class Person extends Object { public String toString() { return "Person"; } } CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione 31 (SUNY Korea) and Pearson METHOD MATCHING VS. BINDING

• COMPILER FINDS A MATCHING METHOD AT COMPILATION TIME ACCORDING TO • NUMBER OF PARAMETERS • PARAMETER TYPES • ORDER OF THE PARAMETERS • THE JAVA VIRTUAL MACHINE DYNAMICALLY BINDS THE IMPLEMENTATION OF THE METHOD AT RUNTIME [PREVIOUS SLIDE]

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson BINDING OF REFERENCING ENVIRONMENTS

• ACCESSING VARIABLES WITH DYNAMIC SCOPE: • (1) KEEP A STACK (ASSOCIATION LIST) • HOLDS ALL ACTIVE VARIABLES • WHEN VARIABLE IS NEEDED, HUNT DOWN FROM TOP OF STACK • EQUIVALENT TO SEARCHING ACTIVATION RECORDS ON A DYNAMIC CHAIN • (2) KEEP A CENTRAL TABLE WITH ONE SLOT FOR EACH VARIABLE NAME • NAMES CANNOT BE CREATED AT RUN TIME: • THE TABLE LAYOUT (AND THE LOCATION OF EVERY SLOT) CAN BE FIXED AT COMPILE TIME • NAMES CAN BE CREATED AT RUN TIME: • NEED A HASH FUNCTION OR OTHER MECHANISM TO DO LOOKUP • EVERY SUBROUTINE CHANGES TABLE ENTRIES FOR ITS LOCALS ON ENTRY/EXIT • ADD LOCAL VARIABLES ON ENTRY • REMOVE LOCAL VARIABLES ON EXIT 33

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson BINDING OF REFERENCE ENVIRONMENTS

• (1) GIVES YOU SLOW ACCESS BUT FAST CALLS • (2) GIVES YOU SLOW CALLS BUT FAST ACCESS • VARIABLE LOOKUP [DYNAMICALLY-SCOPED] = SYMBOL TABLE LOOKUP [STATICALLY-SCOPED] • STATIC SCOPE RULES USUALLY MORE COMPLICATED ➔ DATA STRUCTURE/LOOKUP ALGORITHM ALSO MORE COMPLICATED

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson SEPARATE COMPILATION

• SEPARATELY-COMPILED FILES IN C PROVIDE A SORT OF POOR PERSON'S MODULES: • RULES FOR HOW VARIABLES WORK ARE MESSY • LANGUAGE HAS BEEN JERRY-RIGGED TO MATCH BEHAVIOR OF THE LINKER • STATIC ON FUNCTION OR VARIABLE OUTSIDE A FUNCTION • USABLE ONLY IN CURRENT SOURCE FILE • THIS STATIC IS DIFFERENT FROM STATIC VARIABLES INSIDE A FUNCTION • EXTERN ON VARIABLE OR FUNCTION • DECLARED IN ANOTHER SOURCE FILE • FUNCTION HEADERS WITHOUT BODIES ARE EXTERN BY DEFAULT • EXTERN DECLARATIONS INTERPRETED AS FORWARD DECLARATIONS WHEN LATER DECLARATION OVERRIDES THEM

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson SEPARATE COMPILATION

• SEPARATELY-COMPILED FILES IN C (CONTINUED) • VARIABLES OR FUNCTIONS (WITH BODIES) WITHOUT STATIC OR EXTERN • EITHER GLOBAL OR COMMON (A FORTRAN TERM) • FUNCTIONS AND VARIABLES GIVEN INITIAL VALUES ARE GLOBAL • VARIABLES THAT NOT GIVEN INITIAL VALUES ARE COMMON • MATCHING COMMON DECLARATIONS IN DIFFERENT FILES REFER TO THE SAME VARIABLE • ALSO REFER TO THE SAME VARIABLE AS A MATCHING GLOBAL DECLARATION

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson MACROS MACROS ARE A WAY OF ASSIGNING A NAME TO SOME SYNTAX. C: TEXTUAL SUBSTITUTION. #define MAX(x, y) (x > y ? x : y) BENEFITS: SHORTER CODE NO STACK CAN CHOOSE NOT TO EXECUTE SOME OF THE CODE PROBLEMS WITH MACROS: MULTIPLE SIDE EFFECTS: MAX(a++, b++) BINDING: MAX(1 | a, b) - WE HAVE TO CHANGE OUR MACRO TO #define MAX(x, y) ((x) > (y) ? (x) : (y)) SCOPE CAPTURE: TEMP VAR USED INSIDE MACRO HAS SAME NAME AS REAL VAR

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione 37 (SUNY Korea) and Pearson QUESTIONS

CS307 : Principles of Programming Languages - (c) Paul Fodor (CS Stony Brook), Tony Mione (SUNY Korea) and Pearson