org.apache.flex.compiler.internal.codegen.databinding

Class BindingCodeGenUtils

java.lang.Object

org.apache.flex.compiler.internal.codegen.databinding.BindingCodeGenUtils

public class BindingCodeGenUtils
extends Object

A bunch of static, low level helpers for generating instruction lists In this case, low-level means that these utilities don't know anything about our Databinding analysis strategy, what watchers are (other than some sdk class), directive processors etc.. Because of the "low level" nature of these utilties, they should generally take "simple types" as arguments, with the exception is IASNodes. There is no need to be super strict about this, of course. There are already cases here where we pass in BindingInfo rather that jumpthrough hoops (and CPU cycles) to extract the simple types.

Field Summary

Fields

Modifier and Type	Field and Description
static boolean	doLog

Method Summary

Methods

Modifier and Type	Method and Description
static InstructionList	fireInitialBindings() enumerate all the bindings we have created for this class, and execute each of them so that initial values get assigned to binding targets.
static void	generateGetter(IABCVisitor emitter, InstructionList ret, List<IExpressionNode> expressions, LexicalScope enclosing_scope) emits the code for anonymous getter function, then adds to the instruction list for instantiating one onto the stack
static MethodInfo	generatePropertyGetterFunction(IABCVisitor emitter, ICompilerProject project, ASScope scope) generate this function: function(propertyName:String):* { return target[propertyName]; } where target == "this"
static void	generateSetter(InstructionList ret, IExpressionNode expression, LexicalScope enclosing_scope) emits the code for anonymous setter function, then adds to the instruction list for instantiating one onto the stack
static void	log(InstructionList insns, String s)
static void	log(String s)
static void	makeBinding(InstructionList insns, FlexProject project, String destStr, String srcString, InstructionList methodInstr) generate code to instantiate a binding object.
static void	makeFunctionWatcher(InstructionList insns, FlexProject project, IABCVisitor emitter, String functionName, List<String> eventNames, List<BindingInfo> bindingInfo, IExpressionNode[] params) Generates the ABC to instantiate a FunctionReturnWatcher * VM context: on entry: nothing on stack local1 = this.
static void	makeParameterFunction(IABCVisitor emitter, InstructionList ret, IExpressionNode[] params) Generated the "parameter function" required by the FunctionReturnWatcher constructor.
static void	makePropertyWatcher(boolean makeStaticWatcher, InstructionList insns, String propertyName, List<String> eventNames, List<BindingInfo> bindingInfo, MethodInfo propertyGetterFunction, FlexProject project) Generates the ABC to instantiate a PropertyWatcher Can only generate one special case: single event (Constructor actually takes an array of events. we could easily add that no property getter function (we use null) Note that we are passing in references to BindingInfo.
static void	makeXMLWatcher(InstructionList insns, String propertyName, List<BindingInfo> bindingInfo, FlexProject project) Generate instructions to instantiate an mx.binding.XMLWatcher
static void	trace(InstructionList insns) debugging function to call "trace" will use top of stack as string parameter, doesn't change stack depth
static void	trace(InstructionList insns, String string) debugging function to all "trace"

Methods inherited from class java.lang.Object

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

Field Detail

doLog

public static final boolean doLog

See Also:

Constant Field Values

Method Detail

generateGetter

public static void generateGetter(IABCVisitor emitter,
                  InstructionList ret,
                  List<IExpressionNode> expressions,
                  LexicalScope enclosing_scope)

emits the code for anonymous getter function, then adds to the instruction list for instantiating one onto the stack

Parameters:

ret - The instruction list being built.

expressions - will be codegened to do the bulk of the getter work * VM context: one entry: nothing exit: new function object for getter on TOS

generateSetter

public static void generateSetter(InstructionList ret,
                  IExpressionNode expression,
                  LexicalScope enclosing_scope)

emits the code for anonymous setter function, then adds to the instruction list for instantiating one onto the stack

Parameters:

ret - The instruction list being built.

expression - will be codegened to do the bulk of the setter work * VM context: one entry: nothing exit: new function object for getter on TOS

makeBinding

public static void makeBinding(InstructionList insns,
               FlexProject project,
               String destStr,
               String srcString,
               InstructionList methodInstr)

generate code to instantiate a binding object. The code to generate the source and destination functions should be passed in in methodInstr - these instructions will be inserted in the appropriate place. exit: stack = binding object

Parameters:

insns - IL to add instructions to

project - Project we are compiling in

destStr - String representation of the destination expression

srcString - String representation of the source expression

methodInstr - IL with instructions to put the source function and destination function on the stack. These will be inserted where they are needed - these will usually be OP_newfunction, but could be anything that leaves the methods on the stack

makePropertyWatcher

public static void makePropertyWatcher(boolean makeStaticWatcher,
                       InstructionList insns,
                       String propertyName,
                       List<String> eventNames,
                       List<BindingInfo> bindingInfo,
                       MethodInfo propertyGetterFunction,
                       FlexProject project)

Generates the ABC to instantiate a PropertyWatcher Can only generate one special case: single event (Constructor actually takes an array of events. we could easily add that no property getter function (we use null) Note that we are passing in references to BindingInfo. Although this somewhat breaks the rules for our low-level CG helpers, it's the only convenient way to pass in the list of indicies that we will need to prove to the property watcher ctor. * VM context: on entry: nothing on stack local1 = this._bindings exit: new property watcher on stack

makeXMLWatcher

public static void makeXMLWatcher(InstructionList insns,
                  String propertyName,
                  List<BindingInfo> bindingInfo,
                  FlexProject project)

Generate instructions to instantiate an mx.binding.XMLWatcher

Parameters:

insns - The instruction list being built.

propertyName - The name of a property.

bindingInfo - The binding information for the property.

project - The compiler project.

makeFunctionWatcher

public static void makeFunctionWatcher(InstructionList insns,
                       FlexProject project,
                       IABCVisitor emitter,
                       String functionName,
                       List<String> eventNames,
                       List<BindingInfo> bindingInfo,
                       IExpressionNode[] params)

Generates the ABC to instantiate a FunctionReturnWatcher * VM context: on entry: nothing on stack local1 = this._bindings exit: new property watcher on stack

makeParameterFunction

public static void makeParameterFunction(IABCVisitor emitter,
                         InstructionList ret,
                         IExpressionNode[] params)

Generated the "parameter function" required by the FunctionReturnWatcher constructor.

This function is like this:

 function(): Array { return [param1, param2] };
 

Since that is actually difficult to generate, we are instead generating a simple function that throws an exception that we know will be caught silently by the Flex SDK.

There may be some strange edge cases where this trick won't work, but it will cover the majority of cases BETTER than doing the "right" thing.

Parameters:

emitter - IABCVisitor to which generated code is added.

ret - InstructionList to which code that creates a function closure for the new parameter function should be added.

trace

public static void trace(InstructionList insns,
         String string)

debugging function to all "trace"

Parameters:

insns - The instruction list being built.

string - is a constant string to trace

trace

public static void trace(InstructionList insns)

debugging function to call "trace" will use top of stack as string parameter, doesn't change stack depth

Parameters:

insns - The instruction list being built.

generatePropertyGetterFunction

public static MethodInfo generatePropertyGetterFunction(IABCVisitor emitter,
                                        ICompilerProject project,
                                        ASScope scope)

generate this function: function(propertyName:String):* { return target[propertyName]; } where target == "this"

Parameters:

emitter - The IABCVisitor that generated code is added to.

project - The ICompilerProject in which code is being generated.

scope - The ASScope that contains the data binding expression for which a getter is being generated.

Returns:

the MethodInfo that we can use to refer to the generated function

fireInitialBindings

public static InstructionList fireInitialBindings()

enumerate all the bindings we have created for this class, and execute each of them so that initial values get assigned to binding targets. VM context: one entry: nothing while executing: local1 = index (temporary local var) local2 = this._bindings.length; exit: nothing

log

public static void log(String s)

log

public static void log(InstructionList insns,
       String s)