C# CodeGenerator.EmitArrayKey方法代码示例

		/// <summary>
		/// Emits code to prepare an evaluation stack for storing a reference into a variable.
		/// Supports operators chaining. Store is finished by calling <see cref="EmitAssign"/>.
		/// </summary>
		/// <param name="codeGenerator"></param>
		private PhpTypeCode EmitNodeWriteRef(CodeGenerator codeGenerator)
		{
			ChainBuilder chain = codeGenerator.ChainBuilder;

			// Case 3: a_[x]_[x] never reached
			Debug.Assert(chain.IsArrayItem == false);

			// Case 4,5 never reached
			// 4: a[x]->...
			// 5: ...->a[]->...
			Debug.Assert(chain.IsMember == false);

			// 1, 2, 6, 7
			if (this.isMemberOf != null)
			{
				// 6, 7: ...->a[x]_[x]_
				chain.Create();
				chain.Begin();
				// Store isMemberOf for lazy emit
				chain.SetObjectForLazyEmit(this);
				chain.IsArrayItem = true;
				chain.IsLastMember = false;
				chain.Lengthen(); // for own []
				array.Emit(codeGenerator);
				indexTypeCode = codeGenerator.EmitArrayKey(chain, index);
							
				// Note that EmitAssign will finish the work (SetArrayItem or PhpArray.Add)
			}
			else
			{
				// 1, 2
				Debug.Assert(this.isMemberOf == null);

				if (array is ItemUse || array is DirectStFldUse || array is IndirectStFldUse /* ??? */)
				{
					// 2: a[]_[]_
					chain.Create();
					chain.Begin();
					chain.IsArrayItem = true;
					chain.IsLastMember = true;
					array.Emit(codeGenerator);
					indexTypeCode = codeGenerator.EmitArrayKey(chain, index);
							
					// Note that further work will be done by EmitAssign (SetArrayItem or PhpArray.Add)
				}
				// 1: a_[x]_
				// Do nothing now, let the work be done in EmitAssign()
				// Note further work will be done by EmitAssign (either SetItem or SetItemRef);	
			}
			return PhpTypeCode.Unknown;
		}

		/// <summary>
		/// Finishes the write operation starte by <see cref="Emit"/>.
		/// </summary>
		internal override PhpTypeCode EmitAssign(CodeGenerator/*!*/ codeGenerator)
		{
			ChainBuilder chain = codeGenerator.ChainBuilder;
			PhpTypeCode result;

			switch (access)
			{
				case AccessType.WriteAndReadRef:
				case AccessType.WriteAndReadUnknown:
				case AccessType.ReadAndWrite:
				case AccessType.ReadAndWriteAndReadRef:
				case AccessType.ReadAndWriteAndReadUnknown:
				case AccessType.Write:
				case AccessType.WriteRef:
					{
						bool reference = access == AccessType.WriteRef;

						// Note that some work was done in Emit() !
						// In cases 3, 4, 5 EmitAssign is not called

						if (isMemberOf != null ||
						   (isMemberOf == null && (array is DirectStFldUse || array is IndirectStFldUse || array is ItemUse)))
						{
							// 2, 6, 7
							chain.EmitSetArrayItem(indexTypeCode, index, reference);
							chain.End();
						}
						else
						{
							// Note: The value which should be stored is already loaded on the evaluation stack.
							//				Push the destination array and index and call the operator
							// 1: a_[x]_
							Debug.Assert(array is SimpleVarUse);
							chain.IsArrayItem = true;
							chain.IsLastMember = true;
							indexTypeCode = codeGenerator.EmitArrayKey(chain, index);
							array.Emit(codeGenerator);
							chain.EmitSetItem(indexTypeCode, index, reference);

							// Store the changed variable into table of variables (do nothing in optimalized functions)
							((SimpleVarUse)array).EmitLoadAddress_StoreBack(codeGenerator);
						}

						result = PhpTypeCode.Void;
						break;
					}

				case AccessType.None:
					// do nothing
					result = PhpTypeCode.Void;
					break;

				case AccessType.Read:
					// do nothing
					result = PhpTypeCode.Object;
					break;

				case AccessType.ReadRef:
					// Do nothing
					result = PhpTypeCode.PhpReference;
					break;

				default:
					Debug.Fail();
					result = PhpTypeCode.Invalid;
					break;
			}

			return result;
		}

		/// <summary>
		/// Emits code to prepare an evaluation stack for storing a value into a variable.
		/// Supports operators chaining. Store is finished by calling <see cref="EmitAssign"/>.
		/// </summary>
		/// <param name="codeGenerator"></param>
		private PhpTypeCode EmitNodeWrite(CodeGenerator codeGenerator)
		{
			ChainBuilder chain = codeGenerator.ChainBuilder;

			if (chain.IsArrayItem)
			{
				// 3: a_[x]_[v]
				Debug.Assert(this.isMemberOf == null);
				return chain.EmitEnsureItem(array, index, true);
			}

			// 1, 2, 4, 5, 6, 7
			if (chain.IsMember)
			{
				// 4, 5
				if (this.isMemberOf != null)
				{
					// 5: ...->a[]->...
					// Store isMemberOf for lazy emit
					chain.SetObjectForLazyEmit(this);
					chain.IsArrayItem = true;
					chain.IsLastMember = false;
				}
				else
				{
					// 4: a_[x]_->c->..., a[x]_[x]_->c->...
					chain.IsArrayItem = true;
					chain.IsLastMember = true;
				}

				PhpTypeCode result = chain.EmitEnsureItem(array, index, false);
				chain.IsArrayItem = false;
				return result;
			}

			// 1, 2, 6, 7
			if (this.isMemberOf != null)
			{
				// 6, 7: ...->a[x]_[x]_
				chain.Create();
				chain.Begin();
				// Store isMemberOf for lazy emit
				chain.SetObjectForLazyEmit(this);
				chain.IsArrayItem = true;
				chain.IsLastMember = false;
				chain.Lengthen(); // for own []
				array.Emit(codeGenerator);
				indexTypeCode = codeGenerator.EmitArrayKey(chain, index);
														
				// Note that EmitAssign will finish the work (SetArrayItem or PhpArray.Add)
				return PhpTypeCode.Unknown;
			}
			// 1, 2
			Debug.Assert(this.isMemberOf == null);

			if (array is ItemUse || array is DirectStFldUse || array is IndirectStFldUse /* ??? */)
			{
				// 2: a[]_[]_
				chain.Create();
				chain.Begin();
				chain.IsArrayItem = true;
				chain.IsLastMember = true;
				array.Emit(codeGenerator);
				indexTypeCode = codeGenerator.EmitArrayKey(chain, index);
							
							
				// Note that further work will be done by EmitAssign (SetArrayItem or PhpArray.Add)
				return PhpTypeCode.Unknown;
			}

			// 1: a_[x]_
			// Do nothing now, let the work be done in EmitAssign()
			return PhpTypeCode.Unknown;
		}

		/// <summary>
		/// Emit IL instructions that load the value of array index at the stack.
		/// </summary>
		internal PhpTypeCode EmitIndex(CodeGenerator/*!*/ codeGenerator)
		{
			return codeGenerator.EmitArrayKey(null, index);
		}