override public void LeaveUnaryExpression(UnaryExpression node)
		{
			if (node.Operator == UnaryOperatorType.SafeAccess)
			{
				// target references should already be resolved, so just evaluate as existential
				var notnull = CodeBuilder.CreateNotNullTest(node.Operand);
				ReplaceCurrentNode(notnull);
			}
		}

 public override void LeaveUnaryExpression(UnaryExpression node)
 {
     switch (node.Operator)
     {
     case UnaryOperatorType.LogicalNot:
         node.Operand = ExplicitBooleanContext(node.Operand);
         break;
     }
 }

 public override void LeaveUnaryExpression(UnaryExpression node)
 {
     if (IsDuckTyped(node.Operand) &&
        node.Operator == UnaryOperatorType.UnaryNegation)
     {
         BindDuck(node);
     }
     else
     {
         base.LeaveUnaryExpression(node);
     }
 }

 public override void LeaveMethodInvocationExpression(MethodInvocationExpression node)
 {
     IEntityWithParameters parameters = node.get_Target().get_Entity() as IEntityWithParameters;
     if (parameters != null)
     {
         ExpressionCollection args = node.get_Arguments();
         if (parameters.get_AcceptVarArgs() && UnityCallableResolutionServiceModule.IsArrayArgumentExplicitlyProvided(parameters.GetParameters(), args))
         {
             UnaryExpression expression2;
             Expression expression = args.get_Item(-1);
             UnaryExpression expression1 = expression2 = new UnaryExpression();
             expression2.set_Operator(7);
             expression2.set_Operand(expression);
             expression2.set_ExpressionType(this.GetExpressionType(expression));
             args.ReplaceAt(-1, expression2);
         }
     }
 }

 private void ProcessOperatorOverload(UnaryExpression node)
 {
     if (! ResolveOperator(node))
     {
         InvalidOperatorForType(node);
     }
 }

 private void LeaveUnaryNegation(UnaryExpression node)
 {
     if (IsPrimitiveNumber(node.Operand))
         BindExpressionType(node, GetExpressionType(node.Operand));
     else
         ProcessOperatorOverload(node);
 }

 private void LeaveLogicalNot(UnaryExpression node)
 {
     BindExpressionType(node, TypeSystemServices.BoolType);
 }

 void LeaveIncrementDecrement(UnaryExpression node)
 {
     if (AssertLValue(node.Operand))
     {
         if (!IsValidIncrementDecrementOperand(node.Operand))
             InvalidOperatorForType(node);
         else
             ExpandIncrementDecrement(node);
     }
     else
         Error(node);
 }

 void InvalidOperatorForType(UnaryExpression node)
 {
     Error(node, CompilerErrorFactory.InvalidOperatorForType(node,
                                                             GetUnaryOperatorText(node.Operator),
                                                             GetExpressionType(node.Operand)));
 }

 Expression ExpandIncrementDecrementArraySlicing(UnaryExpression node)
 {
     SlicingExpression slicing = (SlicingExpression)node.Operand;
     AssertIsNotComplexSlicing(slicing);
     Visit(slicing);
     return CreateSideEffectAwareSlicingOperation(
         node.LexicalInfo,
         GetEquivalentBinaryOperator(node.Operator),
         slicing,
         CodeBuilder.CreateIntegerLiteral(1),
         DeclareOldValueTempIfNeeded(node));
 }

 private void EmitUnaryNegation(UnaryExpression node)
 {
     IType operandType = GetExpressionType(node.Operand);
     if (!_checked || !TypeSystemServices.IsIntegerNumber(operandType))
     {
         //a single/double unary negation never overflow
         node.Operand.Accept(this);
         _il.Emit(OpCodes.Neg);
     }
     else
     {
         _il.Emit(OpCodes.Ldc_I4_0);
         if (operandType == TypeSystemServices.LongType || operandType == TypeSystemServices.ULongType)
             _il.Emit(OpCodes.Conv_I8);
         node.Operand.Accept(this);
         _il.Emit(TypeSystemServices.IsSignedNumber(operandType)
                  ? OpCodes.Sub_Ovf : OpCodes.Sub_Ovf_Un);
         if (operandType != TypeSystemServices.LongType && operandType != TypeSystemServices.ULongType)
             EmitCastIfNeeded(operandType, TypeSystemServices.IntType);
     }
 }

 private void EmitOnesComplement(UnaryExpression node)
 {
     node.Operand.Accept(this);
     _il.Emit(OpCodes.Not);
 }

        private void EmitLogicalNot(UnaryExpression node)
        {
            Expression operand = node.Operand;
            operand.Accept(this);
            IType typeOnStack = PopType();
            bool notContext = true;

            if (IsBoolOrInt(typeOnStack))
            {
                EmitIntNot();
            }
            else if (EmitToBoolIfNeeded(operand, ref notContext))
            {
                if (!notContext) //we are in a not context and emit to bool is also in a not context
                    EmitIntNot();//so we do not need any not (false && false => true)
            }
            else
            {
                EmitGenericNot();
            }
            PushBool();
        }

        void EmitIndirection(UnaryExpression node)
        {
            node.Operand.Accept(this);

            if (node.Operand.NodeType != NodeType.ReferenceExpression
                && node.ParentNode.NodeType != NodeType.MemberReferenceExpression)
            {
                //pointer arithmetic, need to load the address
                IType et = PeekTypeOnStack().ElementType;
                OpCode code = GetLoadRefParamCode(et);
                if (code == OpCodes.Ldobj)
                    _il.Emit(code, GetSystemType(et));
                else
                    _il.Emit(code);

                PopType();
                PushType(et);
            }
        }

 void EmitBranch(bool branchOnTrue, UnaryExpression expression, Label label)
 {
     if (UnaryOperatorType.LogicalNot == expression.Operator)
     {
         EmitBranch(!branchOnTrue, expression.Operand, label);
     }
     else
     {
         EmitDefaultBranch(branchOnTrue, expression, label);
     }
 }

 InternalLocal DeclareOldValueTempIfNeeded(UnaryExpression node)
 {
     return AstUtil.IsPostUnaryOperator(node.Operator)
         ? DeclareTempLocal(GetExpressionType(node.Operand))
         : null;
 }

        void ExpandIncrementDecrement(UnaryExpression node)
        {
            var expansion = IsArraySlicing(node.Operand)
                ? ExpandIncrementDecrementArraySlicing(node)
                : ExpandSimpleIncrementDecrement(node);

            node.ParentNode.Replace(node, expansion);

            Visit(expansion);
        }

//.........这里部分代码省略.........
				case UNLESS:
				{
					{
						switch ( LA(1) )
						{
						case IF:
						{
							match(IF);
							break;
						}
						case UNLESS:
						{
							u = LT(1);
							match(UNLESS);
							break;
						}
						default:
						{
							throw new NoViableAltException(LT(1), getFilename());
						}
						 }
					}
					e=boolean_expression();
					break;
				}
				case COLON:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				 }
			}
			if (0==inputState.guessing)
			{
				
						eh = new ExceptionHandler(ToLexicalInfo(c));
						
						eh.Declaration = new Declaration();
						eh.Declaration.Type = tr;
						
						if (x != null)
						{
							eh.Declaration.LexicalInfo = ToLexicalInfo(x);
							eh.Declaration.Name = x.getText();		
						}
						else
						{
							eh.Declaration.Name = null;
							eh.Flags |= ExceptionHandlerFlags.Anonymous;
						}
						if (tr != null)
						{
							eh.Declaration.LexicalInfo = tr.LexicalInfo;
						}
						else if (x != null)
						{
							eh.Declaration.LexicalInfo = eh.LexicalInfo;
						}
						if(tr == null)
						{
							eh.Flags |= ExceptionHandlerFlags.Untyped;
						}
						if (e != null)
						{
							if(u != null)
							{
								UnaryExpression not = new UnaryExpression(ToLexicalInfo(u));
								not.Operator = UnaryOperatorType.LogicalNot;
								not.Operand = e;
								e = not;
							}
							eh.FilterCondition = e;
							eh.Flags |= ExceptionHandlerFlags.Filter;
						}
					
			}
			compound_stmt(eh.Block);
			if (0==inputState.guessing)
			{
				
						t.ExceptionHandlers.Add(eh);
					
			}
		}
		catch (RecognitionException ex)
		{
			if (0 == inputState.guessing)
			{
				reportError(ex, "exception_handler");
				recover(ex,tokenSet_106_);
			}
			else
			{
				throw ex;
			}
		}
	}

        Expression ExpandSimpleIncrementDecrement(UnaryExpression node)
        {
            var oldValue = DeclareOldValueTempIfNeeded(node);
            var type = GetExpressionType(node.Operand);

            var addition = CodeBuilder.CreateBoundBinaryExpression(
                type,
                GetEquivalentBinaryOperator(node.Operator),
                CloneOrAssignToTemp(oldValue, node.Operand),
                CodeBuilder.CreateIntegerLiteral(1));

            var assign = CodeBuilder.CreateAssignment(
                node.LexicalInfo,
                node.Operand,
                addition);

            // Resolve operator overloads if any
            BindArithmeticOperator(addition);

            return oldValue == null
                ? (Expression) assign
                : CodeBuilder.CreateEvalInvocation(
                    node.LexicalInfo,
                    assign,
                    CodeBuilder.CreateReference(oldValue));
        }

	protected Expression  not_expression() //throws RecognitionException, TokenStreamException
{
		Expression e;
		
		IToken  nt = null;
		
				e = null;
			
		
		try {      // for error handling
			{
				switch ( LA(1) )
				{
				case NOT:
				{
					{
						nt = LT(1);
						match(NOT);
						e=not_expression();
					}
					break;
				}
				case ESEPARATOR:
				case CAST:
				case CHAR:
				case FALSE:
				case NULL:
				case SELF:
				case SUPER:
				case THEN:
				case TRUE:
				case TYPEOF:
				case TRIPLE_QUOTED_STRING:
				case LPAREN:
				case DOUBLE_QUOTED_STRING:
				case SINGLE_QUOTED_STRING:
				case ID:
				case MULTIPLY:
				case LBRACK:
				case SPLICE_BEGIN:
				case DOT:
				case LBRACE:
				case QQ_BEGIN:
				case SUBTRACT:
				case LONG:
				case INCREMENT:
				case DECREMENT:
				case ONES_COMPLEMENT:
				case INT:
				case BACKTICK_QUOTED_STRING:
				case RE_LITERAL:
				case DOUBLE:
				case FLOAT:
				case TIMESPAN:
				{
					e=assignment_expression();
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				 }
			}
			if (0==inputState.guessing)
			{
				
						if (nt != null)
						{
							UnaryExpression ue = new UnaryExpression(ToLexicalInfo(nt));
							ue.Operator = UnaryOperatorType.LogicalNot;
							ue.Operand = e;
							e = ue;
						}
					
			}
		}
		catch (RecognitionException ex)
		{
			if (0 == inputState.guessing)
			{
				reportError(ex, "not_expression");
				recover(ex,tokenSet_107_);
			}
			else
			{
				throw ex;
			}
		}
		return e;
	}