org.apache.flex.compiler.internal.as.codegen

Class LexicalScope

java.lang.Object

org.apache.flex.compiler.internal.as.codegen.LexicalScope

Direct Known Subclasses:

GlobalLexicalScope, InlineFunctionLexicalScope

public class LexicalScope
extends Object

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	LexicalScope.NestingState The nesting state of a function.
protected static class	LexicalScope.TempManager Utility class to manage the allocation and merging of temps within lexical scopes.
static class	LexicalScope.VariableMutability Mutability settings for a variable declaration.

Field Summary

Fields

Modifier and Type	Field and Description
static Name	anyType The "*" type.
static int	DEBUG_LINE_UNKNOWN Manifest constant for "debug line number not known."
protected MethodBodySemanticChecker	methodBodySemanticChecker The semantic checker for this compilation.
static Object	noInitializer Constant initializer not present.

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	LexicalScope() constructor which should only ever be called by GlobalLexicalScope
protected	LexicalScope(LexicalScope enclosingFrame) constructor which is called whenever pushing a new lexical scope
protected	LexicalScope(LexicalScope enclosingFrame, boolean mergableTempManager) constructor which is called whenever pushing a new lexical scope, and the temps are potentially going to be shared with enclosing scope.

Method Summary

Methods

Modifier and Type	Method and Description
void	addDefaultValue(PooledValue value) Add a default value to the currently compiling method.
protected void	addHasNexts(Collection<org.apache.flex.compiler.internal.as.codegen.LexicalScope.Hasnext2Wrapper> nexts) Add a collection of hasnext wrappers to the collection of hasnexts in this lexical scope.
protected void	addInlinedBindings(Collection<Binding> bindings) Add a collection of bindings to the collection of inlined bindings in this lexical scope.
void	addProblem(ICompilerProblem problem) Add a problem to this code generation phase.
void	addProblems(Collection<ICompilerProblem> problems) Add a collection of problems to this code generation phase.
Binding	allocateTemp() Allocate a temporary register.
Binding	allocateTemp(boolean reuse_free) Allocate a temporary register.
void	declareVariableName(Name n) Add a variable name to the set of known names.
boolean	emitFile(String candidate)
boolean	emitLine(int candidate)
InstructionList	findProperty(Binding binding, boolean useStrict) Get the property for the specified binding.
InstructionList	findProperty(Name name, IDefinition def, boolean useStrict) Get the property for the specified name.
void	finishClassStaticInitializer(InstructionList cinit_insns) Finish a class static initializer method.
void	generateBindableGetter(IDefinition bindableVarDef, Name var_name, Name backingPropertyName, Name var_type, IMetaInfo[] metaTags)
void	generateBindableSetter(IDefinition bindableVarDef, Name var_name, Name backingPropertyName, Name var_type, IMetaInfo[] metaTags)
Binding	getBinding(IASNode node, Name name, IDefinition def) Get or create the Binding for a Name and its associated IDefinition.
Binding	getBinding(IDefinition def) Get or create the Binding for an IDefinition.
String	getDebugFile()
LexicalScope	getEnclosingFrame()
ControlFlowContextManager	getFlowManager() Create a ControlFlowContextManager on demand.
ICodeGenerator	getGenerator()
GlobalLexicalScope	getGlobalScope()
protected Collection<org.apache.flex.compiler.internal.as.codegen.LexicalScope.Hasnext2Wrapper>	getHasNexts()
boolean	getInInvisibleCompilationUnit()
InstructionList	getInitInstructions()
IASScope	getLocalASScope()
protected Collection<Binding>	getLocalBindings()
MethodBodySemanticChecker	getMethodBodySemanticChecker()
MethodInfo	getMethodInfo()
LexicalScope.NestingState	getNestingState()
Vector<Name>	getParamTypes()
Collection<ICompilerProblem>	getProblems()
ICompilerProject	getProject()
InstructionList	getPropertyValue(Binding binding) Get the property value for the specified binding.
InstructionList	getPropertyValue(Name name, IDefinition def) Get the property value for the specified name.
protected Binding	getThisBinding(IdentifierNode id) Fetch the Binding that represents "this."
void	initializeTempRegisters(int base) Give all temporaries a register number.
boolean	insideInlineFunction() Test whether we are currently inside the scope of a function being inlined.
boolean	isGlobalScope()
boolean	isLocalDefinition(IDefinition candidate)
void	makeBindableVariable(Binding var, Name var_type, IMetaInfo[] metaTags) Create a bindable property.
void	makeNamespace(Binding ns_binding, Namespace ns_init) Declare and define a namespace.
void	makeParameter(IDefinition def, Name param_type) Declare an explicit parameter.
void	makeVariable(Binding var) Create a variable with potential visibility to nested scopes.
void	makeVariable(Binding var, Name var_type, IMetaInfo[] meta_tags) Create a variable with potential visibility to nested scopes.
void	makeVariable(Binding var, Name var_type, IMetaInfo[] meta_tags, Object initializer) Create a variable with potential visibility to nested scopes.
void	makeVariable(Binding var, Name var_type, IMetaInfo[] meta_tags, Object initializer, LexicalScope.VariableMutability mutability) Create a variable with potential visibility to nested scopes.
protected void	mergeTemps(LexicalScope scopeToMerge) Merge the temps from the specified lexical scope into this lexical scope.
boolean	needsActivation()
boolean	needsArguments()
boolean	needsHoistedInitInsns(Name var_name, boolean has_initializer) Helper method to determine if a variable binding has already been referenced.
boolean	needsThis()
LexicalScope	popFrame() Pop the current lexical scope.
void	processMetadata(ITraitVisitor tv, IMetaInfo[] meta_infos) Metadata management - works on IMetaInfo, which is a common interface of IMetaTagNode and IMetaTag.
LexicalScope	pushFrame() Push a new lexical scope.
InlineFunctionLexicalScope	pushInlineFunctionFrame(IASScope containingScope, boolean storeClassBinding, FunctionNode functionNode) Push a new lexical scope for a function being inlined.
void	releaseTemp(Binding temp) Release a temporary register.
void	resetDebugInfo() Reset the debug info to initial values.
void	resetMethodInfo() Reset this scope's MethodInfo to null; called from a ClassDirectiveProcessor's static initialization error recovery logic.
Binding	resolveName(IdentifierNode id) Resolve a name, and return a Binding for it.
void	setDebugFile(String file_name) Set the debug info file name.
void	setDebugLine(int line_num) Set the debug info line number.
void	setLocalASScope(IASScope scope) Set this LexicalScope's corresponding ASScope.
void	setMethodInfo(MethodInfo methodInfo) sets this scope's MethodInfo,
void	setNeedsActivation() Turn on thie scope's method's NEED_ACTIVATION flag; this will cause the AVM to allocate an activation object when the method is called.
void	setNeedsArguments() Turn on this scope's method's NEED_ARGUMENTS flag; this will cause the AVM to allocate an implicit arguments parameter when the method is called.
void	setNeedsRest() Turn on this scope's NEED_REST flag.
void	setSetsDxns() Turn on this scope's SETS_DXNS flag.
void	transferInitializerData() Transfer information about local initializers from the scope in which they were declared (the class or instance scope) to this scope (a constructor).

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

anyType

public static final Name anyType

The "*" type.

noInitializer

public static final Object noInitializer

Constant initializer not present.

DEBUG_LINE_UNKNOWN

public static final int DEBUG_LINE_UNKNOWN

Manifest constant for "debug line number not known."

See Also:

Constant Field Values

methodBodySemanticChecker

protected MethodBodySemanticChecker methodBodySemanticChecker

The semantic checker for this compilation.

Constructor Detail

LexicalScope

protected LexicalScope()

constructor which should only ever be called by GlobalLexicalScope

LexicalScope

protected LexicalScope(LexicalScope enclosingFrame)

constructor which is called whenever pushing a new lexical scope

Parameters:

enclosingFrame - the parent frame

LexicalScope

protected LexicalScope(LexicalScope enclosingFrame,
            boolean mergableTempManager)

constructor which is called whenever pushing a new lexical scope, and the temps are potentially going to be shared with enclosing scope.

Parameters:

enclosingFrame - the parent frame

Method Detail

makeVariable

public void makeVariable(Binding var)

Create a variable with potential visibility to nested scopes.

Parameters:

var - The variable binding

makeVariable

public void makeVariable(Binding var,
                Name var_type,
                IMetaInfo[] meta_tags)

Create a variable with potential visibility to nested scopes.

Parameters:

var - The variable binding

var_type - The Name of the type of the variable

meta_tags - The metadata on the variable

makeVariable

public void makeVariable(Binding var,
                Name var_type,
                IMetaInfo[] meta_tags,
                Object initializer)

Create a variable with potential visibility to nested scopes.

Parameters:

var - The variable binding

var_type - The Name of the type of the variable

meta_tags - The metadata on the variable

initializer - An initializer. null if no initializer. only consts can have an initializer

makeVariable

public void makeVariable(Binding var,
                Name var_type,
                IMetaInfo[] meta_tags,
                Object initializer,
                LexicalScope.VariableMutability mutability)

Create a variable with potential visibility to nested scopes.

Parameters:

var - The variable binding

var_type - The Name of the type of the variable

meta_tags - The metadata on the variable

initializer - An initializer. null if no initializer. only consts can have an initializer

mutability - - the caller's desired mutability.

needsHoistedInitInsns

public boolean needsHoistedInitInsns(Name var_name,
                            boolean has_initializer)

Helper method to determine if a variable binding has already been referenced. When called before makeVariable, it can be used to determine if the var was referenced before it was initialized, which means it will need hoisted init instructions to make sure it has the right initial value.

Parameters:

var_name - The name for the variable

Returns:

true if the binding for var_name is already in the localBindings table

declareVariableName

public void declareVariableName(Name n)

Add a variable name to the set of known names.

Parameters:

n - - the Name to add.

makeBindableVariable

public void makeBindableVariable(Binding var,
                        Name var_type,
                        IMetaInfo[] metaTags)

Create a bindable property. This will create a getter/setter that will do the bindable magic, and a backing property that will store the actual value.

This method must only be called on the thread that started code generation of the syntax tree that contains the bindable variable. This constraint is met today, because we do not generate code for classes in parallel and bindable variables are always be class members.

Parameters:

metaTags - The IMetaTagsNode representing the metadata nodes for this definition. If it is null, this method will ask the varDef for the metadata - some callers of this method will not have an MetaTagsNode in the AST, and want the metadata from the definition

generateBindableGetter

public void generateBindableGetter(IDefinition bindableVarDef,
                          Name var_name,
                          Name backingPropertyName,
                          Name var_type,
                          IMetaInfo[] metaTags)

generateBindableSetter

public void generateBindableSetter(IDefinition bindableVarDef,
                          Name var_name,
                          Name backingPropertyName,
                          Name var_type,
                          IMetaInfo[] metaTags)

makeNamespace

public void makeNamespace(Binding ns_binding,
                 Namespace ns_init)

Declare and define a namespace.

Parameters:

ns_binding - - the namespace declaration's binding.

ns_init - - the namespace definition's initial AET Namespace. May not be null.

makeParameter

public void makeParameter(IDefinition def,
                 Name param_type)

Declare an explicit parameter.

Parameters:

def - - the parameter's definition.

param_type - - the name of the parameter's type.

addDefaultValue

public void addDefaultValue(PooledValue value)

Add a default value to the currently compiling method.

See Also:

which is called first.

needsThis

public boolean needsThis()

Returns:

true if "this" needed.

getParamTypes

public Vector<Name> getParamTypes()

Returns:

the types of this scope's function parameters.

getMethodInfo

public MethodInfo getMethodInfo()

Returns:

this scope's MethodInfo, or null if none present.

setMethodInfo

public void setMethodInfo(MethodInfo methodInfo)

sets this scope's MethodInfo,

resetMethodInfo

public void resetMethodInfo()

Reset this scope's MethodInfo to null; called from a ClassDirectiveProcessor's static initialization error recovery logic.

allocateTemp

public Binding allocateTemp()

Allocate a temporary register. The temp is assumed to hold the "*" type.

Returns:

the temp register's Binding. A temp's Binding is used to hold the get/set/kill, etc., instructions that relate to it.

allocateTemp

public Binding allocateTemp(boolean reuse_free)

Allocate a temporary register.

Parameters:

reuse_free - - re-use a free temp if set.

Returns:

the temp's local number.

releaseTemp

public void releaseTemp(Binding temp)

Release a temporary register.

Parameters:

temp - - the temp's Binding.

See Also:

allocateTemp()

mergeTemps

protected void mergeTemps(LexicalScope scopeToMerge)

Merge the temps from the specified lexical scope into this lexical scope.

Parameters:

scopeToMerge - the scope containing the temps to merge

addInlinedBindings

protected void addInlinedBindings(Collection<Binding> bindings)

Add a collection of bindings to the collection of inlined bindings in this lexical scope.

Parameters:

bindings - the bindings to add

addHasNexts

protected void addHasNexts(Collection<org.apache.flex.compiler.internal.as.codegen.LexicalScope.Hasnext2Wrapper> nexts)

Add a collection of hasnext wrappers to the collection of hasnexts in this lexical scope.

Parameters:

nexts - the hasnexts to add

getHasNexts

protected Collection<org.apache.flex.compiler.internal.as.codegen.LexicalScope.Hasnext2Wrapper> getHasNexts()

Returns:

collection of Hasnext2Wrappers

getLocalBindings

protected Collection<Binding> getLocalBindings()

Returns:

All the local bindings in the lexical scope.

getLocalASScope

public IASScope getLocalASScope()

Returns:

the LexicalScope's corresponding ASScope.

setLocalASScope

public void setLocalASScope(IASScope scope)

Set this LexicalScope's corresponding ASScope.

isLocalDefinition

public boolean isLocalDefinition(IDefinition candidate)

Parameters:

candidate - - the IDefinition under examination.

Returns:

true if the candidate definition is local to this LexicalScope's corresponding ASScope.

resolveName

public Binding resolveName(IdentifierNode id)

Resolve a name, and return a Binding for it. The Binding will include information such as the multiname (or qname), and local register info

Parameters:

id - The IdentifierNode you need a Binding for

Returns:

A Binding

getBinding

public Binding getBinding(IDefinition def)

Get or create the Binding for an IDefinition.

Parameters:

def - - the IDefinition.

Returns:

said Binding.

getBinding

public Binding getBinding(IASNode node,
                 Name name,
                 IDefinition def)

Get or create the Binding for a Name and its associated IDefinition.

Parameters:

name - - the name under consideration.

def - - the name's IDefinition.

Returns:

said Binding.

getThisBinding

protected Binding getThisBinding(IdentifierNode id)

Fetch the Binding that represents "this."

Returns:

said Binding.

findProperty

public InstructionList findProperty(Binding binding,
                           boolean useStrict)

Get the property for the specified binding. Use this method rather than using findprop directly, because inlining needs to do some magic

Parameters:

binding - Binding of the property to find

useStrict - Use OP_findpropstrict

Returns:

InstructionList

findProperty

public InstructionList findProperty(Name name,
                           IDefinition def,
                           boolean useStrict)

Get the property for the specified name. Use this method rather than using findprop directly, because inlining needs to do some magic

Parameters:

name - Name of the property to find

def - Definition of the property to find

useStrict - Use OP_findpropstrict

Returns:

InstructionList

getPropertyValue

public InstructionList getPropertyValue(Binding binding)

Get the property value for the specified binding. Use this method rather than using getlex directly, because inlining needs to do some magic

Parameters:

binding - Binding of the property to find

Returns:

InstructionList

getPropertyValue

public InstructionList getPropertyValue(Name name,
                               IDefinition def)

Get the property value for the specified name. Use this method rather than using getlex directly, because inlining needs to do some magic

Parameters:

name - Name of the property to find

def - Definition of the property to find

Returns:

InstructionList

getEnclosingFrame

public LexicalScope getEnclosingFrame()

Returns:

this scope's enclosing scope.

finishClassStaticInitializer

public void finishClassStaticInitializer(InstructionList cinit_insns)

Finish a class static initializer method.

Parameters:

cinit_insns - - initialization instructions. Classes may have ad-hoc static initialization code, so the content of this list is arbitrary.

initializeTempRegisters

public void initializeTempRegisters(int base)

Give all temporaries a register number.

pushFrame

public LexicalScope pushFrame()

Push a new lexical scope.

Returns:

the new scope.

pushInlineFunctionFrame

public InlineFunctionLexicalScope pushInlineFunctionFrame(IASScope containingScope,
                                                 boolean storeClassBinding,
                                                 FunctionNode functionNode)

Push a new lexical scope for a function being inlined.

Returns:

the new scope.

insideInlineFunction

public boolean insideInlineFunction()

Test whether we are currently inside the scope of a function being inlined.

Returns:

true if currently inside an inline function.

popFrame

public LexicalScope popFrame()

Pop the current lexical scope.

Returns:

the enclosing lexical scope.

isGlobalScope

public boolean isGlobalScope()

Returns:

true if this scope is the root of a scope chain.

getGlobalScope

public final GlobalLexicalScope getGlobalScope()

Returns:

the root of this scope chain.

needsActivation

public boolean needsActivation()

Returns:

true if this scope's method needs an activation record.

setNeedsActivation

public void setNeedsActivation()

Turn on thie scope's method's NEED_ACTIVATION flag; this will cause the AVM to allocate an activation object when the method is called.

needsArguments

public boolean needsArguments()

Returns:

true if this scope's method needs an "arguments" array.

setNeedsArguments

public void setNeedsArguments()

Turn on this scope's method's NEED_ARGUMENTS flag; this will cause the AVM to allocate an implicit arguments parameter when the method is called.

setNeedsRest

public void setNeedsRest()

Turn on this scope's NEED_REST flag.

setSetsDxns

public void setSetsDxns()

Turn on this scope's SETS_DXNS flag.

getFlowManager

public ControlFlowContextManager getFlowManager()

Create a ControlFlowContextManager on demand.

Returns:

the ControlFlowContextManager associated with this scope.

processMetadata

public void processMetadata(ITraitVisitor tv,
                   IMetaInfo[] meta_infos)

Metadata management - works on IMetaInfo, which is a common interface of IMetaTagNode and IMetaTag.

emitFile

public boolean emitFile(String candidate)

Returns:

true if the new file name is valid and does not match the existing file name, in which case the caller should emit a debugfile instruction and reset the file name.

emitLine

public boolean emitLine(int candidate)

Returns:

true if the current file name is valid, and the new line number is valid and does not equal the existing line number, in which case the caller should emit a debugline instruction and reset the line number.

setDebugFile

public void setDebugFile(String file_name)

Set the debug info file name.

Parameters:

file_name - - the name to set. May be null.

getDebugFile

public String getDebugFile()

Returns:

the current debug info file name. May be null

setDebugLine

public void setDebugLine(int line_num)

Set the debug info line number.

Parameters:

line_num - - the line number to set.

resetDebugInfo

public void resetDebugInfo()

Reset the debug info to initial values.

getNestingState

public LexicalScope.NestingState getNestingState()

transferInitializerData

public void transferInitializerData()

Transfer information about local initializers from the scope in which they were declared (the class or instance scope) to this scope (a constructor).

getProject

public ICompilerProject getProject()

Returns:

this scope's compiler project.

getGenerator

public ICodeGenerator getGenerator()

Returns:

the code generator that this lexical scope is using.

getInInvisibleCompilationUnit

public boolean getInInvisibleCompilationUnit()

Returns:

true if this scope is for an invisible compilation unit. In this case, IDefinition's for package/file classes, interfaces, function's, var's, const's, and namespaces need to be normalized before comparing them by identity in some semantic checks ( namely the type conversion checks ). Also, in this case, we must do additional checking to determine whether an import is valid.

getInitInstructions

public InstructionList getInitInstructions()

Returns:

any initial instructions for this code generation phase.

getMethodBodySemanticChecker

public MethodBodySemanticChecker getMethodBodySemanticChecker()

Returns:

the MethodBodySemanticChecker covering this code generation phase.

getProblems

public Collection<ICompilerProblem> getProblems()

Returns:

the problems covering this code generation phase.

addProblem

public void addProblem(ICompilerProblem problem)

Add a problem to this code generation phase.

Parameters:

problem - The ICompilerProblem to add.

addProblems

public void addProblems(Collection<ICompilerProblem> problems)

Add a collection of problems to this code generation phase.

Parameters:

problems - The collection of ICompilerProblem objects to add.