/// /// <summary> /// Parses logical expressions /// </summary> /// /// <param name="leftOp">Left operand</param> /// <param name="rightOp">Right operand</param> /// <param name="type">Logical expression type</param> /// /// <returns>The result of applying the given logical expression operator</returns> /// public static CseObject Parse(CseObject leftOp, CseObject rightOp, LogicalType type) { CseObject obj = null; if (type == LogicalType.NOT) { obj = new CseObject(null) { IsLiteral = leftOp.IsLiteral }; } else { obj = new CseObject(null) { IsLiteral = leftOp.IsLiteral && rightOp.IsLiteral }; } try { switch (type) { case LogicalType.AND: // TODO: lazy eval if exception thrown obj.Value = leftOp.Value && rightOp.Value; break; case LogicalType.OR: // TODO: lazy eval if exception thrown obj.Value = leftOp.Value || rightOp.Value; break; case LogicalType.NOT: { //try { obj.Value = !leftOp.Value; /*} * catch { * MethodInfo mi = obj.Value.GetType().GetMethod(OpOverloadNames.FALSE); * if (mi != null) * obj.Value = obj.Value.GetType().InvokeMember(OpOverloadNames.FALSE, OpOverloadNames.Flags, null, CsEval.evalEnvironment, new object[] { obj.Value }); * else * obj.Value = null; * }*/ } break; default: throw new System.NotImplementedException("Not implemented."); } } catch { // TODO: Fill this out! } return(obj); }
/// /// <summary> /// Parses xor expressions /// </summary> /// /// <param name="leftOp">Left operand</param> /// <param name="rightOp">Right operand</param> /// /// <returns>The result of applying the xor operator</returns> /// public static CseObject Parse(CseObject leftOp, CseObject rightOp) { CseObject obj = new CseObject(null) { IsLiteral = leftOp.IsLiteral && rightOp.IsLiteral }; obj.Value = leftOp.Value ^ rightOp.Value; return(obj); }
/// /// <summary> /// Used for quick evaluation. /// Use this when the evaluation environment changes often. /// If the environment is consistent, set CsEval.EvalEnvironment /// then call CsEval.Eval(string data). /// </summary> /// /// <param name="evalEnvironment"> /// Provides an evaluation environment for the given expression. /// The stored evaluation environment is temporarily replaced /// when the given statement is evaluated and restored afterwards. /// </param> /// <param name="data">The expression to evaluate</param> /// /// <returns>The return result of evaluating the expression</returns> /// public static object Eval(object evalEnvironment, string data) { CseObject saveDebugInstance = CsEval.evalEnvironment; CsEval.evalEnvironment = new CseObject(evalEnvironment); object result = Eval(data); CsEval.evalEnvironment = saveDebugInstance; return(result); }
/// /// <summary> /// Parses bitwise expressions /// </summary> /// /// <param name="leftOp">Left operand</param> /// <param name="rightOp">Right operand</param> /// <param name="type">Bitwise expression type</param> /// /// <returns>The result of applying the given bitwise operand</returns> /// public static CseObject Parse(CseObject leftOp, CseObject rightOp, BitwiseType type) { CseObject obj = null; if (type == BitwiseType.NOT) { obj = new CseObject(null) { IsLiteral = leftOp.IsLiteral }; } else { obj = new CseObject(null) { IsLiteral = leftOp.IsLiteral && rightOp.IsLiteral }; } try { switch (type) { case BitwiseType.AND: obj.Value = leftOp.Value & rightOp.Value; break; case BitwiseType.OR: obj.Value = leftOp.Value | rightOp.Value; break; case BitwiseType.NOT: obj.Value = ~leftOp.Value; break; case BitwiseType.SHL: obj.Value = leftOp.Value << rightOp.Value; break; case BitwiseType.SHR: obj.Value = leftOp.Value >> rightOp.Value; break; default: throw new System.NotImplementedException("Not implemented."); } } catch { // TODO: Fill this out! } return(obj); }
/// /// <summary> /// Parses logical expressions /// </summary> /// /// <param name="leftOp">Left operand</param> /// <param name="rightOp">Right operand</param> /// <param name="type">Logical expression type</param> /// /// <returns>The result of applying the given logical expression operator</returns> /// public static CseObject Parse(CseObject leftOp, CseObject rightOp, LogicalType type) { CseObject obj = null; if (type == LogicalType.NOT) { obj = new CseObject(null) { IsLiteral = leftOp.IsLiteral }; } else { obj = new CseObject(null) { IsLiteral = leftOp.IsLiteral && rightOp.IsLiteral }; } try { switch (type) { case LogicalType.AND: // TODO: lazy eval if exception thrown obj.Value = leftOp.Value && rightOp.Value; break; case LogicalType.OR: // TODO: lazy eval if exception thrown obj.Value = leftOp.Value || rightOp.Value; break; case LogicalType.NOT: { //try { obj.Value = !leftOp.Value; /*} catch { MethodInfo mi = obj.Value.GetType().GetMethod(OpOverloadNames.FALSE); if (mi != null) obj.Value = obj.Value.GetType().InvokeMember(OpOverloadNames.FALSE, OpOverloadNames.Flags, null, CsEval.evalEnvironment, new object[] { obj.Value }); else obj.Value = null; }*/ } break; default: throw new System.NotImplementedException("Not implemented."); } } catch { // TODO: Fill this out! } return obj; }
/// /// <summary> /// Parses bitwise expressions /// </summary> /// /// <param name="leftOp">Left operand</param> /// <param name="rightOp">Right operand</param> /// <param name="type">Bitwise expression type</param> /// /// <returns>The result of applying the given bitwise operand</returns> /// public static CseObject Parse(CseObject leftOp, CseObject rightOp, BitwiseType type) { CseObject obj = null; if (type == BitwiseType.NOT) { obj = new CseObject(null) { IsLiteral = leftOp.IsLiteral }; } else { obj = new CseObject(null) { IsLiteral = leftOp.IsLiteral && rightOp.IsLiteral }; } try { switch (type) { case BitwiseType.AND: obj.Value = leftOp.Value & rightOp.Value; break; case BitwiseType.OR: obj.Value = leftOp.Value | rightOp.Value; break; case BitwiseType.NOT: obj.Value = ~leftOp.Value; break; case BitwiseType.SHL: obj.Value = leftOp.Value << rightOp.Value; break; case BitwiseType.SHR: obj.Value = leftOp.Value >> rightOp.Value; break; default: throw new System.NotImplementedException("Not implemented."); } } catch { // TODO: Fill this out! } return obj; }
/// /// <summary> /// Constructor for MethResSettings objects /// </summary> /// /// <param name="env">The environment to use</param> /// <param name="name">The name of the method</param> /// <param name="args">Arguments to pass to the method</param> /// <param name="isExtInvocation">True if this is an extended invocation, false otherwise</param> /// public MethResSettings(object env, string name, CseObject[] args, bool isExtInvocation) { Env = env; Name = name; Args = args; IsExtInvocation = isExtInvocation; }
public static void Main2(string[] comArgs) { MethOverloads mo = new MethOverloads(); A a = new A(); //var t = a.GetType().GetMethod("Foo", BindingFlags.Public | BindingFlags.Instance).GetGenericArguments()[0].GetGenericParameterConstraints();//.GenericParameterAttributes; //mo.Baz(3); //mo.Foo( new int[] { 3, 1} ); int?nullableint = null; CseObject from = new CseObject(new String[, ] { { "1" } }); Type to = a.GetType().GetMethod("Foo", BindingFlags.Public | BindingFlags.Instance).GetParameters()[0].ParameterType; //Console.Out.WriteLine(MethRes.CanConvertType(from, to)); MethRes.GetBestInvocableMember(new MethResSettings(new A(), "Foo", new CseObject[] { new CseObject(3) }, false)); Console.Out.WriteLine(MethRes.ImpRefConv(from, to)); return; Console.WindowHeight = 20; Console.WindowWidth = 80; object env = new MethOverloads(); string name = "Bar"; CseObject[] args = new CseObject[] { /*new CseObject('x') { * CallMod = CallArgMod.REF * }, * new CseObject(3) { * CallMod = CallArgMod.OUT * }*/ new CseObject(3) }; MethResObject bestMember = MethRes.GetBestInvocableMember(new MethResSettings(env, name, args, false)); Console.ForegroundColor = ConsoleColor.White; Console.Out.WriteLine("CALL"); Console.Out.Write("\t{0}: {1}(", env.GetType().FullName, name); foreach (object arg in args) { if (arg == null) { Console.Out.Write("null, "); } else { Console.Out.Write(arg.GetType().Name + ", "); } } Console.Out.WriteLine("\b\b)\n", env.GetType().Name); Console.ForegroundColor = ConsoleColor.Green; Console.Out.WriteLine("MATCH "); //foreach (MethodInfo appMember in appMembers) if (bestMember.MethInfo == null) { Console.Out.WriteLine("\tNo matches found!"); } else { Console.Out.WriteLine("\t" + bestMember.MethInfo.ReflectedType.ToString() + ": " + bestMember.MethInfo.ToString()); } Console.Out.WriteLine(""); Console.ForegroundColor = ConsoleColor.Black; }
/// /// <summary> /// Parses xor expressions /// </summary> /// /// <param name="leftOp">Left operand</param> /// <param name="rightOp">Right operand</param> /// /// <returns>The result of applying the xor operator</returns> /// public static CseObject Parse(CseObject leftOp, CseObject rightOp) { CseObject obj = new CseObject(null) { IsLiteral = leftOp.IsLiteral && rightOp.IsLiteral }; obj.Value = leftOp.Value ^ rightOp.Value; return obj; }