bool IsArrayCreation(MethodCall methodCall)
{
MethodCall targetMethodCall = methodCall.Target as MethodCall;
if (targetMethodCall != null) {
return targetMethodCall.MethodName == "[]";
}
return false;
}
public object Deserialize(string name, MethodCall methodCall)
{
if (methodCall.Target is ArrayItemAccess) {
return DeserializeCreateArrayExpression(name, methodCall);
} else if ("new".Equals(methodCall.MethodName, StringComparison.InvariantCultureIgnoreCase)) {
return CreateInstance(name, methodCall);
} else if ("|".Equals(methodCall.MethodName)) {
return DeserializeBitwiseOr(methodCall);
}
return CreateInstance(name, methodCall);
}
protected override void Walk(MethodCall node)
{
if (node.MethodName == "require") {
if (HasArguments(node)) {
string requireString = GetRequireString(node.Arguments.Expressions);
if (requireString != null) {
AddUsing(requireString);
}
}
}
base.Walk(node);
}
protected static void AssertParameters(MethodCall self, int n)
{
if (n == 0)
{
if (self.Arguments != null && self.Arguments.Expressions.Length != 0)
throw new FructoseCompileException("Built in function " + self.MethodName + " takes no arguments", self);
}
else
{
if (self.Arguments == null || self.Arguments.Expressions.Length != 1)
throw new FructoseCompileException("Built in function " + self.MethodName + " takes " + n + " argument(s)", self);
}
}
/// <summary>
/// Gets the fully qualified name being referenced in the MemberExpression.
/// </summary>
public static string GetMemberName(MethodCall methodCall)
{
return GetMemberName(GetMemberNames(methodCall));
}
/// <summary>
/// Creates a RubyControlField from a call expression:
///
/// @menuItem1.Items.AddRange(...)
///
/// Note that in Ruby a method call is also of the form:
///
/// System::Drawing::Color.Red
/// </summary>
public static RubyControlFieldExpression Create(MethodCall methodCall)
{
string[] allNames = GetMemberNames(methodCall);
// Remove last member since it is the method name.
int lastItemIndex = allNames.Length - 1;
string[] memberNames = new string[lastItemIndex];
Array.Copy(allNames, memberNames, lastItemIndex);
RubyControlFieldExpression field = Create(memberNames);
field.methodName = allNames[lastItemIndex];
return field;
}
internal override MSA.Expression /*!*/ TransformWrite(AstGenerator /*!*/ gen, MSA.Expression target, MSA.Expression /*!*/ rightValue)
{
Assert.NotNull(target);
return(MethodCall.TransformRead(this, gen, _array.NodeType == NodeTypes.SelfReference, "[]=", target, _arguments, _block, null, rightValue));
}
string GetEventHandlerName(MethodCall eventHandlerMethodBlock)
{
BlockDefinition blockDef = eventHandlerMethodBlock.Block as BlockDefinition;
MethodCall eventHandlerMethodCall = blockDef.Body.First as MethodCall;
return eventHandlerMethodCall.MethodName;
}
/// <summary>
/// Walks a method call. Typical method calls are:
///
/// @menuItem1.Items.AddRange(...)
///
/// This method will execute the method call.
/// </summary>
void WalkMethodCall(MethodCall node)
{
// Try to get the object being called. Try the form first then
// look for other controls.
object member = RubyControlFieldExpression.GetMember(component, node);
RubyControlFieldExpression field = RubyControlFieldExpression.Create(node);
if (member == null) {
member = field.GetMember(componentCreator);
}
// Execute the method on the object.
if (member != null) {
if (node.Arguments == null) {
RegisterEventHandler(node, member);
} else {
object[] args = deserializer.GetArguments(node).ToArray();
InvokeMethod(member, field.MethodName, args);
}
}
}
public virtual bool Enter(MethodCall/*!*/ node) { return true; }
/// <summary>
/// Gets the member object that matches the field member.
/// </summary>
/// <remarks>
/// The member names array should contain all items including self, for example:
///
/// self
/// Controls
/// </remarks>
public static object GetMember(object obj, MethodCall methodCall)
{
string[] memberNames = GetMemberNames(methodCall);
if (ContainsSelfReference(memberNames)) {
return GetMember(obj, memberNames, 1, memberNames.Length - 2);
}
return null;
}
static bool IsClrMemberMethod(MethodCall methodCall)
{
return String.Equals(methodCall.MethodName, "clr_member", StringComparison.InvariantCultureIgnoreCase);
}
static string[] GetMemberNamesFromMethodCall(MethodCall methodCall)
{
List<string> names = new List<string>();
while (methodCall != null) {
names.Insert(0, methodCall.MethodName);
SelfReference selfRef = methodCall.Target as SelfReference;
InstanceVariable instance = methodCall.Target as InstanceVariable;
LocalVariable localVariable = methodCall.Target as LocalVariable;
methodCall = methodCall.Target as MethodCall;
if (methodCall == null) {
if (selfRef != null) {
names.Insert(0, "self");
} else if (instance != null) {
names.Insert(0, instance.Name);
} else if (localVariable != null) {
names.Insert(0, localVariable.Name);
}
}
}
return names.ToArray();
}
/// <summary>
/// Gets the member names that make up the MemberExpression in order.
/// </summary>
public static string[] GetMemberNames(MethodCall methodCall)
{
if (methodCall != null) {
if (methodCall.Target is ConstantVariable) {
return GetMemberNamesFromConstant(methodCall);
} else if (IsClrMemberMethodCall(methodCall)) {
return GetMemberNamesFromClrMemberMethodCall(methodCall);
}
}
return GetMemberNamesFromMethodCall(methodCall);
}
public override void Compile(Compiler compiler, MethodCall node, NodeParent parent)
{
AssertParameters(node, 1);
compiler.CompileNode(node.Arguments.Expressions.First(), parent.CreateChild(node));
compiler.AppendLine("include array_pop($_stack)->F_to_s(NULL)->__STRING;");
}
public abstract void Compile(Compiler compiler, MethodCall node, NodeParent parent);
internal override MSA.Expression /*!*/ TransformRead(AstGenerator /*!*/ gen)
{
var target = (_expression != null) ? _expression.Transform(gen) : Ast.Constant(null);
return(MethodCall.TransformRead(this, gen, false, Symbols.Bang, target, null, null, null, null));
}
public virtual bool Enter(MethodCall /*!*/ node)
{
return(true);
}
public virtual void Exit(MethodCall /*!*/ node)
{
}
static string[] GetMemberNamesFromConstant(MethodCall methodCall)
{
List<string> names = new List<string>();
ConstantVariable constantVariable = methodCall.Target as ConstantVariable;
while (constantVariable != null) {
names.Insert(0, constantVariable.Name);
constantVariable = constantVariable.Qualifier as ConstantVariable;
}
names.Add(methodCall.MethodName);
return names.ToArray();
}
bool HasArguments(MethodCall node)
{
return (node.Arguments != null) && (!node.Arguments.IsEmpty);
}
static bool IsClrMemberMethodCall(MethodCall methodCall)
{
MethodCall clrMemberMethod = methodCall.Target as MethodCall;
if (clrMemberMethod != null) {
return IsClrMemberMethod(clrMemberMethod);
}
return false;
}
object DeserializeBitwiseOr(MethodCall methodCall)
{
List<object> items = new List<object>();
while (methodCall != null) {
if (methodCall.Arguments != null) {
items.Add(CreateInstance(null, methodCall.Arguments.Expressions[0] as MethodCall));
}
methodCall = methodCall.Target as MethodCall;
}
int value = 1;
foreach (object item in items) {
value = Convert.ToInt32(item) | value;
}
return Enum.ToObject(items[0].GetType(), value);
}
static string[] GetMemberNamesFromClrMemberMethodCall(MethodCall methodCall)
{
string[] allNames = GetMemberNamesFromMethodCall(methodCall);
List<string> names = new List<string>();
MethodCall clrMemberMethodCall = methodCall.Target as MethodCall;
SymbolLiteral literal = clrMemberMethodCall.Arguments.Expressions[1] as SymbolLiteral;
MutableString mutableString = literal.GetMutableString();
string methodBeingCalledByClrMemberMethod = mutableString.ConvertToString();
// Remove two members since these are 'clr_member' and 'call'.
int lastItemIndex = allNames.Length - 2;
string[] memberNames = new string[lastItemIndex];
Array.Copy(allNames, memberNames, lastItemIndex);
names.AddRange(memberNames);
names.Add(methodBeingCalledByClrMemberMethod);
return names.ToArray();
}
object CreateInstance(string name, MethodCall methodCall)
{
RubyControlFieldExpression field = RubyControlFieldExpression.Create(methodCall);
Type type = GetType(field);
if (type != null) {
if (type.IsEnum) {
return Enum.Parse(type, methodCall.MethodName);
}
BindingFlags propertyBindingFlags = BindingFlags.Public | BindingFlags.GetField | BindingFlags.Static | BindingFlags.Instance;
PropertyInfo propertyInfo = type.GetProperty(methodCall.MethodName, propertyBindingFlags);
if (propertyInfo != null) {
return propertyInfo.GetValue(type, null);
}
if (type.IsAssignableFrom(typeof(ComponentResourceManager))) {
return componentCreator.CreateInstance(type, new object[0], name, false);
}
if (methodCall.Arguments != null) {
return CreateInstance(type, name, methodCall);
}
} else {
return componentCreator.GetInstance(field.MethodName);
}
return null;
}
protected override void Walk(MethodCall node)
{
if (node.Block != null)
base.Walk(node.Block);
base.Walk(node);
}
object CreateInstance(Type type, string name, MethodCall methodCall)
{
List<object> args = GetArguments(methodCall.Arguments);
// Try to execute a method on the object.
foreach (MethodInfo method in type.GetMethods(BindingFlags.Public | BindingFlags.Static)) {
if (method.Name == methodCall.MethodName) {
int parameterCount = method.GetParameters().Length;
if ((methodCall.Arguments.IsEmpty && (parameterCount == 0)) ||
(parameterCount == methodCall.Arguments.Expressions.Length)) {
return method.Invoke(null, args.ToArray());
}
}
}
return componentCreator.CreateInstance(type, args, name, false);
}
public virtual void Exit(MethodCall/*!*/ node) { }
/// <summary>
/// Deserializes a method call where the target is an array expression.
///
/// System::Array[System::String].new("a", "b")
/// </summary>
object DeserializeCreateArrayExpression(string name, MethodCall methodCall)
{
MethodCall arrayCreationMethodCall = methodCall.Target as MethodCall;
ConstantVariable constantVariable = arrayCreationMethodCall.Arguments.Expressions[0] as ConstantVariable;
string arrayTypeName = RubyControlFieldExpression.GetQualifiedName(constantVariable);
ArrayConstructor arrayConstructor = methodCall.Arguments.Expressions[0] as ArrayConstructor;
Expression[] arrayItems = arrayConstructor.Arguments.Expressions;
Type arrayType = componentCreator.GetType(arrayTypeName);
Array array = Array.CreateInstance(arrayType, arrayItems.Length);
for (int i = 0; i < arrayItems.Length; ++i) {
Expression arrayItemExpression = arrayItems[i];
object instance = Deserialize(arrayItemExpression);
array.SetValue(instance, i);
}
return array;
}
void RegisterEventHandler(MethodCall node, object component)
{
string eventHandlerName = GetEventHandlerName(node);
RegisterEventHandler(component, node.MethodName, eventHandlerName);
}
public List<object> GetArguments(MethodCall methodCall)
{
return GetArguments(methodCall.Arguments);
}
object GetResource(MethodCall methodCall)
{
IResourceReader reader = componentCreator.GetResourceReader(CultureInfo.InvariantCulture);
if (reader != null) {
using (ResourceSet resources = new ResourceSet(reader)) {
List<object> args = deserializer.GetArguments(methodCall);
return resources.GetObject(args[0] as String);
}
}
return null;
}
internal override MSA.Expression /*!*/ TransformRead(AstGenerator /*!*/ gen, MSA.Expression targetValue, bool tryRead)
{
Assert.NotNull(gen, targetValue);
return(MethodCall.TransformRead(this, gen, false, "[]", targetValue, _arguments, _block, null, null));
}
