public void Constructor0_Deny_Unrestricted ()
		{
			CodeArrayIndexerExpression caie = new CodeArrayIndexerExpression ();
			Assert.AreEqual (0, caie.Indices.Count, "Indices");
			Assert.IsNull (caie.TargetObject, "TargetObject");
			caie.TargetObject = new CodeExpression ();
		}

        void EmitArrayIndexer(CodeArrayIndexerExpression array)
        {
            if (array.TargetObject is CodePropertyReferenceExpression &&
                ((CodePropertyReferenceExpression)array.TargetObject).PropertyName == Parser.VarProperty &&
                array.Indices.Count == 1 && array.Indices[0] is CodePrimitiveExpression)
            {
                var name = ((CodePrimitiveExpression)array.Indices[0]).Value as string;

                if (name != null)
                {
                    var sep = name.IndexOf(Parser.ScopeVar);

                    if (sep != -1)
                        name = name.Substring(sep + 1);

                    writer.Write(name);
                    return;
                }
            }

            EmitExpression(array.TargetObject);

            foreach (CodeExpression index in array.Indices)
            {
                writer.Write(Parser.ArrayOpen);
                EmitExpression(index);
                writer.Write(Parser.ArrayClose);
            }
        }

		public void Constructor1_Deny_Unrestricted ()
		{
			CodeExpression target = new CodeExpression ();
			CodeExpression[] parameters = new CodeExpression[1] { target };
			CodeArrayIndexerExpression caie = new CodeArrayIndexerExpression (target, parameters);
			Assert.AreEqual (1, caie.Indices.Count, "Indices");
			Assert.AreSame (target, caie.TargetObject, "TargetObject");
			caie.TargetObject = new CodeExpression ();
		}

 public static CodeArrayIndexerExpression Clone(this CodeArrayIndexerExpression expression)
 {
     if (expression == null) return null;
     CodeArrayIndexerExpression e = new CodeArrayIndexerExpression();
     e.Indices.AddRange(expression.Indices.Clone());
     e.TargetObject = expression.TargetObject.Clone();
     e.UserData.AddRange(expression.UserData);
     return e;
 }

        private void EmitArrayIndexerExpression(CodeArrayIndexerExpression Indexer)
        {
            var index = (CodeArrayIndexerExpression) Indexer;

            Generator.Emit(OpCodes.Ldloc, VarsProperty);
            EmitExpression(index.Indices[0]);

            Generator.Emit(OpCodes.Callvirt, GetVariable);
        }

        /// <summary>
        /// Visits a <see cref="CodeArrayIndexerExpression"/>.
        /// </summary>
        /// <param name="codeArrayIndexerExpression">The <see cref="CodeArrayIndexerExpression"/> to visit.</param>
        protected virtual void VisitCodeArrayIndexerExpression(CodeArrayIndexerExpression codeArrayIndexerExpression)
        {
            if (codeArrayIndexerExpression == null)
            {
                return;
            }

            this.VisitCodeExpression(codeArrayIndexerExpression.TargetObject);
            this.VisitCodeExpressionCollection(codeArrayIndexerExpression.Indices);
        }

 private CodeExpression BuildArray(CodeStatementCollection statements, string name, object value)
 {
     Array array = (Array) value;
     Type type = value.GetType();
     string uniqueVariableName = GetUniqueVariableName(name, statements);
     CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement(type.FullName, uniqueVariableName);
     statement.InitExpression = new CodeArrayCreateExpression(type.GetElementType(), array.Length);
     statements.Add(statement);
     CodeVariableReferenceExpression targetObject = new CodeVariableReferenceExpression(uniqueVariableName);
     string str2 = name + "_";
     for (int i = 0; i < array.Length; i++)
     {
         CodeArrayIndexerExpression left = new CodeArrayIndexerExpression(targetObject, new CodeExpression[0]);
         left.Indices.Add(new CodePrimitiveExpression(i));
         CodeExpression right = this.BuildObject(statements, str2 + i.ToString(), array.GetValue(i));
         statements.Add(new CodeAssignStatement(left, right));
     }
     return targetObject;
 }

        static CodeMemberProperty CreateProperty(PropertyNameType nameType, string constantsClassName, string defaultValuesClassName)
        {
            CodeMemberProperty publicProp = new CodeMemberProperty();
            publicProp.Name = nameType.propertyName;
            publicProp.Attributes = CodeDomHelperObjects.PublicFinal;
            publicProp.HasGet = true;
            publicProp.HasSet = true;
            publicProp.Type = new CodeTypeReference(nameType.propertyType);

            CodeAttributeDeclarationCollection attributes = new CodeAttributeDeclarationCollection();
            CodeAttributeArgument arg1 = new CodeAttributeArgument(
                                            new CodeFieldReferenceExpression(
                                                new CodeTypeReferenceExpression(constantsClassName),
                                                nameType.propertyName));
            CodeAttributeArgument arg2 = new CodeAttributeArgument(
                                            PropertyNameConstants.DefaultValueProperty,
                                            new CodeFieldReferenceExpression(
                                                new CodeTypeReferenceExpression(defaultValuesClassName),
                                                Constants.DefaultPrefix + nameType.propertyName));
            // Future TODO: Provide a library with attributes that custom channel writes 
            // can use to adorn their properties with default values and validators, we can
            // then add it here.
            attributes.Add(new CodeAttributeDeclaration(
                            new CodeTypeReference(TypeNameConstants.ConfigurationProperty),
                            arg1, arg2));
            publicProp.CustomAttributes = new CodeAttributeDeclarationCollection(attributes);
            string nameInConfig = constantsClassName + "." + nameType.propertyName;
            CodeArrayIndexerExpression baseIndexedProperty
                                        = new CodeArrayIndexerExpression(
                                            CodeDomHelperObjects.BaseRef,
                                            new CodeFieldReferenceExpression(
                                                new CodeTypeReferenceExpression(constantsClassName),
                                                nameType.propertyName));
            publicProp.GetStatements.Add(new CodeMethodReturnStatement(
                                                new CodeCastExpression(
                                                    nameType.propertyType,
                                                    baseIndexedProperty)));
            publicProp.SetStatements.Add(new CodeAssignStatement(
                                                baseIndexedProperty,
                                                new CodePropertySetValueReferenceExpression()));
            return publicProp;
        }

		protected override void CreateConstructor (CodeStatementCollection localVars,
							   CodeStatementCollection trueStmt)
		{
#if NET_2_0
			if (!String.IsNullOrEmpty (pageParser.MasterPageFile))
				// This is here just to trigger master page build, so that its type
				// is available when compiling the page itself.
				BuildManager.GetCompiledType (pageParser.MasterPageFile);
#endif
			if (pageParser.ClientTarget != null) {
				CodeExpression prop;
				prop = new CodePropertyReferenceExpression (thisRef, "ClientTarget");
				CodeExpression ct = new CodePrimitiveExpression (pageParser.ClientTarget);
				if (localVars == null)
					localVars = new CodeStatementCollection ();
				localVars.Add (new CodeAssignStatement (prop, ct));
			}

			ArrayList deps = pageParser.Dependencies;
			int depsCount = deps != null ? deps.Count : 0;
			
			if (depsCount > 0) {
				if (localVars == null)
					localVars = new CodeStatementCollection ();
				if (trueStmt == null)
					trueStmt = new CodeStatementCollection ();

				CodeAssignStatement assign;
#if NET_2_0
				localVars.Add (
					new CodeVariableDeclarationStatement (
						typeof (string[]),
						"dependencies")
				);

				CodeVariableReferenceExpression dependencies = new CodeVariableReferenceExpression ("dependencies");
				trueStmt.Add (
					new CodeAssignStatement (dependencies, new CodeArrayCreateExpression (typeof (string), depsCount))
				);
				
				CodeArrayIndexerExpression arrayIndex;
				object o;
				
				for (int i = 0; i < depsCount; i++) {
					o = deps [i];
					arrayIndex = new CodeArrayIndexerExpression (dependencies, new CodeExpression[] {new CodePrimitiveExpression (i)});
					assign = new CodeAssignStatement (arrayIndex, new CodePrimitiveExpression (o));
					trueStmt.Add (assign);
				}
				
				CodeMethodInvokeExpression getDepsCall = new CodeMethodInvokeExpression (
					thisRef,
					"GetWrappedFileDependencies",
					new CodeExpression[] {dependencies}
				);
				assign = new CodeAssignStatement (GetMainClassFieldReferenceExpression ("__fileDependencies"), getDepsCall);
#else
				localVars.Add (new CodeVariableDeclarationStatement (
						typeof (ArrayList),
						"dependencies")
				);

				CodeVariableReferenceExpression dependencies = new CodeVariableReferenceExpression ("dependencies");
				trueStmt.Add (
					new CodeAssignStatement (dependencies, new CodeObjectCreateExpression (typeof (ArrayList), new CodeExpression[] {new CodePrimitiveExpression (depsCount)}))
				);

				CodeMethodInvokeExpression invoke;
				for (int i = 0; i < depsCount; i++) {
					invoke = new CodeMethodInvokeExpression (dependencies, "Add", new CodeExpression[] {new CodePrimitiveExpression (deps [i])});
					trueStmt.Add (invoke);
				}
				assign = new CodeAssignStatement (GetMainClassFieldReferenceExpression ("__fileDependencies"), dependencies);
#endif

				trueStmt.Add (assign);
			}

			base.CreateConstructor (localVars, trueStmt);
		}

		private void CreateVertexInputMethods()
		{
			AsmListing asmVS = this.source.GetAsmTechnique(this.techniqueName, this.platform).VertexShader;

			//create the GetVertexInputCount() and GetVertexInput() methods

			CodeMemberMethod count = new CodeMemberMethod();
			count.Name = "GetVertexInputCountImpl";
			count.Attributes = MemberAttributes.Family | MemberAttributes.Override;
			count.ReturnType = new CodeTypeReference(typeof(int));

			Comment(count, "Returns the number of vertex inputs used by this shader");
			count.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(asmVS.InputCount)));
			classDom.Members.Add(count);

			//inputs are stored in a static array

			//create it...

			int[] arrayValues = new int[asmVS.InputCount * 2];
			for (int i = 0; i < asmVS.InputCount; i++)
			{
				arrayValues[i] = (int)asmVS.GetInput(i).Usage;
				arrayValues[i + asmVS.InputCount] = (int)asmVS.GetInput(i).Index;
			}

			this.vsInputField = new CodeMemberField(typeof(int[]), "vin");
			this.vsInputField.Attributes = MemberAttributes.Private | MemberAttributes.Static | MemberAttributes.Final;
			this.vsInputField.InitExpression = ShaderBytes.ToArray(arrayValues, this.directives);

			CodeFieldReferenceExpression vsInputRef = new CodeFieldReferenceExpression(ShaderClassEx, vsInputField.Name);

			//protected internal abstract void GetVertexInput(int index, out VertexElementUsage elementUsage, out int elementIndex);

			CodeMemberMethod getInput = new CodeMemberMethod();
			getInput.Name = "GetVertexInputImpl";
			getInput.Attributes = MemberAttributes.Family | MemberAttributes.Override;

			CodeParameterDeclarationExpression indexParam = new CodeParameterDeclarationExpression(typeof(int),"i");
			getInput.Parameters.Add(indexParam);

			CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(VertexElementUsage), "usage");
			param.Direction = FieldDirection.Out;
			getInput.Parameters.Add(param);

			param = new CodeParameterDeclarationExpression(typeof(int), "index");
			param.Direction = FieldDirection.Out;
			getInput.Parameters.Add(param);

			CodeArgumentReferenceExpression indexRef = new CodeArgumentReferenceExpression(indexParam.Name);

			//the element index is stored at 'i + asmVS.InputCount'
			CodeExpression indexArray = new CodeArrayIndexerExpression(vsInputRef,
				new CodeBinaryOperatorExpression(indexRef, CodeBinaryOperatorType.Add, new CodePrimitiveExpression(asmVS.InputCount)));

			//and the usage must be cast
			CodeExpression usageCast = new CodeCastExpression(typeof(VertexElementUsage), new CodeArrayIndexerExpression(vsInputRef,indexRef));

			getInput.Statements.Add(new CodeAssignStatement(new CodeArgumentReferenceExpression("usage"), usageCast));
			getInput.Statements.Add(new CodeAssignStatement(new CodeArgumentReferenceExpression("index"), indexArray));

			Comment(getInput, "Returns a vertex input used by this shader");

			classDom.Members.Add(getInput);
		}

		protected override void GenerateArrayIndexerExpression (CodeArrayIndexerExpression e)
		{
		}

		protected abstract void GenerateArrayIndexerExpression (CodeArrayIndexerExpression e);

		protected override void GenerateArrayIndexerExpression (CodeArrayIndexerExpression expression)
		{
			TextWriter output = Output;

			GenerateExpression (expression.TargetObject);
			output.Write ("(");
			OutputExpressionList (expression.Indices);
			output.Write (')');
		}

		protected override void GenerateArrayIndexerExpression(CodeArrayIndexerExpression e)
		{
			Output.Write("[CodeArrayIndexerExpression: {0}]", e.ToString());
		}

 /// <summary>
 /// Generates code for the specified array indexer expression.
 /// </summary>
 /// <remarks><c>TARGET[INDEX1][INDEX2]...</c></remarks>
 protected override void GenerateArrayIndexerExpression(CodeArrayIndexerExpression e)
 {
     OutputArrayIndexerExpression(e.TargetObject, e.Indices);
 }

 private CodeBinaryOperatorExpression VarAssign(CodeArrayIndexerExpression name, CodeExpression value)
 {
     return new CodeBinaryOperatorExpression(name, CodeBinaryOperatorType.Assign, value);
 }

		private void CreateConstantSetters(IShaderDom shader, Action<CodeTypeMember, string> add, string name, CodeExpression assignmentField, CodeExpression assignmentArrayField)
		{
			/*
			 * Something like:

			public void SetInvTargetSize(ref Microsoft.Xna.Framework.Vector2 value)
			{
				this.vreg.SetVector2(130, ref value);
			}

			public Microsoft.Xna.Framework.Vector2 InvTargetSize
			{
				set
				{
					this.SetInvTargetSize(ref value);
				}
			}*/

			Register reg;
			Type dataType;
			bool hasSetMethod;
			int stride;

			if (!ExtractRegType(name, out reg, out dataType, out hasSetMethod, out stride))
				return;

			Type arrayOrSingleType = dataType;

			//right...

			//create the method of the given type.


			//public void SetInvTargetSize(ref Microsoft.Xna.Framework.Vector2 value)
			CodeStatementCollection methodStatements = new CodeStatementCollection();

			CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(dataType, "value");
			List<CodeParameterDeclarationExpression> additionalParams = new List<CodeParameterDeclarationExpression>();

			if (reg.ArraySize == -1)
				param.Direction = FieldDirection.Ref;
			else
			{
				arrayOrSingleType = dataType.MakeArrayType();
				param.Type = new CodeTypeReference(arrayOrSingleType);

				//add array params, readIndex, writeIndex, count
				additionalParams.Add(new CodeParameterDeclarationExpression(typeof(uint), "readIndex"));
				additionalParams.Add(new CodeParameterDeclarationExpression(typeof(uint), "writeIndex"));
				additionalParams.Add(new CodeParameterDeclarationExpression(typeof(uint), "count"));
			}

			CodeExpression valueRef = new CodeArgumentReferenceExpression(param.Name);

			//when there isn't a set method, there is just a set property
			if (!hasSetMethod)
				valueRef = new CodePropertySetValueReferenceExpression();

			//create the guts
			//depends on what constants use it...

			//eg:
			//this.vreg.SetVector2(130, ref value);

			Register sreg;

			if (dataType == typeof(bool))
			{
				//special case for booleans, assign the array directly.
				//looks like:
				// 
				// if (preg_bool[index] != value)
				// {
				//  preg_bool[index] = value;
				//  preg_bool_changed = true;
				// }

				foreach (KeyValuePair<AsmListing, CodeExpression> listing in listingRegisters)
				{
					RegisterSet registers = listing.Key.RegisterSet;
					CodeExpression registersRef = listing.Value;

					if (registers.TryGetRegister(name, out sreg))
					{
						if (listing.Key == asm.PixelShader)
						{
							CodeExpression arrayIndex = new CodeArrayIndexerExpression(shader.PixelShaderBooleanRegistersRef, new CodePrimitiveExpression(sreg.Index));

							CodeStatement assign = new CodeAssignStatement(arrayIndex, new CodePropertySetValueReferenceExpression());
							CodeStatement change = new CodeAssignStatement(shader.PixelShaderBooleanRegistersChangedRef, new CodePrimitiveExpression(true));

							CodeStatement condition = new CodeConditionStatement(
								new CodeBinaryOperatorExpression(arrayIndex, CodeBinaryOperatorType.IdentityInequality, new CodePropertySetValueReferenceExpression()),
								new CodeStatement[]{assign, change});

							methodStatements.Add(condition);
						}
						if (listing.Key == asm.VertexShader)
						{
							CodeExpression arrayIndex = new CodeArrayIndexerExpression(shader.VertexShaderBooleanRegistersRef, new CodePrimitiveExpression(sreg.Index));
//.........这里部分代码省略.........

        public override CodeExpression ToCodeExpression()
        {
            CodeArrayIndexerExpression access = new CodeArrayIndexerExpression();
            access.TargetObject = array.ToCodeExpression();

            for (Node n = args; n != null; n = n.nd_next)
                access.Indices.Add(n.ToCodeExpression());

            return access;
        }

            MakeReadFieldStatements(Type type,
                                    CodeExpression objExpr,
                                    FieldInfo finfo,
                                    CodeVariableReferenceExpression[] indexExprs)
        {
            CodeStatement[] stmts;
            CodeExpression readerExpr = new CodeArgumentReferenceExpression("reader");
            string readerName = GetBuiltinReaderName(type);
            if (readerName == null)
            {
                // For non-builtin types
                string serializerName = GetStaticSerializerName(type);
                CodeVariableReferenceExpression serializerExpr = new CodeVariableReferenceExpression(serializerName);                
                CodeVariableDeclarationStatement tempDecl = null;
                CodeExpression setterExpr = null;

                CodeExpression fieldExpr;
                if (finfo == null)
                {
                    fieldExpr = new CodeArrayIndexerExpression(objExpr, indexExprs);
                }
                else if (finfo.IsPublic && !finfo.IsInitOnly)
                {
                    fieldExpr = new CodeFieldReferenceExpression(objExpr, finfo.Name);
                }
                else
                {
                    string fieldName = TypeSystem.FieldName(finfo.Name);
                    if (!TypeSystem.IsBackingField(finfo.Name) ||
                        finfo.DeclaringType.GetProperty(fieldName, FieldFlags).GetSetMethod() == null)
                    {
                        setterExpr = new CodeVariableReferenceExpression(ExtensionClassName + "." + this.SetterFieldName(finfo));
                        fieldName = this.m_fieldToStaticName[finfo];
                    }
                    tempDecl = new CodeVariableDeclarationStatement(type, fieldName);
                    fieldExpr = new CodeVariableReferenceExpression(tempDecl.Name);
                }

                CodeExpression fieldValExpr = new CodeMethodInvokeExpression(serializerExpr, "Read", readerExpr);
                CodeStatement readCall = new CodeAssignStatement(fieldExpr, fieldValExpr);
                if (tempDecl == null)
                {
                    stmts = new CodeStatement[] { readCall };
                }
                else
                {
                    CodeStatement setCall;
                    if (setterExpr == null)
                    {
                        CodeExpression propExpr = new CodePropertyReferenceExpression(objExpr, tempDecl.Name);
                        setCall = new CodeAssignStatement(propExpr, fieldExpr);
                    }
                    else
                    {
                        if (finfo.DeclaringType.IsValueType)
                        {
                            objExpr = new CodeDirectionExpression(FieldDirection.Out, objExpr);
                        }
                        CodeExpression setExpr = new CodeDelegateInvokeExpression(setterExpr, objExpr, fieldExpr);
                        setCall = new CodeExpressionStatement(setExpr);
                    }
                    stmts = new CodeStatement[] { tempDecl, readCall, setCall };
                }
            }
            else
            {
                // for builtin types
                CodeExpression readCall = new CodeMethodInvokeExpression(readerExpr, readerName);
                if (finfo == null)
                {
                    CodeExpression fieldExpr = new CodeArrayIndexerExpression(objExpr, indexExprs);
                    stmts = new CodeStatement[] { new CodeAssignStatement(fieldExpr, readCall) };
                }
                else
                {
                    string fieldName = TypeSystem.FieldName(finfo.Name);
                    if ((finfo.IsPublic && !finfo.IsInitOnly) ||
                        (TypeSystem.IsBackingField(finfo.Name) &&
                         finfo.DeclaringType.GetProperty(fieldName, FieldFlags).GetSetMethod() != null))
                    {
                        CodeExpression fieldExpr = new CodeFieldReferenceExpression(objExpr, fieldName);
                        stmts = new CodeStatement[] { new CodeAssignStatement(fieldExpr, readCall) };
                    }
                    else
                    {
                        CodeExpression setterExpr = new CodeVariableReferenceExpression(
                                                            ExtensionClassName + "." + this.SetterFieldName(finfo));
                        if (finfo.DeclaringType.IsValueType)
                        {
                            objExpr = new CodeDirectionExpression(FieldDirection.Out, objExpr);
                        }
                        CodeExpression setExpr = new CodeDelegateInvokeExpression(setterExpr, objExpr, readCall);
                        stmts = new CodeStatement[] { new CodeExpressionStatement(setExpr) };
                    }
                }
            }

            if (!type.IsValueType &&
                (finfo != null || StaticConfig.AllowNullArrayElements) &&
                (finfo == null || AttributeSystem.FieldCanBeNull(finfo)))
//.........这里部分代码省略.........

        protected override void GenerateArrayIndexerExpression(CodeArrayIndexerExpression e) {
            GenerateExpression(e.TargetObject);
            Output.Write("[");
            bool first = true;
            foreach(CodeExpression exp in e.Indices) {            
                if (first) {
                    first = false;
                }
                else {
                    Output.Write(", ");
                }
                GenerateExpression(exp);
            }
            Output.Write("]");

        }