1 / 18

Semantics of Procedures and Scopes

Semantics of Procedures and Scopes. Kinds of Scope. Static or Lexical scope determined by structure of program Scheme, C++, Java, and many compiled languages Dynamic scope determined by path of execution Lisp dialects, Perl, and many interpreted languages Global Scope File scope

alannis
Télécharger la présentation

Semantics of Procedures and Scopes

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Semantics of Procedures and Scopes

  2. Kinds of Scope • Static or Lexical scope • determined by structure of program • Scheme, C++, Java, and many compiled languages • Dynamic scope • determined by path of execution • Lisp dialects, Perl, and many interpreted languages • Global Scope • File scope • Local Scope • Block • Body of a procedure • Body of a loop • Scope alters the meaning

  3. proc main() int x := 5; proc q() { x := x + 1;} proc r() {int x := 0; q(); } { r(); print(x); }. Static scoping x -> x output: 6 Dynamic scoping x-> x output: 5 Scoping : Free (non-local) Variables

  4. letx = 15 in let f = proc () x in ( letx = 8 in (f) ) + (f) Static Scoping x -> x30 Dynamic Scoping x -> x23 x -> x

  5. Informal Semantics of Procedures • Procedure Definition • Store formal parameters and body • Procedure Invocation • Evaluate body in an environment that binds formals to actual argument values • Interpretation of free-variables • Use env. at proc. creation (static scoping) • Use env. at proc. call (dynamic scoping)

  6. Procedures: Syntaxes • Concrete Syntax <expression> ::= … | ( <expression> +) | proc <idlist> <expression> <idlist> ::= () | ( <identifier> {, <identifier>}*) • Abstract Syntax proc-exp (ids body) app-exp (ratorrands)

  7. Encoding Procedures • Static scoping (define-datatypeprocvalprocval? (closure (ids (list-of symbol?) (body expression?) (env environment?))) Closure retains the bindings of the free variables at procedure creation time. • Dynamic scoping (define-datatypeprocvalprocval? (procv (ids (list-of symbol?) (body expression?)))

  8. Processing Procedure Definitions • Static scoping (define (eval-expression exp env) (cases expression exp (proc-exp (ids body) (closure idsbodyenv)) )) • Dynamic scoping (define (eval-expression exp env) (cases expression exp (proc-exp (ids body) (procvidsbody)) ))

  9. Processing Procedure Invocations: • Static scoping (define (eval-expression exp env) (cases expression exp . . . (app-exp (ratorrands) (let ((proc (eval-expression ratorenv)) (args (eval-randsrandsenv))) (if (procval? proc) (apply-procval proc args) (eopl:error 'eval-expression “Applying non-procedure ~s" proc) ) ))

  10. Processing Procedure Invocations • Dynamic scoping (define (eval-expression exp env) (cases expression exp (app-exp (rator rands) . . . (let ((proc (eval-expression ratorenv)) (args (eval-rands randsenv))) (if (procval? proc) (apply-procval proc args env) (eopl:error 'eval-expression "Applying non-procedure ~s" proc) ) ))

  11. Processing Procedure Invocations • Static scoping (define (apply-procval proc args) (cases procval proc (closure (ids body s-env) (eval-expression body (extend-envids argss-env)) ))) • Dynamic scoping (define (apply-procval proc argsc-env) (cases procval proc (procv(ids body) (eval-expression body (extend-envidsargsc-env)) )))

  12. Processing Procedure Invocations >(run "let x = 1 in let f = proc () x in (f)") 1 >(run "let x = 1 in let f = proc (x) x in (f 2)") 2 • Static scoping >(run "let x = 1 in let f = proc () x x = 5 in (f)") 1 • Dynamic scoping >(run "let x = 1 in let f = proc () x x = 5 in (f)") 5

  13. Alternative Description: Static Scoping (define (closure ids body env) (lambda (args) (eval-expression body (extend-env ids argsenv)) ) ) (define (apply-procval procargs) (procargs) )

  14. Implementing Dynamic Scoping • The value of variable x is the last value bound to x. => stack discipline • Deep binding • Use a global stack for all variables • Shallow binding • Use a separate stack for each variable • Implementing recursion is trivial. • Meaning of a call depends on the context.

  15. Lexical Scope Pros and Cons • Scope of names is known to the compiler. • Permits type checking by compiler • Easily check for uninitialized variables • Easier to analyze program correctness • Recursion is harder to implement

  16. Dynamic Scope Pros and Cons • Meaning of variables known only at run-time. • Cannot perform type checking before execution • Programs are flexible, but harder to understand • Easy to implement recursion • Renaming in the caller can effect the semantics of a program • Locality of formals destroyed. • if renamed parameter now captures a free variable in the called function. • Recall the interpretation of a free variable in a function body can change based on the context (environment) of a call.

  17. Application of Dynamic Scoping • Exception Handling • provide a separate construct in statically scoped language • Setting Local Formatting Parameters • Input-Output Redirection • avoids passing parameters explicitly through “intermediate” procedures

  18. > (define x 1) > (define (f) x) > (f) 1 > (define x 2) > (f) 2 > (define (g) x) > x 2 > (g) 2 - val x = 1; - fun f () = x; val f = fn : unit -> int - f (); val it = 1 : int - val x = 2; - f () ; val it = 1 : int - fun g () = x; val g = fn : unit -> int - g (); val it = 2: int Difference between Scheme and ML

More Related