dmd.escape - D Programming Language
Description: D Programming Language
Keywords: D programming language

Menu

- Learn
- Documentation
  - Language Reference
  - Library Reference
  - Command-line Reference
  - Feature Overview
  - Articles
- Downloads
- Packages
- Community
  - Blog
  - Orgs using D
  - Twitter
  - Calendar
  - Forums
  - IRC
  - Wiki
  - GitHub
  - Issues
  - Get involved
  - Contributors
  - Foundation
  - Donate
  - Sponsors
- Resources
  - Tour
  - Books
  - Tutorials
  - Tools
  - Editors
  - IDEs
  - Visual D
  - Acknowledgments
  - D Style
  - Glossary
  - Sitemap

Search
Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using a local clone.

# dmd.escape

Compiler implementation of the D programming language.
Authors:
Walter Bright
License:
Boost License 1.0

Source escape.d

Documentation https://dlang.org/phobos/dmd_escape.html

Coverage https://codecov.io/gh/dlang/dmd/src/master/src/dmd/escape.d

bool `checkArrayLiteralEscape`(Scope* `sc`, ArrayLiteralExp `ae`, bool `gag`);
  Array literal is going to be allocated on the GC heap. Check its elements to see if any would escape by going on the heap.
  Parameters:

  Scope* `sc` | used to determine current function and module
  ArrayLiteralExp `ae` | array literal expression
  bool `gag` | do not print error messages

  Returns:
  true if any elements escaped
bool `checkAssocArrayLiteralEscape`(Scope* `sc`, AssocArrayLiteralExp `ae`, bool `gag`);
  Associative array literal is going to be allocated on the GC heap. Check its elements to see if any would escape by going on the heap.
  Parameters:

  Scope* `sc` | used to determine current function and module
  AssocArrayLiteralExp `ae` | associative array literal expression
  bool `gag` | do not print error messages

  Returns:
  true if any elements escaped
bool `checkParamArgumentEscape`(Scope* `sc`, FuncDeclaration `fdc`, Identifier `par`, Expression `arg`, bool `gag`);
  Function parameter par is being initialized to arg, and par may escape. Detect if scoped values can escape this way. Print error messages when these are detected.
  Parameters:

  Scope* `sc` | used to determine current function and module
  FuncDeclaration `fdc` | function being called, null if called indirectly
  Identifier `par` | identifier of function parameter
  Expression `arg` | initializer for param
  bool `gag` | do not print error messages

  Returns:
  true if pointers to the stack can escape via assignment
bool `checkAssignEscape`(Scope* `sc`, Expression `e`, bool `gag`);
  Given an AssignExp, determine if the lvalue will cause the contents of the rvalue to escape. Print error messages when these are detected. Infer 'scope' for the lvalue where possible, in order to eliminate the error.
  Parameters:

  Scope* `sc` | used to determine current function and module
  Expression `e` | AssignExp or CatAssignExp to check for any pointers to the stack
  bool `gag` | do not print error messages

  Returns:
  true if pointers to the stack can escape via assignment
bool `checkThrowEscape`(Scope* `sc`, Expression `e`, bool `gag`);
  Detect cases where pointers to the stack can 'escape' the lifetime of the stack frame when throwing `e`. Print error messages when these are detected.
  Parameters:

  Scope* `sc` | used to determine current function and module
  Expression `e` | expression to check for any pointers to the stack
  bool `gag` | do not print error messages

  Returns:
  true if pointers to the stack can escape
bool `checkNewEscape`(Scope* `sc`, Expression `e`, bool `gag`);
  Detect cases where pointers to the stack can 'escape' the lifetime of the stack frame by being placed into a GC allocated object. Print error messages when these are detected.
  Parameters:

  Scope* `sc` | used to determine current function and module
  Expression `e` | expression to check for any pointers to the stack
  bool `gag` | do not print error messages

  Returns:
  true if pointers to the stack can escape
bool `checkReturnEscape`(Scope* `sc`, Expression `e`, bool `gag`);
  Detect cases where pointers to the stack can 'escape' the lifetime of the stack frame by returning 'e' by value. Print error messages when these are detected.
  Parameters:

  Scope* `sc` | used to determine current function and module
  Expression `e` | expression to check for any pointers to the stack
  bool `gag` | do not print error messages

  Returns:
  true if pointers to the stack can escape
bool `checkReturnEscapeRef`(Scope* `sc`, Expression `e`, bool `gag`);
  Detect cases where returning 'e' by ref can result in a reference to the stack being returned. Print error messages when these are detected.
  Parameters:

  Scope* `sc` | used to determine current function and module
  Expression `e` | expression to check
  bool `gag` | do not print error messages

  Returns:
  true if references to the stack can escape
void `findAllOuterAccessedVariables`(FuncDeclaration `fd`, VarDeclarations* `vars`);
  Find all variables accessed by this delegate that are in functions enclosing it.
  Parameters:

  FuncDeclaration `fd` | function
  VarDeclarations* `vars` | array to append found variables to

void `notMaybeScope`(VarDeclaration `v`);
  Turn off STC.maybescope for variable `v`. This exists in order to find where STC.maybescope is getting turned off.
  Parameters:

  VarDeclaration `v` | variable

Copyright © 1999-2018 by the D Language Foundation | Page generated by Ddoc on Thu Jun 7 15:29:14 2018