GotoExpression.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Core / Microsoft / Scripting / Ast / GotoExpression.cs / 1305376 / GotoExpression.cs
                        
                        
                            /* **************************************************************************** 
 *
 * Copyright (c) Microsoft Corporation.
 *
 * This source code is subject to terms and conditions of the Microsoft Public License. A 
 * copy of the license can be found in the License.html file at the root of this distribution. If
 * you cannot locate the  Microsoft Public License, please send an email to 
 * dlr@microsoft.com. By using this source code in any fashion, you are agreeing to be bound 
 * by the terms of the Microsoft Public License.
 * 
 * You must not remove this notice, or any other, from this software.
 *
 *
 * ***************************************************************************/ 

using System.Diagnostics; 
using System.Dynamic.Utils; 

#if SILVERLIGHT 
using System.Core;
#endif

namespace System.Linq.Expressions { 
    /// 
    /// Specifies what kind of jump this  represents. 
    ///  
    public enum GotoExpressionKind {
        ///  
        /// A  that represents a jump to some location.
        /// 
        Goto,
        ///  
        /// A  that represents a return statement.
        ///  
        Return, 
        /// 
        /// A  that represents a break statement. 
        /// 
        Break,
        /// 
        /// A  that represents a continue statement. 
        /// 
        Continue, 
    } 

    ///  
    /// Represents an unconditional jump. This includes return statements, break and continue statements, and other jumps.
    /// 
#if !SILVERLIGHT
    [DebuggerTypeProxy(typeof(Expression.GotoExpressionProxy))] 
#endif
    public sealed class GotoExpression : Expression { 
        private readonly GotoExpressionKind _kind; 
        private readonly Expression _value;
        private readonly LabelTarget _target; 
        private readonly Type _type;

        internal GotoExpression(GotoExpressionKind kind, LabelTarget target, Expression value, Type type) {
            _kind = kind; 
            _value = value;
            _target = target; 
            _type = type; 
        }
 
        /// 
        /// Gets the static type of the expression that this  represents. (Inherited from .)
        /// 
        /// The  that represents the static type of the expression. 
        public sealed override Type Type {
            get { return _type; } 
        } 

        ///  
        /// Returns the node type of this . (Inherited from .)
        /// 
        /// The  that represents this expression.
        public sealed override ExpressionType NodeType { 
            get { return ExpressionType.Goto; }
        } 
 
        /// 
        /// The value passed to the target, or null if the target is of type 
        /// System.Void.
        /// 
        public Expression Value {
            get { return _value; } 
        }
 
        ///  
        /// The target label where this node jumps to.
        ///  
        public LabelTarget Target {
            get { return _target; }
        }
 
        /// 
        /// The kind of the goto. For information purposes only. 
        ///  
        public GotoExpressionKind Kind {
            get { return _kind; } 
        }

        /// 
        /// Dispatches to the specific visit method for this node type. 
        /// 
        protected internal override Expression Accept(ExpressionVisitor visitor) { 
            return visitor.VisitGoto(this); 
        }
 
        /// 
        /// Creates a new expression that is like this one, but using the
        /// supplied children. If all of the children are the same, it will
        /// return this expression. 
        /// 
        /// The  property of the result. 
        /// The  property of the result. 
        /// This expression if no children changed, or an expression with the updated children.
        public GotoExpression Update(LabelTarget target, Expression value) { 
            if (target == Target && value == Value) {
                return this;
            }
            return Expression.MakeGoto(Kind, target, value, Type); 
        }
    } 
 
    public partial class Expression {
        ///  
        /// Creates a  representing a break statement.
        /// 
        /// The  that the  will jump to.
        ///  
        /// A  with  equal to Break,
        /// the  property set to , and a null value to be passed to the target label upon jumping. 
        ///  
        public static GotoExpression Break(LabelTarget target) {
            return MakeGoto(GotoExpressionKind.Break, target, null, typeof(void)); 
        }

        /// 
        /// Creates a  representing a break statement. The value passed to the label upon jumping can be specified. 
        /// 
        /// The  that the  will jump to. 
        /// The value that will be passed to the associated label upon jumping. 
        /// 
        /// A  with  equal to Break, 
        /// the  property set to ,
        /// and  to be passed to the target label upon jumping.
        /// 
        public static GotoExpression Break(LabelTarget target, Expression value) { 
            return MakeGoto(GotoExpressionKind.Break, target, value, typeof(void));
        } 
 
        /// 
        /// Creates a  representing a break statement with the specified type. 
        /// 
        /// The  that the  will jump to.
        /// An  to set the  property equal to.
        ///  
        /// A  with  equal to Break,
        /// the  property set to , 
        /// and the  property set to . 
        /// 
        public static GotoExpression Break(LabelTarget target, Type type) { 
            return MakeGoto(GotoExpressionKind.Break, target, null, type);
        }

        ///  
        /// Creates a  representing a break statement with the specified type.
        /// The value passed to the label upon jumping can be specified. 
        ///  
        /// The  that the  will jump to.
        /// The value that will be passed to the associated label upon jumping. 
        /// An  to set the  property equal to.
        /// 
        /// A  with  equal to Break,
        /// the  property set to , 
        /// the  property set to ,
        /// and  to be passed to the target label upon jumping. 
        ///  
        public static GotoExpression Break(LabelTarget target, Expression value, Type type) {
            return MakeGoto(GotoExpressionKind.Break, target, value, type); 
        }

        /// 
        /// Creates a  representing a continue statement. 
        /// 
        /// The  that the  will jump to. 
        ///  
        /// A  with  equal to Continue,
        /// the  property set to , 
        /// and a null value to be passed to the target label upon jumping.
        /// 
        public static GotoExpression Continue(LabelTarget target) {
            return MakeGoto(GotoExpressionKind.Continue, target, null, typeof(void)); 
        }
 
        ///  
        /// Creates a  representing a continue statement with the specified type.
        ///  
        /// The  that the  will jump to.
        /// An  to set the  property equal to.
        /// 
        /// A  with  equal to Continue, 
        /// the  property set to ,
        /// the  property set to , 
        /// and a null value to be passed to the target label upon jumping. 
        /// 
        public static GotoExpression Continue(LabelTarget target, Type type) { 
            return MakeGoto(GotoExpressionKind.Continue, target, null, type);
        }

        ///  
        /// Creates a  representing a return statement.
        ///  
        /// The  that the  will jump to. 
        /// 
        /// A  with  equal to Return, 
        /// the  property set to ,
        /// and a null value to be passed to the target label upon jumping.
        /// 
        public static GotoExpression Return(LabelTarget target) { 
            return MakeGoto(GotoExpressionKind.Return, target, null, typeof(void));
        } 
 
        /// 
        /// Creates a  representing a return statement with the specified type. 
        /// 
        /// The  that the  will jump to.
        /// An  to set the  property equal to.
        ///  
        /// A  with  equal to Return,
        /// the  property set to , 
        /// the  property set to , 
        /// and a null value to be passed to the target label upon jumping.
        ///  
        public static GotoExpression Return(LabelTarget target, Type type) {
            return MakeGoto(GotoExpressionKind.Return, target, null, type);
        }
 
        /// 
        /// Creates a  representing a return statement. The value passed to the label upon jumping can be specified. 
        ///  
        /// The  that the  will jump to.
        /// The value that will be passed to the associated label upon jumping. 
        /// 
        /// A  with  equal to Continue,
        /// the  property set to ,
        /// and  to be passed to the target label upon jumping. 
        /// 
        public static GotoExpression Return(LabelTarget target, Expression value) { 
            return MakeGoto(GotoExpressionKind.Return, target, value, typeof(void)); 
        }
 
        /// 
        /// Creates a  representing a return statement with the specified type.
        /// The value passed to the label upon jumping can be specified.
        ///  
        /// The  that the  will jump to.
        /// The value that will be passed to the associated label upon jumping. 
        /// An  to set the  property equal to. 
        /// 
        /// A  with  equal to Continue, 
        /// the  property set to ,
        /// the  property set to ,
        /// and  to be passed to the target label upon jumping.
        ///  
        public static GotoExpression Return(LabelTarget target, Expression value, Type type) {
            return MakeGoto(GotoExpressionKind.Return, target, value, type); 
        } 

        ///  
        /// Creates a  representing a goto.
        /// 
        /// The  that the  will jump to.
        ///  
        /// A  with  equal to Goto,
        /// the  property set to the specified value, 
        /// and a null value to be passed to the target label upon jumping. 
        /// 
        public static GotoExpression Goto(LabelTarget target) { 
            return MakeGoto(GotoExpressionKind.Goto, target, null, typeof(void));
        }

        ///  
        /// Creates a  representing a goto with the specified type.
        ///  
        /// The  that the  will jump to. 
        /// An  to set the  property equal to.
        ///  
        /// A  with  equal to Goto,
        /// the  property set to the specified value,
        /// the  property set to ,
        /// and a null value to be passed to the target label upon jumping. 
        /// 
        public static GotoExpression Goto(LabelTarget target, Type type) { 
            return MakeGoto(GotoExpressionKind.Goto, target, null, type); 
        }
 
        /// 
        /// Creates a  representing a goto. The value passed to the label upon jumping can be specified.
        /// 
        /// The  that the  will jump to. 
        /// The value that will be passed to the associated label upon jumping.
        ///  
        /// A  with  equal to Goto, 
        /// the  property set to ,
        /// and  to be passed to the target label upon jumping. 
        /// 
        public static GotoExpression Goto(LabelTarget target, Expression value) {
            return MakeGoto(GotoExpressionKind.Goto, target, value, typeof(void));
        } 

        ///  
        /// Creates a  representing a goto with the specified type. 
        /// The value passed to the label upon jumping can be specified.
        ///  
        /// The  that the  will jump to.
        /// The value that will be passed to the associated label upon jumping.
        /// An  to set the  property equal to.
        ///  
        /// A  with  equal to Goto,
        /// the  property set to , 
        /// the  property set to , 
        /// and  to be passed to the target label upon jumping.
        ///  
        public static GotoExpression Goto(LabelTarget target, Expression value, Type type) {
            return MakeGoto(GotoExpressionKind.Goto, target, value, type);
        }
 
        /// 
        /// Creates a  representing a jump of the specified . 
        /// The value passed to the label upon jumping can also be specified. 
        /// 
        /// The  of the . 
        /// The  that the  will jump to.
        /// The value that will be passed to the associated label upon jumping.
        /// An  to set the  property equal to.
        ///  
        /// A  with  equal to ,
        /// the  property set to , 
        /// the  property set to , 
        /// and  to be passed to the target label upon jumping.
        ///  
        public static GotoExpression MakeGoto(GotoExpressionKind kind, LabelTarget target, Expression value, Type type) {
            ValidateGoto(target, ref value, "target", "value");
            return new GotoExpression(kind, target, value, type);
        } 

        private static void ValidateGoto(LabelTarget target, ref Expression value, string targetParameter, string valueParameter) { 
            ContractUtils.RequiresNotNull(target, targetParameter); 
            if (value == null) {
                if (target.Type != typeof(void)) throw Error.LabelMustBeVoidOrHaveExpression(); 
            } else {
                ValidateGotoType(target.Type, ref value, valueParameter);
            }
        } 

        // Standard argument validation, taken from ValidateArgumentTypes 
        private static void ValidateGotoType(Type expectedType, ref Expression value, string paramName) { 
            RequiresCanRead(value, paramName);
            if (expectedType != typeof(void)) { 
                if (!TypeUtils.AreReferenceAssignable(expectedType, value.Type)) {
                    // C# autoquotes return values, so we'll do that here
                    if (TypeUtils.IsSameOrSubclass(typeof(LambdaExpression), expectedType) &&
                        expectedType.IsAssignableFrom(value.GetType())) { 
                        value = Expression.Quote(value);
                    } 
                    throw Error.ExpressionTypeDoesNotMatchLabel(value.Type, expectedType); 
                }
            } 
        }

    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
GotoExpression.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
