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)); }