C# EmitContext.StartFlowBranching方法代码示例

		/// <summary>
		///   We already know that the statement is unreachable, but we still
		///   need to resolve it to catch errors.
		/// </summary>
		public virtual bool ResolveUnreachable (EmitContext ec, bool warn)
		{
			//
			// This conflicts with csc's way of doing this, but IMHO it's
			// the right thing to do.
			//
			// If something is unreachable, we still check whether it's
			// correct.  This means that you cannot use unassigned variables
			// in unreachable code, for instance.
			//

			if (warn)
				Report.Warning (162, 2, loc, "Unreachable code detected");

			ec.StartFlowBranching (FlowBranching.BranchingType.Block, loc);
			bool ok = Resolve (ec);
			ec.KillFlowBranching ();

			return ok;
		}

				public override bool Resolve (EmitContext ec)
				{
					bool ok = true;

					ec.StartFlowBranching (this);

					if (!parent.ResolveLoop (ec))
						ok = false;

					ec.EndFlowBranching ();

					ResolveReachability (ec);

					if (TypeManager.void_dispose_void == null) {
						TypeManager.void_dispose_void = TypeManager.GetPredefinedMethod (
							TypeManager.idisposable_type, "Dispose", loc, Type.EmptyTypes);
					}
					return ok;
				}

		public bool ResolveMeta (EmitContext ec, Parameters ip)
		{
			int errors = Report.Errors;
			int orig_count = parameters.Count;

			if (top_level_branching != null)
				return true;

			if (ip != null)
				parameters = ip;

			// Assert: orig_count != parameter.Count => orig_count == 0
			if (orig_count != 0 && orig_count != parameters.Count)
				throw new InternalErrorException ("parameter information mismatch");

			int offset = Parent == null ? 0 : Parent.AssignableSlots;

			for (int i = 0; i < orig_count; ++i) {
				Parameter.Modifier mod = parameters.FixedParameters [i].ModFlags;

				if ((mod & Parameter.Modifier.OUT) != Parameter.Modifier.OUT)
					continue;

				VariableInfo vi = new VariableInfo (ip, i, offset);
				parameter_info [i].VariableInfo = vi;
				offset += vi.Length;
			}

			ResolveMeta (ec, offset);

			top_level_branching = ec.StartFlowBranching (this);

			return Report.Errors == errors;
		}

		public override bool Resolve (EmitContext ec)
		{
			ec.StartFlowBranching (iterator);
			bool ok = original_block.Resolve (ec);
			ec.EndFlowBranching ();
			return ok;
		}