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 GenerateArrayIndexerExpression (CodeArrayIndexerExpression expression)
{
TextWriter output = Output;
GenerateExpression (expression.TargetObject);
output.Write ("(");
OutputExpressionList (expression.Indices);
output.Write (')');
}
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);
}
public bool ValidateCodeArrayIndexerExpression (CodeArrayIndexerExpression exp) {
bool result = true;
PushLocation (exp);
if (exp.Indices != null && exp.Indices.Count > 0) {
if (exp.Indices.Count > 1) {
PushError ("Can only have one index.");
result = false;
} else {
if (!IsSimpleTarget (exp.Indices[0]))
result = false;
}
}
if (!IsSimpleTarget (exp.TargetObject))
result = false;
PopLocation();
return result;
}
protected abstract void GenerateArrayIndexerExpression (CodeArrayIndexerExpression e);
public override void AddBind(IShaderDom shader, Action<CodeStatement, string> add)
{
bool requiresUnused = false;
//bind the semantics bound attributes
foreach (SemanticMapping mapping in semanticMapping)
{
//eg:
//state.SetWorldMatrix(this.vreg.Matrix4Transpose(8), ref this.v_8);
string method = string.Format("Set{0}{1}", mapping.Type.Mapping, mapping.Type.Type.Name);
if (mapping.Type.IsArray)
method += "Array";
//for each register set, see if it uses this mapping
int changeRefIndex = 0;
foreach (KeyValuePair<AsmListing, CodeExpression> listing in listingRegisters)
{
Register sreg;
RegisterSet registers = listing.Key.RegisterSet;
CodeExpression registersRef = listing.Value;
if (registers.TryGetRegister(mapping.Register.Name, out sreg))
{
//it does.. so the constants need setting..
//changed |= state.SetWorldMatrix(ref this.vreg[8], ref this.vreg[9], ref this.vreg[9], ref unused, ref this.v_8);
CodeExpression changeRef = Ref(mapping.ChangeRefs[changeRefIndex]);
CodeExpression getRegisterX = //this.vreg[8]
new CodeArrayIndexerExpression(registersRef, new CodePrimitiveExpression(sreg.Index));
//invoke
CodeExpression invokeSet = null;
if (mapping.Type.IsArray)
{
invokeSet = new CodeMethodInvokeExpression(shader.ShaderSystemRef, method, registersRef, new CodePrimitiveExpression(sreg.Index), new CodePrimitiveExpression(sreg.Size), changeRef);
}
else
{
if (mapping.Type.Type == typeof(Matrix))
{
int rank = (int)mapping.Register.Rank;
if (rank != 4 && requiresUnused == false) // an 'unused' variable is required
{
//add a temporary. A matrix being set may not use all 4 rows. Need a temp write target
add(new CodeVariableDeclarationStatement(typeof(Vector4), "unused", new CodeObjectCreateExpression(typeof(Vector4))), null);
requiresUnused = true;
}
//setter takes in X,Y,Z,W registers
CodeExpression unused = new CodeVariableReferenceExpression("unused");
CodeExpression Y = rank >= 2 ? new CodeArrayIndexerExpression(registersRef, new CodePrimitiveExpression(sreg.Index + 1)) : unused;
CodeExpression Z = rank >= 3 ? new CodeArrayIndexerExpression(registersRef, new CodePrimitiveExpression(sreg.Index + 2)) : unused;
CodeExpression W = rank >= 4 ? new CodeArrayIndexerExpression(registersRef, new CodePrimitiveExpression(sreg.Index + 3)) : unused;
invokeSet = new CodeMethodInvokeExpression(shader.ShaderSystemRef, method, Ref(getRegisterX), Ref(Y), Ref(Z), Ref(W), changeRef);
}
else
invokeSet = new CodeMethodInvokeExpression(shader.ShaderSystemRef, method, Ref(getRegisterX), changeRef);
}
//update the change value appropriately
CodeExpression changeValue = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), (registersRef as CodeFieldReferenceExpression).FieldName + "_change");
//change |= ...;
CodeStatement assign = new CodeAssignStatement(changeValue,
new CodeBinaryOperatorExpression(changeValue, CodeBinaryOperatorType.BitwiseOr,
invokeSet));
if (ExtractAssignmentForExtenionBlock(assign, shader, listing.Key))
continue;
add(assign, changeRefIndex != 0 ? null : string.Format("Set the value for attribute '{0}'", mapping.Register.Name));
changeRefIndex++;
}
}
}
//bind the shader globals
foreach (GlobalAttribute global in globals)
{
string registerTypeName = global.Type.Name;
if (global.Type == typeof(Matrix))
{
registerTypeName += (int)global.Register.Rank;
}
int changeRefIndex = 0;
foreach (KeyValuePair<AsmListing, CodeExpression> listing in listingRegisters)
{
Register sreg;
RegisterSet registers = listing.Key.RegisterSet;
CodeExpression registersRef = listing.Value;
bool isMatrix = global.Type == typeof(Matrix);
if (registers.TryGetRegister(global.Register.Name, out sreg))
{
//special case the booleans, as they have different logic to set globally.
if (sreg.Category == RegisterCategory.Boolean)
{
if (global.Register.ArraySize != -1)
throw new CompileException("'GLOBAL' Boolean Arrays are not supported");
//this is a bit of a hack :-/
//need to figure out if this is a vertex or pixel boolean constant.
if (listing.Key == asm.VertexShader)
{
CodeExpression setValue = new CodeMethodInvokeExpression(shader.ShaderSystemRef, "SetGlobalBool", shader.VertexShaderBooleanRegistersRef, new CodePrimitiveExpression(sreg.Index), global.GlobalIdRef);
//update the change flag
CodeExpression invoke = new CodeBinaryOperatorExpression(
shader.VertexShaderBooleanRegistersChangedRef, CodeBinaryOperatorType.BitwiseOr,
setValue);
add(shader.ETS(invoke),
string.Format("Set the value for global 'bool {0}'", global.Register.Name));
}
if (listing.Key == asm.PixelShader)
{
CodeExpression setValue = new CodeMethodInvokeExpression(shader.ShaderSystemRef, "SetGlobalBool", shader.PixelShaderBooleanRegistersRef, new CodePrimitiveExpression(sreg.Index), global.GlobalIdRef);
//update the change flag
CodeExpression invoke = new CodeBinaryOperatorExpression(
shader.PixelShaderBooleanRegistersChangedRef, CodeBinaryOperatorType.BitwiseOr,
setValue);
add(shader.ETS(invoke),
string.Format("Set the value for global 'bool {0}'", global.Register.Name));
}
}
else
{
//eg:
//changed |= state.SetGlobalMatrix3(ref this.vreg[8], ref this.vreg[9], ref this.vreg[10], ShadowShaderBlend.g_id0, ref this.g_0);
CodeExpression getRegisterX = //this.vreg[8]
new CodeArrayIndexerExpression(registersRef, new CodePrimitiveExpression(sreg.Index));
string methodName = "SetGlobal" + global.Type.Name;
int rank = (int)global.Register.Rank;
if (isMatrix)
methodName += rank;
//eg, SetGlobalMatrix3
CodeExpression changeRef = Ref(global.ChangeRefs[changeRefIndex]);
CodeExpression invokeSet;
//logic changes for arrays
if (global.Register.ArraySize != -1)
{
//SetGlobalMatrix3 for Arrays takes in the array itself as the first arg.
invokeSet =
new CodeMethodInvokeExpression(shader.ShaderSystemRef, methodName, registersRef, new CodePrimitiveExpression(global.Register.Index), new CodePrimitiveExpression(global.Register.Size + global.Register.Index), global.GlobalIdRef, changeRef);
//state.SetGlobal(this.ga0, ShadowShaderBlend.g_id0, ref this.g_0);
}
else
{
//SetGlobalMatrix3 for non-arays takes a variable number of arguements
if (isMatrix)
{
List<CodeExpression> args = new List<CodeExpression>();
//add X
args.Add(Ref(getRegisterX));
if (rank >= 2) args.Add(Ref(new CodeArrayIndexerExpression(registersRef, new CodePrimitiveExpression(sreg.Index + 1))));
if (rank >= 3) args.Add(Ref(new CodeArrayIndexerExpression(registersRef, new CodePrimitiveExpression(sreg.Index + 2))));
if (rank >= 4) args.Add(Ref(new CodeArrayIndexerExpression(registersRef, new CodePrimitiveExpression(sreg.Index + 3))));
args.Add(global.GlobalIdRef);
args.Add(changeRef);
invokeSet =
new CodeMethodInvokeExpression(shader.ShaderSystemRef, methodName, args.ToArray());
}
else
invokeSet =
new CodeMethodInvokeExpression(shader.ShaderSystemRef, methodName, Ref(getRegisterX), global.GlobalIdRef, changeRef);
}
//update the change value appropriately
CodeExpression changeValue = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), (registersRef as CodeFieldReferenceExpression).FieldName + "_change");
//change |= ...;
CodeStatement assign = new CodeAssignStatement(changeValue,
new CodeBinaryOperatorExpression(changeValue, CodeBinaryOperatorType.BitwiseOr,
invokeSet));
if (ExtractAssignmentForExtenionBlock(assign, shader, listing.Key))
continue;
add(assign, changeRefIndex != 0 ? null : string.Format("Set the value for global '{0}'", global.Register.Name));
changeRefIndex++;
}
}
}
}
}
protected override void GenerateArrayIndexerExpression(CodeArrayIndexerExpression e)
{
Output.Write("[CodeArrayIndexerExpression: {0}]", e.ToString());
}
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));
CodeStatement assign = new CodeAssignStatement(arrayIndex, new CodePropertySetValueReferenceExpression());
CodeStatement change = new CodeAssignStatement(shader.VertexShaderBooleanRegistersChangedRef, new CodePrimitiveExpression(true));
CodeStatement condition = new CodeConditionStatement(
new CodeBinaryOperatorExpression(arrayIndex, CodeBinaryOperatorType.IdentityInequality, new CodePropertySetValueReferenceExpression()),
new CodeStatement[] { assign, change });
methodStatements.Add(condition);
}
}
}
}
else
{
//some array set methods require temporary values, but should only be created once.
bool tempValuesCreated = false;
foreach (KeyValuePair<AsmListing, CodeExpression> listing in listingRegisters)
{
RegisterSet registers = listing.Key.RegisterSet;
CodeExpression registersRef = listing.Value;
if (registers.TryGetRegister(name, out sreg))
{
//Assign the register array data
AssignRegister(dataType, sreg, reg, listing.Value, valueRef, methodStatements, ref tempValuesCreated);
//set changed
CodeExpression changeValue = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), (registersRef as CodeFieldReferenceExpression).FieldName + "_change");
methodStatements.Add(new CodeAssignStatement(changeValue, new CodePrimitiveExpression(true)));
}
}
}
string upperName = Common.ToUpper(name);
//there is always a setable property
CodeMemberProperty property = new CodeMemberProperty();
property.Name = upperName;
property.Type = param.Type;
property.Attributes = MemberAttributes.Final | MemberAttributes.Public;
property.HasSet = true;
property.HasGet = false;
//there isn't always a set method
CodeMemberMethod method = null;
CodeStatement assignAttribute = null;
if (hasSetMethod || reg.ArraySize != -1)
{
//create the method to set the value
string methodName = "Set" + upperName;
method = new CodeMemberMethod();
method.Name = methodName;
method.Attributes = MemberAttributes.Final | MemberAttributes.Public;
method.Parameters.Add(param);
method.Parameters.AddRange(additionalParams.ToArray());
method.Statements.AddRange(methodStatements);
//create a property that calls the Set method
//is not an array
CodeMethodInvokeExpression invokeSetter =
new CodeMethodInvokeExpression(
shader.Instance, method.Name,
new CodeDirectionExpression(reg.ArraySize == -1 ? FieldDirection.Ref : FieldDirection.In, new CodePropertySetValueReferenceExpression()));
if (reg.ArraySize != -1)
{
//add method ops (readIndex, writeIndex, count)
invokeSetter.Parameters.Add(new CodePrimitiveExpression(0));
invokeSetter.Parameters.Add(new CodePrimitiveExpression(0));
invokeSetter.Parameters.Add(new CodeCastExpression(typeof(uint), new CodePropertyReferenceExpression(valueRef, "Length")));
}
property.SetStatements.Add(invokeSetter);
//call the method as well for attribute assign
CodeMethodInvokeExpression assignSetter =
new CodeMethodInvokeExpression(
shader.Instance, method.Name,
new CodeDirectionExpression(param.Direction, shader.AttributeAssignValue));
if (reg.ArraySize != -1)
{
//add method ops (readIndex, writeIndex, count)
assignSetter.Parameters.Add(new CodePrimitiveExpression(0));
assignSetter.Parameters.Add(new CodePrimitiveExpression(0));
assignSetter.Parameters.Add(new CodeCastExpression(typeof(uint), new CodePropertyReferenceExpression(valueRef, "Length")));
}
assignAttribute = shader.ETS(assignSetter);
}
else
{
//create a property to directly set the value
property.SetStatements.AddRange(methodStatements);
//attribute assign sets the property
assignAttribute = new CodeAssignStatement(
new CodePropertyReferenceExpression(shader.Instance, property.Name),
shader.AttributeAssignValue);
}
if (reg.ArraySize > 0)
{
if (method != null)
add(method, string.Format("Set the shader array value '{0} {1}[{2}]'", reg.Type, reg.Name, reg.ArraySize));
add(property, string.Format("Set and copy the array data for the shader value '{0} {1}[{2}]'", reg.Type, reg.Name, reg.ArraySize));
}
else
{
if (method != null)
add(method, string.Format("Set the shader value '{0} {1}'", reg.Type, reg.Name));
add(property, string.Format("Assign the shader value '{0} {1}'", reg.Type, reg.Name));
}
//create the attribute assignment value statement.
List<CodeStatement> assignList;
if (!attributeAssignment.TryGetValue(arrayOrSingleType, out assignList))
{
assignList = new List<CodeStatement>();
attributeAssignment.Add(arrayOrSingleType, assignList);
}
//create the statement...
CodeExpression assignIdsMatch =
new CodeBinaryOperatorExpression(shader.AttributeAssignId, CodeBinaryOperatorType.IdentityEquality, assignmentField);
CodeConditionStatement performAssign =
new CodeConditionStatement(assignIdsMatch,
assignAttribute, //call the assignment code
new CodeMethodReturnStatement(new CodePrimitiveExpression(true))); //return true, set correctly.
assignList.Add(performAssign);
}
private CodeBinaryOperatorExpression VarAssign(CodeArrayIndexerExpression name, CodeExpression value)
{
return new CodeBinaryOperatorExpression(name, CodeBinaryOperatorType.Assign, value);
}
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("]");
}
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;
}
private void ValidateArrayIndexerExpression(CodeArrayIndexerExpression e) {
ValidateExpression(e.TargetObject);
foreach(CodeExpression exp in e.Indices) {
ValidateExpression(exp);
}
}
private static string BuildCodeExtractingModelType(CodeDomProvider provider)
{
var getType = new CodeMethodInvokeExpression
(
new CodeThisReferenceExpression(),
"GetType"
);
var baseType = new CodeFieldReferenceExpression
(
getType,
"BaseType"
);
var getFirstGenericArgument = new CodeArrayIndexerExpression
(
new CodeMethodInvokeExpression
(
baseType,
"GetGenericArguments"
),
new CodePrimitiveExpression(0)
);
var fullName = new CodeFieldReferenceExpression
(
getFirstGenericArgument,
"FullName"
);
string modelTypeCode;
using (var writer = new StringWriter())
{
provider.GenerateCodeFromExpression(fullName, writer, new CodeGeneratorOptions());
modelTypeCode = writer.ToString();
}
return modelTypeCode;
}
private CodeStatement BuildReadStringStatement(MemberType memberType, string classRefName, CodeMemberField memberField)
{
string tempListName = memberField.Name + "_List";
// If called by the Native contract serializer method classRefName
// will be null indicating this is a local field type
CodeTypeReferenceExpression classRefType = null;
if (classRefName != null || classRefName == "")
classRefType = new CodeTypeReferenceExpression(classRefName);
// Build left code assignment value
CodeFieldReferenceExpression leftStatement = new CodeFieldReferenceExpression(
classRefType,
memberField.Name + (memberField.Type.ArrayElementType == null ? "" : "[i]"));
// Build right code assignment value
CodeExpression readExpression;
if (memberField.Type.ArrayElementType != null)
{
readExpression = new CodeArrayIndexerExpression(
new CodeVariableReferenceExpression(tempListName),
new CodeVariableReferenceExpression("i"));
}
else if (memberType == MemberType.Field)
readExpression = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression("reader"),
"ReadString");
else
readExpression = new CodeFieldReferenceExpression(
new CodeTypeReferenceExpression("reader"),
"Value");
CodeStatement assignStatement;
// if the field is a string type just read it
if (memberField.Type.BaseType == "System.String")
{
assignStatement = new CodeAssignStatement(leftStatement, readExpression);
}
// Else build convert statement
else
{
CodeExpression convertExpression = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression("XmlConvert"),
CodeGenUtils.GetConvertMethod(memberField.Type.BaseType),
new CodeExpression[] { readExpression });
assignStatement = new CodeAssignStatement(leftStatement, convertExpression);
}
return assignStatement;
}
protected override void GenerateArrayIndexerExpression (CodeArrayIndexerExpression e)
{
}
private CodeStmtPair MakeWriteFieldStatements(Type type,
CodeExpression objExpr,
FieldInfo finfo,
CodeVariableReferenceExpression[] indexExprs)
{
CodeExpression writerExpr = new CodeArgumentReferenceExpression("writer");
CodeExpression fieldExpr;
if (finfo == null)
{
fieldExpr = new CodeArrayIndexerExpression(objExpr, indexExprs);
}
else
{
string fieldName = TypeSystem.FieldName(finfo.Name);
if (finfo.IsPublic ||
(TypeSystem.IsBackingField(finfo.Name) &&
finfo.DeclaringType.GetProperty(fieldName, FieldFlags).GetGetMethod() != null))
{
fieldExpr = new CodeFieldReferenceExpression(objExpr, fieldName);
}
else
{
CodeExpression getterExpr = new CodeVariableReferenceExpression(
ExtensionClassName + "." + this.GetterFieldName(finfo));
if (finfo.DeclaringType.IsValueType)
{
objExpr = new CodeDirectionExpression(FieldDirection.Out, objExpr);
}
fieldExpr = new CodeDelegateInvokeExpression(getterExpr, objExpr);
}
}
CodeExpression writeCall;
if (GetBuiltinReaderName(type) == null)
{
// for non-builtin types
string serializerName = GetStaticSerializerName(type);
CodeVariableReferenceExpression serializerExpr = new CodeVariableReferenceExpression(serializerName);
writeCall = new CodeMethodInvokeExpression(serializerExpr, "Write", writerExpr, fieldExpr);
}
else
{
// for builtin types
writeCall = new CodeMethodInvokeExpression(writerExpr, "Write", fieldExpr);
}
CodeStatement stmt1 = new CodeExpressionStatement(writeCall);
if (type.IsValueType)
{
return new CodeStmtPair(null, new CodeStatement[] { stmt1 });
}
else if (finfo == null)
{
if (StaticConfig.AllowNullArrayElements)
{
string bvIndexString = indexExprs[0].VariableName;
for (int i = 1; i < indexExprs.Length; i++)
{
bvIndexString += "*" + indexExprs[i].VariableName;
}
CodeExpression bvIndex = new CodeSnippetExpression(bvIndexString);
CodeExpression nullExpr = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression("Object"),
"ReferenceEquals",
fieldExpr,
NullExpr);
CodeExpression bvExpr = new CodeArgumentReferenceExpression("bv");
CodeStatement stmt0 = new CodeExpressionStatement(
new CodeMethodInvokeExpression(bvExpr, "Set", bvIndex));
stmt0 = new CodeConditionStatement(nullExpr, stmt0);
CodeExpression notNullExpr = new CodeBinaryOperatorExpression(
new CodeIndexerExpression(bvExpr, bvIndex),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(false));
stmt1 = new CodeConditionStatement(notNullExpr, stmt1);
return new CodeStmtPair(new CodeStatement[] { stmt0 }, new CodeStatement[] { stmt1 });
}
else
{
return new CodeStmtPair(null, new CodeStatement[] { stmt1 });
}
}
else
{
CodeExpression nullExpr = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression("Object"),
"ReferenceEquals",
fieldExpr,
NullExpr);
if (AttributeSystem.FieldCanBeNull(finfo))
{
CodeExpression bvExpr = new CodeArgumentReferenceExpression("bv");
CodeStatement stmt0 = new CodeExpressionStatement(
new CodeMethodInvokeExpression(bvExpr, "Set", indexExprs[0]));
stmt0 = new CodeConditionStatement(nullExpr, stmt0);
CodeExpression notNullExpr = new CodeBinaryOperatorExpression(
new CodeIndexerExpression(bvExpr, indexExprs[0]),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(false));
stmt1 = new CodeConditionStatement(notNullExpr, stmt1);
return new CodeStmtPair(new CodeStatement[] { stmt0 }, new CodeStatement[] { stmt1 });
}
else
{
// YY: For now we always check null
string msg = "Field " + finfo.DeclaringType.Name + "." + finfo.Name + " is null.";
CodeExpression msgExpr = new CodePrimitiveExpression(msg);
CodeExpression throwExpr = new CodeObjectCreateExpression(typeof(ArgumentNullException), msgExpr);
CodeStatement stmt0 = new CodeConditionStatement(nullExpr, new CodeThrowExceptionStatement(throwExpr));
return new CodeStmtPair(null, new CodeStatement[] { stmt0, stmt1 });
}
}
}
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);
}
public CodeExpression ParseBaseExpression()
{
if (TokenType == CDILToken.Integer)
{
CodePrimitiveExpression expr = new CodePrimitiveExpression(TokenValue);
GetNextToken();
return expr;
}
if (TokenType == CDILToken.String)
{
CodePrimitiveExpression expr = new CodePrimitiveExpression(TokenValue);
GetNextToken();
return expr;
}
if (IsKeyword("base"))
{
GetNextToken();
return new CodeBaseReferenceExpression();
}
if (IsKeyword("null"))
{
GetNextToken();
return new CodePrimitiveExpression(null);
}
if (IsKeyword("false"))
{
GetNextToken();
return new CodePrimitiveExpression(false);
}
if (IsKeyword("true"))
{
GetNextToken();
return new CodePrimitiveExpression(true);
}
if (IsKeyword("this"))
{
GetNextToken();
return new CodeThisReferenceExpression();
}
if (IsKeyword("setvalue"))
{
GetNextToken();
return new CodePropertySetValueReferenceExpression();
}
if (IsKeyword("arg"))
{
GetNextToken();
Expect(CDILToken.LeftParen);
string name = EatKeyword();
Expect(CDILToken.RightParen);
return new CodeArgumentReferenceExpression(name);
}
if (IsKeyword("delegatecall"))
{
CodeDelegateInvokeExpression retval = new CodeDelegateInvokeExpression();
GetNextToken();
Expect(CDILToken.LeftParen);
retval.TargetObject = ParseExpression();
Expect(CDILToken.RightParen);
Expect(CDILToken.LeftParen);
while (TokenType != CDILToken.RightParen && TokenType != CDILToken.EOF)
{
CodeExpression expr = ParseExpression();
retval.Parameters.Add(expr);
if (TokenType == CDILToken.Comma)
{
GetNextToken();
}
}
Expect(CDILToken.RightParen);
return retval;
}
if (IsKeyword("typeref"))
{
GetNextToken();
Expect(CDILToken.LeftParen);
CodeTypeReference typeRef = ParseType();
Expect(CDILToken.RightParen);
return new CodeTypeReferenceExpression(typeRef);
}
if (IsKeyword("typeof"))
{
GetNextToken();
Expect(CDILToken.LeftParen);
CodeTypeReference typeRef = ParseType();
Expect(CDILToken.RightParen);
return new CodeTypeOfExpression(typeRef);
}
if (IsKeyword("add"))
{
CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression();
cboe.Operator = CodeBinaryOperatorType.Add;
GetNextToken();
Expect(CDILToken.LeftParen);
cboe.Left = ParseExpression();
Expect(CDILToken.Comma);
cboe.Right = ParseExpression();
Expect(CDILToken.RightParen);
return cboe;
}
if (IsKeyword("equal"))
{
CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression();
cboe.Operator = CodeBinaryOperatorType.ValueEquality;
GetNextToken();
Expect(CDILToken.LeftParen);
cboe.Left = ParseExpression();
Expect(CDILToken.Comma);
cboe.Right = ParseExpression();
Expect(CDILToken.RightParen);
return cboe;
}
if (IsKeyword("refequal"))
{
CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression();
cboe.Operator = CodeBinaryOperatorType.IdentityEquality;
GetNextToken();
Expect(CDILToken.LeftParen);
cboe.Left = ParseExpression();
Expect(CDILToken.Comma);
cboe.Right = ParseExpression();
Expect(CDILToken.RightParen);
return cboe;
}
if (IsKeyword("refnotequal"))
{
CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression();
cboe.Operator = CodeBinaryOperatorType.IdentityInequality;
GetNextToken();
Expect(CDILToken.LeftParen);
cboe.Left = ParseExpression();
Expect(CDILToken.Comma);
cboe.Right = ParseExpression();
Expect(CDILToken.RightParen);
return cboe;
}
if (IsKeyword("arrayitem"))
{
GetNextToken();
Expect(CDILToken.LeftParen);
CodeArrayIndexerExpression caie = new CodeArrayIndexerExpression();
caie.TargetObject = ParseExpression();
while (TokenType == CDILToken.Comma)
{
Expect(CDILToken.Comma);
caie.Indices.Add(ParseExpression());
}
Expect(CDILToken.RightParen);
return caie;
}
if (IsKeyword("index"))
{
GetNextToken();
Expect(CDILToken.LeftParen);
CodeIndexerExpression cie = new CodeIndexerExpression();
cie.TargetObject = ParseExpression();
while (TokenType == CDILToken.Comma)
{
Expect(CDILToken.Comma);
cie.Indices.Add(ParseExpression());
}
Expect(CDILToken.RightParen);
return cie;
}
if (IsKeyword("var"))
{
GetNextToken();
Expect(CDILToken.LeftParen);
string name = EatKeyword();
Expect(CDILToken.RightParen);
return new CodeVariableReferenceExpression(name);
}
if (IsKeyword("defaultscope"))
{
GetNextToken();
return null;
}
if (IsKeyword("ref"))
{
GetNextToken();
Expect(CDILToken.LeftParen);
CodeExpression expr = ParseExpression();
Expect(CDILToken.RightParen);
return new CodeDirectionExpression(FieldDirection.Ref, expr);
}
if (IsKeyword("out"))
{
GetNextToken();
Expect(CDILToken.LeftParen);
CodeExpression expr = ParseExpression();
Expect(CDILToken.RightParen);
return new CodeDirectionExpression(FieldDirection.Out, expr);
}
if (IsKeyword("cast"))
{
GetNextToken();
Expect(CDILToken.LeftParen);
CodeTypeReference type = ParseType();
Expect(CDILToken.Comma);
CodeExpression expr = ParseExpression();
Expect(CDILToken.RightParen);
return new CodeCastExpression(type, expr);
}
if (IsKeyword("new"))
{
GetNextToken();
CodeTypeReference type = ParseType();
CodeObjectCreateExpression retval = new CodeObjectCreateExpression(type);
Expect(CDILToken.LeftParen);
while (TokenType != CDILToken.RightParen && TokenType != CDILToken.EOF)
{
CodeExpression expr = ParseExpression();
retval.Parameters.Add(expr);
if (TokenType == CDILToken.Comma)
{
GetNextToken();
}
}
Expect(CDILToken.RightParen);
return retval;
}
if (IsKeyword("newarray"))
{
GetNextToken();
Expect(CDILToken.LeftParen);
CodeArrayCreateExpression retval = new CodeArrayCreateExpression();
retval.CreateType = ParseType();
Expect(CDILToken.Comma);
retval.SizeExpression = ParseExpression();
Expect(CDILToken.RightParen);
return retval;
}
throw BuildException("Unexpected token '" + TokenType + "'");
}
protected override void GenerateArrayIndexerExpression(CodeArrayIndexerExpression e)
{
base.GenerateExpression(e.TargetObject);
base.Output.Write("(");
bool flag = true;
foreach (CodeExpression expression in e.Indices)
{
if (flag)
{
flag = false;
}
else
{
base.Output.Write(", ");
}
base.GenerateExpression(expression);
}
base.Output.Write(")");
}
private void GenerateArrayIndexerExpression(CodeArrayIndexerExpression e)
{
this.GenerateExpression(e.TargetObject);
this.Output.Write("[");
bool flag1 = true;
foreach (CodeExpression expression1 in e.Indices)
{
if (flag1)
{
flag1 = false;
}
else
{
this.Output.Write(", ");
}
this.GenerateExpression(expression1);
}
this.Output.Write("]");
}
protected override void GenerateArrayIndexerExpression(System.CodeDom.CodeArrayIndexerExpression e)
{
throw new Exception("The method or operation is not implemented.");
}
public void Visit (CodeArrayIndexerExpression o)
{
g.GenerateArrayIndexerExpression (o);
}
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)))
{
CodeExpression bvIndex = indexExprs[0];
if (finfo == null)
{
string bvIndexString = indexExprs[0].VariableName;
for (int i = 1; i < indexExprs.Length; i++)
{
bvIndexString += "*" + indexExprs[i].VariableName;
}
bvIndex = new CodeSnippetExpression(bvIndexString);
}
CodeExpression bvExpr = new CodeArgumentReferenceExpression("bv");
CodeExpression ifExpr = new CodeBinaryOperatorExpression(
new CodeIndexerExpression(bvExpr, bvIndex),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(false));
CodeStatement stmt = new CodeConditionStatement(ifExpr, stmts);
stmts = new CodeStatement[] { stmt };
}
return stmts;
}
/// <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);
}