internal static DynamicExpression Make(Type returnType, Type delegateType, CallSiteBinder binder, Expression arg0, Expression arg1, Expression arg2, Expression arg3) {
     if (returnType == typeof(object)) {
         return new DynamicExpression4(delegateType, binder, arg0, arg1, arg2, arg3);
     } else {
         return new TypedDynamicExpression4(returnType, delegateType, binder, arg0, arg1, arg2, arg3);
     }
 }

 public void SetCurrentLine(string line)
 {
     lineNumber++;
     currentLine = line;
     Value = null;
     if(currentLine.Count() > 0){
         localExpression = new Expression(currentLine);
         if (localExpression.NumericalEvaluation != null) {
             Value = localExpression.NumericalEvaluation;
             OutputString = localExpression.OutputString;
         } else {
             OutputString = "\""+line+"\" " + localExpression.OutputString;
         }
     }
 }

 public void ExpressionConstructorTest()
 {
     Expression target = new Expression("3+4*334 - te 33z 34.3.4,() || ,");
     Tokens tokens = new Tokens(new System.Collections.Generic.List<Token>(){
         new Token("3", TokenType.numberLiteral),
         new Token("+", TokenType.operatorOrPunctuation),
         new Token("+4", TokenType.numberLiteral),
         new Token("*", TokenType.operatorOrPunctuation),
         new Token("334", TokenType.numberLiteral),
         new Token("-", TokenType.atomicOperatorOrPunctuation),
         new Token("te", TokenType.identifier),
         new Token("33z", TokenType.identifier),
         new Token("34.3.4", TokenType.numberLiteral),
         new Token(",", TokenType.operatorOrPunctuation),
         new Token("(", TokenType.atomicOperatorOrPunctuation),
         new Token(")", TokenType.atomicOperatorOrPunctuation),
         new Token("||", TokenType.operatorOrPunctuation),
         new Token(",", TokenType.operatorOrPunctuation)
     });
     for(int i=0; i < tokens.AsList().Count; i++){
         Assert.AreEqual<string>(tokens.AsList()[i].TokenString, target.Tokens.AsList()[i].TokenString);
         Assert.AreEqual<TokenType>(tokens.AsList()[i].TokenType, target.Tokens.AsList()[i].TokenType);
     }
 }

 internal TypedDynamicExpression4(Type retType, Type delegateType, CallSiteBinder binder, Expression arg0, Expression arg1, Expression arg2, Expression arg3)
     : base(delegateType, binder, arg0, arg1, arg2, arg3) {
     _retType = retType;
 }

        internal override DynamicExpression Rewrite(Expression[] args) {
            Debug.Assert(args.Length == 4);

            return Expression.MakeDynamic(DelegateType, Binder, args[0], args[1], args[2], args[3]);
        }

        private readonly Expression _arg1, _arg2, _arg3;    // storage for the 2nd - 4th arguments

        internal DynamicExpression4(Type delegateType, CallSiteBinder binder, Expression arg0, Expression arg1, Expression arg2, Expression arg3)
            : base(delegateType, binder) {
            _arg0 = arg0;
            _arg1 = arg1;
            _arg2 = arg2;
            _arg3 = arg3;
        }

        private readonly Expression _arg1;      // storage for the 2nd argument

        internal DynamicExpression2(Type delegateType, CallSiteBinder binder, Expression arg0, Expression arg1)
            : base(delegateType, binder) {
            _arg0 = arg0;
            _arg1 = arg1;
        }

 internal TypedDynamicExpression1(Type retType, Type delegateType, CallSiteBinder binder, Expression arg0)
     : base(delegateType, binder, arg0) {
     _retType = retType;
 }

 public void ExpressionConstructorTest1()
 {
     string textOfCurrentLine = "4+-1(3)(-3)3--3";
     Expression target = new Expression(textOfCurrentLine);
     //Assert.AreEqual(target.OutputString, "34");
 }

 Expression IDynamicExpression.Rewrite(Expression[] args)
 {
     return this.Rewrite(args);
 }

 /// <summary>
 /// Creates a <see cref="DynamicExpression" /> that represents a dynamic operation bound by the provided <see cref="CallSiteBinder" /> and four arguments.
 /// </summary>
 /// <param name="delegateType">The type of the delegate used by the <see cref="CallSite" />.</param>
 /// <param name="binder">The runtime binder for the dynamic operation.</param>
 /// <param name="arg0">The first argument to the dynamic operation.</param>
 /// <param name="arg1">The second argument to the dynamic operation.</param>
 /// <param name="arg2">The third argument to the dynamic operation.</param>
 /// <param name="arg3">The fourth argument to the dynamic operation.</param>
 /// <returns>
 /// A <see cref="DynamicExpression" /> that has <see cref="NodeType" /> equal to
 /// <see cref="ExpressionType.Dynamic">Dynamic</see> and has the
 /// <see cref="DynamicExpression.DelegateType">DelegateType</see>,
 /// <see cref="DynamicExpression.Binder">Binder</see>, and
 /// <see cref="DynamicExpression.Arguments">Arguments</see> set to the specified values.
 /// </returns>
 public static new DynamicExpression MakeDynamic(Type delegateType, CallSiteBinder binder, Expression arg0, Expression arg1, Expression arg2, Expression arg3) {
     return Expression.MakeDynamic(delegateType, binder, arg0, arg1, arg2, arg3);
 }

 /// <summary>
 /// Creates a <see cref="DynamicExpression" /> that represents a dynamic operation bound by the provided <see cref="CallSiteBinder" />.
 /// </summary>
 /// <param name="binder">The runtime binder for the dynamic operation.</param>
 /// <param name="returnType">The result type of the dynamic expression.</param>
 /// <param name="arg0">The first argument to the dynamic operation.</param>
 /// <param name="arg1">The second argument to the dynamic operation.</param>
 /// <param name="arg2">The third argument to the dynamic operation.</param>
 /// <param name="arg3">The fourth argument to the dynamic operation.</param>
 /// <returns>
 /// A <see cref="DynamicExpression" /> that has <see cref="NodeType" /> equal to
 /// <see cref="ExpressionType.Dynamic">Dynamic</see> and has the
 /// <see cref="DynamicExpression.Binder">Binder</see> and
 /// <see cref="DynamicExpression.Arguments">Arguments</see> set to the specified values.
 /// </returns>
 /// <remarks>
 /// The <see cref="DynamicExpression.DelegateType">DelegateType</see> property of the
 /// result will be inferred from the types of the arguments and the specified return type.
 /// </remarks>
 public static new DynamicExpression Dynamic(CallSiteBinder binder, Type returnType, Expression arg0, Expression arg1, Expression arg2, Expression arg3) {
     return Expression.Dynamic(binder, returnType, arg0, arg1, arg2, arg3);
 }

        /// <summary>
        /// Creates a <see cref="DynamicExpression" /> that represents a dynamic operation bound by the provided <see cref="CallSiteBinder" /> and one argument.
        /// </summary>
        /// <param name="delegateType">The type of the delegate used by the <see cref="CallSite" />.</param>
        /// <param name="binder">The runtime binder for the dynamic operation.</param>
        /// <param name="arg0">The argument to the dynamic operation.</param>
        /// <returns>
        /// A <see cref="DynamicExpression" /> that has <see cref="NodeType" /> equal to
        /// <see cref="ExpressionType.Dynamic">Dynamic</see> and has the
        /// <see cref="DynamicExpression.DelegateType">DelegateType</see>,
        /// <see cref="DynamicExpression.Binder">Binder</see>, and
        /// <see cref="DynamicExpression.Arguments">Arguments</see> set to the specified values.
        /// </returns>
        public static DynamicExpression MakeDynamic(Type delegateType, CallSiteBinder binder, Expression arg0) {
            ContractUtils.RequiresNotNull(delegateType, "delegatType");
            ContractUtils.RequiresNotNull(binder, "binder");
            ContractUtils.Requires(delegateType.IsSubclassOf(typeof(Delegate)), "delegateType", Strings.TypeMustBeDerivedFromSystemDelegate);

            var method = GetValidMethodForDynamic(delegateType);
            var parameters = method.GetParametersCached();

            ValidateArgumentCount(method, ExpressionType.Dynamic, 2, parameters);
            ValidateDynamicArgument(arg0);
            ValidateOneArgument(method, ExpressionType.Dynamic, arg0, parameters[1]);

            return DynamicExpression.Make(method.GetReturnType(), delegateType, binder, arg0);
        }

        /// <summary>
        /// Creates a <see cref="DynamicExpression" /> that represents a dynamic operation bound by the provided <see cref="CallSiteBinder" /> and four arguments.
        /// </summary>
        /// <param name="delegateType">The type of the delegate used by the <see cref="CallSite" />.</param>
        /// <param name="binder">The runtime binder for the dynamic operation.</param>
        /// <param name="arg0">The first argument to the dynamic operation.</param>
        /// <param name="arg1">The second argument to the dynamic operation.</param>
        /// <param name="arg2">The third argument to the dynamic operation.</param>
        /// <param name="arg3">The fourth argument to the dynamic operation.</param>
        /// <returns>
        /// A <see cref="DynamicExpression" /> that has <see cref="NodeType" /> equal to
        /// <see cref="ExpressionType.Dynamic">Dynamic</see> and has the
        /// <see cref="DynamicExpression.DelegateType">DelegateType</see>,
        /// <see cref="DynamicExpression.Binder">Binder</see>, and
        /// <see cref="DynamicExpression.Arguments">Arguments</see> set to the specified values.
        /// </returns>
        public static DynamicExpression MakeDynamic(Type delegateType, CallSiteBinder binder, Expression arg0, Expression arg1, Expression arg2, Expression arg3) {
            ContractUtils.RequiresNotNull(delegateType, "delegateType");
            ContractUtils.RequiresNotNull(binder, "binder");
            if (!delegateType.IsSubclassOf(typeof(MulticastDelegate))) throw Error.TypeMustBeDerivedFromSystemDelegate();

            var method = GetValidMethodForDynamic(delegateType);
            var parameters = method.GetParametersCached();

            ValidateArgumentCount(method, ExpressionType.Dynamic, 5, parameters);
            ValidateDynamicArgument(arg0);
            ValidateOneArgument(method, ExpressionType.Dynamic, arg0, parameters[1]);
            ValidateDynamicArgument(arg1);
            ValidateOneArgument(method, ExpressionType.Dynamic, arg1, parameters[2]);
            ValidateDynamicArgument(arg2);
            ValidateOneArgument(method, ExpressionType.Dynamic, arg2, parameters[3]);
            ValidateDynamicArgument(arg3);
            ValidateOneArgument(method, ExpressionType.Dynamic, arg3, parameters[4]);

            return DynamicExpression.Make(method.GetReturnType(), delegateType, binder, arg0, arg1, arg2, arg3);
        }

        /// <summary>
        /// Creates a <see cref="DynamicExpression" /> that represents a dynamic operation bound by the provided <see cref="CallSiteBinder" />.
        /// </summary>
        /// <param name="binder">The runtime binder for the dynamic operation.</param>
        /// <param name="returnType">The result type of the dynamic expression.</param>
        /// <param name="arg0">The first argument to the dynamic operation.</param>
        /// <param name="arg1">The second argument to the dynamic operation.</param>
        /// <param name="arg2">The third argument to the dynamic operation.</param>
        /// <param name="arg3">The fourth argument to the dynamic operation.</param>
        /// <returns>
        /// A <see cref="DynamicExpression" /> that has <see cref="NodeType" /> equal to
        /// <see cref="ExpressionType.Dynamic">Dynamic</see> and has the
        /// <see cref="DynamicExpression.Binder">Binder</see> and
        /// <see cref="DynamicExpression.Arguments">Arguments</see> set to the specified values.
        /// </returns>
        /// <remarks>
        /// The <see cref="DynamicExpression.DelegateType">DelegateType</see> property of the
        /// result will be inferred from the types of the arguments and the specified return type.
        /// </remarks>
        public static DynamicExpression Dynamic(CallSiteBinder binder, Type returnType, Expression arg0, Expression arg1, Expression arg2, Expression arg3) {
            ContractUtils.RequiresNotNull(binder, "binder");
            ValidateDynamicArgument(arg0);
            ValidateDynamicArgument(arg1);
            ValidateDynamicArgument(arg2);
            ValidateDynamicArgument(arg3);

            DelegateHelpers.TypeInfo info = DelegateHelpers.GetNextTypeInfo(
                returnType,
                DelegateHelpers.GetNextTypeInfo(
                    arg3.Type,
                    DelegateHelpers.GetNextTypeInfo(
                        arg2.Type,
                        DelegateHelpers.GetNextTypeInfo(
                            arg1.Type,
                            DelegateHelpers.GetNextTypeInfo(
                                arg0.Type,
                                DelegateHelpers.NextTypeInfo(typeof(CallSite))
                            )
                        )
                    )
                )
            );

            Type delegateType = info.DelegateType;
            if (delegateType == null) {
                delegateType = info.MakeDelegateType(returnType, arg0, arg1, arg2, arg3);
            }

            return DynamicExpression.Make(returnType, delegateType, binder, arg0, arg1, arg2, arg3);
        }

 private static void ValidateDynamicArgument(Expression arg) {
     RequiresCanRead(arg, "arguments");
     var type = arg.Type;
     ContractUtils.RequiresNotNull(type, "type");
     TypeUtils.ValidateType(type);
     if (type == typeof(void)) throw Error.ArgumentTypeCannotBeVoid();
 }

        private object _arg0;               // storage for the 1st argument or a readonly collection.  See IArgumentProvider for more info.

        internal DynamicExpression1(Type delegateType, CallSiteBinder binder, Expression arg0)
            : base(delegateType, binder) {
            _arg0 = arg0;
        }