public CodeExpression GetReaderExpression(CodeExpression reader)
{
CodeExpression ret = null;
IMemberReaderWriter entry = BaseEntry as IMemberReaderWriter;
if (_reference.IsValid())
{
string name = _isByteLength ? "SAB" : "SA";
List <CodeExpression> parameters = new List <CodeExpression>();
parameters.Add(reader);
EvalExpression lengthRead = LengthReadExpression;
parameters.Add(CodeGen.GetField(CodeGen.GetThis(), _reference.GetNames()));
if (lengthRead.IsValid)
{
parameters.Add(CodeGen.GetPrimitive(lengthRead.Expression));
}
else
{
parameters.Add(CodeGen.GetPrimitive(_adjustment));
}
ret = CodeGen.CallMethod(CodeGen.GetThis(), name, BaseEntry.GetTypeReference(), parameters.ToArray());
}
else
{
ret = CodeGen.CreateArray(GetTypeReference(), 0);
}
return(ret);
}
public CodeExpression GetReaderExpression(CodeExpression reader)
{
CodeExpression returnExpression;
// Might as well return an empty string
if (!_reference.IsValid())
{
returnExpression = CodeGen.GetPrimitive(String.Empty);
}
else
{
string name = _isByteLength ? "FixBS" : "FixS";
List <CodeExpression> parameters = new List <CodeExpression>();
parameters.Add(reader);
parameters.Add(CodeGen.GetEnum(StringEncoding));
parameters.Add(CodeGen.GetField(CodeGen.GetThis(), _reference.GetNames()));
EvalExpression lengthRead = LengthReadExpression;
if (lengthRead.IsValid)
{
parameters.Add(CodeGen.GetPrimitive(lengthRead.Expression));
}
else
{
parameters.Add(CodeGen.GetPrimitive(_adjustment));
}
returnExpression = CodeGen.CallMethod(CodeGen.GetThis(), name, parameters.ToArray());
}
return(returnExpression);
}
public override CodeExpression GetReaderExpression(CodeExpression reader)
{
CodeExpression refExpr;
if (_magicParser)
{
List <CodeExpression> args = new List <CodeExpression>();
args.Add(reader);
foreach (SequenceChoice choice in _choices)
{
if (choice.SequenceType != null)
{
args.Add(CodeGen.GetTypeOf(new CodeTypeReference(choice.SequenceType.Name)));
}
}
if (DefaultType != null)
{
args.Add(CodeGen.GetTypeOf(new CodeTypeReference(DefaultType.Name)));
}
return(CodeGen.CallMethod(CodeGen.GetThis(), "RSC", args.ToArray()));
}
else
{
if (_reference.IsValid())
{
refExpr = CodeGen.GetField(CodeGen.GetThis(), _reference.GetNames());
}
else
{
refExpr = CodeGen.GetPrimitive(null);
}
List <CodeExpression> args = new List <CodeExpression>();
args.Add(reader);
args.Add(refExpr);
foreach (SequenceChoice choice in _choices)
{
if ((choice.BooleanExpression.IsValid) && (choice.SequenceType != null))
{
args.Add(CodeGen.GetPrimitive(choice.BooleanExpression.Expression));
args.Add(CodeGen.GetTypeOf(new CodeTypeReference(choice.SequenceType.Name)));
}
}
if (DefaultType != null)
{
args.Add(CodeGen.GetPrimitive("true"));
args.Add(CodeGen.GetTypeOf(new CodeTypeReference(DefaultType.Name)));
}
return(CodeGen.CallMethod(CodeGen.GetThis(), "RSC", args.ToArray()));
}
}
public System.CodeDom.CodeExpression GetReaderExpression(CodeExpression reader)
{
if (ReadToEnd)
{
return(_baseWriter.GetReaderExpression(CodeGen.CallMethod(CodeGen.GetThis(), "GBR", reader)));
}
else
{
return(_baseWriter.GetReaderExpression(CodeGen.CallMethod(CodeGen.GetThis(), "GBR", reader, CodeGen.GetPrimitive(_sizeExpression))));
}
}
private CodeExpression GetLength()
{
CodeExpression ret = CodeGen.GetCast(typeof(int), CodeGen.GetField(CodeGen.GetThis(), _reference.GetNames()));
if (_adjustment != 0)
{
ret = CodeGen.GetOperator(ret, CodeBinaryOperatorType.Add, CodeGen.GetPrimitive(_adjustment));
}
return(ret);
}
internal static CodeExpression GetLength(int length, EvalExpression lengthExpression)
{
if (lengthExpression.IsValid)
{
return(CodeGen.CallMethod(CodeGen.GetThis(), "CL", CodeGen.GetPrimitive(length), CodeGen.GetPrimitive(lengthExpression.Expression)));
}
else
{
return(CodeGen.GetPrimitive(length));
}
}
public CodeExpression GetReaderExpression(CodeExpression reader)
{
CodeExpression ret = CodeGen.CallMethod(reader, "ReadBytes", CodeGen.GetPrimitive(_bytes.Length));
if (_validate)
{
ret = CodeGen.CallMethod(CodeGen.GetThis(), "CMP", ret, CodeGen.CreateByteArray(_bytes));
}
return(ret);
}
public CodeExpression GetReaderExpression(CodeExpression reader)
{
if (_isByteLength)
{
return(CodeGen.CallMethod(CodeGen.GetThis(), "FixBPA", BaseEntry.GetTypeReference(),
reader, CodeGen.GetLength(Length), _intEntry.GetEndian()));
}
else
{
return(CodeGen.CallMethod(CodeGen.GetThis(), "FixPA", BaseEntry.GetTypeReference(),
reader, CodeGen.GetLength(Length), _intEntry.GetEndian()));
}
}
public override System.CodeDom.CodeMemberMethod GetPreSerializeMethod()
{
CodeMemberMethod method = base.GetPreSerializeMethod();
if (_reference.IsValid())
{
CodeExpression right = CodeGen.GetProperty(CodeGen.GetThisField(Name), "Length");
if (_isByteLength)
{
PrimitiveMemberEntry entry = BaseEntry as PrimitiveMemberEntry;
BitFieldMemberEntry bitField = entry as BitFieldMemberEntry;
if (bitField != null)
{
right = CodeGen.CallMethod(CodeGen.GetThis(), "CLBits", right, CodeGen.GetPrimitive(bitField.Bits));
}
else
{
right = CodeGen.GetOperator(CodeGen.GetPrimitive(entry.GetSize()), CodeBinaryOperatorType.Multiply, right);
}
}
EvalExpression lengthWrite = LengthWriteExpression;
if (lengthWrite.IsValid)
{
right = lengthWrite.GetEvalExpression(right);
}
else if (_adjustment != 0)
{
right = CodeGen.GetOperator(right, CodeBinaryOperatorType.Subtract, CodeGen.GetPrimitive(_adjustment));
}
if (_reference.GetTargetMember().BaseType is StringParserType)
{
right = CodeGen.CallMethod(right, "ToString");
}
else
{
right = CodeGen.GetCast(_reference.GetTargetMember().GetTypeReference(), right);
}
method.Statements.Add(CodeGen.GetAssign(CodeGen.GetField(CodeGen.GetThis(), _reference.GetNames()), right));
}
return(method);
}
public CodeExpression GetReaderExpression(CodeExpression reader)
{
CodeExpression ret;
if (!String.IsNullOrEmpty(_termString))
{
ret = CodeGen.CallMethod(CodeGen.GetThis(), "RTS",
reader, CodeGen.GetEnum(StringEncoding), CodeGen.GetPrimitive(GeneralUtils.DecodeEscapedString(_termString)), CodeGen.GetPrimitive(!_notrequired));
}
else
{
ret = CodeGen.CallMethod(CodeGen.GetThis(), "RTS",
reader, CodeGen.GetEnum(StringEncoding), CodeGen.GetPrimitive(_termChar), CodeGen.GetPrimitive(!_notrequired));
}
return(ret);
}
public CodeExpression GetReaderExpression(CodeExpression reader)
{
CodeExpression ret;
PrimitiveMemberEntry entry = BaseEntry as PrimitiveMemberEntry;
if (_reference.IsValid())
{
CodeExpression lengthExpression;
EvalExpression lengthRead = LengthReadExpression;
if (lengthRead.IsValid)
{
lengthExpression = CodeGen.CallMethod(CodeGen.GetThis(), "CL", CodeGen.GetField(CodeGen.GetThis(), _reference.GetNames()), CodeGen.GetPrimitive(lengthRead.Expression));
}
else
{
Type refType = ((BuiltinParserType)_reference.GetTargetMember().BaseType).DataType;
lengthExpression = CodeGen.GetField(CodeGen.GetThis(), _reference.GetNames());
if (refType != typeof(int))
{
lengthExpression = CodeGen.CallMethod(CodeGen.GetThis(), "CL", lengthExpression);
}
if (_adjustment != 0)
{
lengthExpression = CodeGen.GetOperator(lengthExpression, CodeBinaryOperatorType.Add, CodeGen.GetPrimitive(_adjustment));
}
}
if (_isByteLength)
{
ret = CodeGen.CallMethod(CodeGen.GetThis(), "FixBPA", BaseEntry.GetTypeReference(), reader, lengthExpression, ((IntegerPrimitiveMemberEntry)BaseEntry).GetEndian());
}
else
{
ret = CodeGen.CallMethod(CodeGen.GetThis(), "FixPA", BaseEntry.GetTypeReference(), reader, lengthExpression, ((IntegerPrimitiveMemberEntry)BaseEntry).GetEndian());
}
}
else
{
ret = CodeGen.CreateArray(BaseEntry.GetTypeReference(), 0);
}
return(ret);
}
private CodeExpression GetLength()
{
Type refType = ((BuiltinParserType)_reference.GetTargetMember().BaseType).DataType;
CodeExpression ret = CodeGen.GetField(CodeGen.GetThis(), _reference.GetNames());
if (refType != typeof(int))
{
ret = CodeGen.CallMethod(CodeGen.GetThis(), "CL", ret);
}
if (_adjustment != 0)
{
ret = CodeGen.GetOperator(ret, CodeBinaryOperatorType.Add, CodeGen.GetPrimitive(_adjustment));
}
return(ret);
}
public CodeExpression GetWriterExpression(CodeExpression writer, CodeExpression obj)
{
CodeExpression ret;
if (!String.IsNullOrEmpty(_termString))
{
ret = CodeGen.CallMethod(CodeGen.GetThis(), "WTS",
writer, CodeGen.GetEnum(StringEncoding), obj, CodeGen.GetPrimitive(GeneralUtils.DecodeEscapedString(_termString)));
}
else
{
ret = CodeGen.CallMethod(CodeGen.GetThis(), "WTS",
writer, CodeGen.GetEnum(StringEncoding), obj, CodeGen.GetPrimitive(_termChar)
);
}
return(ret);
}
public override System.CodeDom.CodeMemberMethod GetDeserializerMethod()
{
CodeMemberMethod method = base.GetDeserializerMethod();
IMemberReaderWriter entry = BaseEntry as IMemberReaderWriter;
if (_isByteLength)
{
CodeTypeReference listType = CodeGen.CreateGenericType(typeof(List <>), BaseEntry.GetTypeReference());
method.Statements.Add(CodeGen.MakeVariable(listType, "ret",
CodeGen.CreateObject(listType)));
method.Statements.Add(CodeGen.GetAssign(CodeGen.GetReader(),
CodeGen.CallMethod(CodeGen.GetThis(), "GBR", CodeGen.GetReader(), CodeGen.GetPrimitive(_lengthExpression))));
List <CodeStatement> loopStatements = new List <CodeStatement>();
CodeExpression expr = CodeGen.CallMethod(CodeGen.GetVariable("ret"), "Add", entry.GetReaderExpression(CodeGen.GetReader()));
method.Statements.Add(CodeGen.GetTryCatch(new CodeStatement[] { CodeGen.GetInfLoop(new CodeExpressionStatement(expr)) }, typeof(EndOfStreamException)));
method.Statements.Add(CodeGen.GetReturn(CodeGen.CallMethod(CodeGen.GetVariable("ret"), "ToArray")));
}
else
{
method.Statements.Add(CodeGen.MakeVariable(GetTypeReference(), "ret",
CodeGen.CreateArray(GetTypeReference(), CodeGen.GetLength(Length))));
List <CodeStatement> loopStatements = new List <CodeStatement>();
loopStatements.Add(CodeGen.GetAssign(
CodeGen.GetIndex(
CodeGen.GetVariable("ret"), CodeGen.GetVariable("i")
),
entry.GetReaderExpression(CodeGen.GetReader()))
);
method.Statements.Add(CodeGen.GetForLoop("i", 0, CodeGen.GetProperty(CodeGen.GetVariable("ret"), "Length"), 1, loopStatements.ToArray()));
method.Statements.Add(CodeGen.GetReturn(CodeGen.GetVariable("ret")));
}
return(method);
}
public override CodeMemberMethod GetPreSerializeMethod()
{
CodeMemberMethod method = base.GetPreSerializeMethod();
if (_reference.IsValid())
{
CodeExpression right;
if (_isByteLength)
{
right = CodeGen.CallMethod(CodeGen.GetThis(), "SBL", CodeGen.GetThisField(Name), CodeGen.GetEnum(StringEncoding));
}
else
{
right = CodeGen.GetProperty(CodeGen.GetThisField(Name), "Length");
}
EvalExpression lengthWrite = LengthWriteExpression;
if (lengthWrite.IsValid)
{
right = lengthWrite.GetEvalExpression(right);
}
else if (_adjustment != 0)
{
right = CodeGen.GetOperator(right, CodeBinaryOperatorType.Subtract, CodeGen.GetPrimitive(_adjustment));
}
if (_reference.GetTargetMember().BaseType is StringParserType)
{
right = CodeGen.CallMethod(right, "ToString");
}
else
{
right = CodeGen.GetCast(_reference.GetTargetMember().GetTypeReference(), right);
}
method.Statements.Add(CodeGen.GetAssign(CodeGen.GetField(CodeGen.GetThis(), _reference.GetNames()), right));
}
return(method);
}
public override System.CodeDom.CodeMemberMethod GetPreSerializeMethod()
{
CodeMemberMethod method = base.GetPreSerializeMethod();
if (_reference.IsValid())
{
CodeExpression right;
if (_isByteLength)
{
// Should really save this out and reuse when it comes to actually writing the data, seems a waste
method.Statements.Add(CodeGen.MakeVariable(typeof(DataWriter), "writer", CodeGen.CreateObject(typeof(DataWriter))));
IMemberReaderWriter entry = BaseEntry as IMemberReaderWriter;
List <CodeStatement> loopStatements = new List <CodeStatement>();
loopStatements.Add(CodeGen.GetStatement(entry.GetWriterExpression(CodeGen.GetWriter(), CodeGen.GetIndex(CodeGen.GetThisField(Name),
CodeGen.GetVariable("i")))));
method.Statements.Add(CodeGen.GetForLoop("i", 0, CodeGen.GetProperty(CodeGen.GetThisField(Name), "Length"),
1, loopStatements.ToArray()));
right = CodeGen.GetProperty(CodeGen.GetVariable("writer"), "BytesWritten");
}
else
{
right = CodeGen.GetProperty(CodeGen.GetThisField(Name), "Length");
}
if (_adjustment != 0)
{
right = CodeGen.GetOperator(right, CodeBinaryOperatorType.Subtract, CodeGen.GetPrimitive(_adjustment));
}
method.Statements.Add(CodeGen.GetAssign(CodeGen.GetField(CodeGen.GetThis(),
_reference.GetNames()), CodeGen.GetCast(_reference.GetTargetMember().GetTypeReference(), right)));
}
return(method);
}
internal static CodeExpression GetLength(EvalExpression lengthExpression)
{
if (lengthExpression.IsValid)
{
int length;
// If we can parse then just emit the primitive
if (lengthExpression.ParseInt(out length))
{
return(CodeGen.GetPrimitive(length));
}
else
{
return(CodeGen.CallMethod(CodeGen.GetThis(), "CL", CodeGen.GetPrimitive(lengthExpression.Expression)));
}
}
else
{
return(CodeGen.GetPrimitive(0));
}
}
public CodeExpression GetWriterExpression(CodeExpression writer, CodeExpression obj)
{
return(CodeGen.CallMethod(CodeGen.GetThis(), "WA", obj, writer));
}
/// <summary>
/// Method to generate the code to implement the type
/// </summary>
/// <returns></returns>
public override CodeTypeDeclaration GetCodeType()
{
CodeTypeDeclaration type = new CodeTypeDeclaration(Name);
type.IsClass = true;
type.BaseTypes.Add(new CodeTypeReference(typeof(BaseParser)));
type.Attributes = MemberAttributes.Public | MemberAttributes.Final;
type.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(GuidAttribute)),
new CodeAttributeArgument(new CodePrimitiveExpression(Uuid.ToString()))));
if (DisplayClass != Guid.Empty)
{
type.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(DisplayClassAttribute)),
new CodeAttributeArgument(new CodePrimitiveExpression(DisplayClass.ToString()))));
}
if (!String.IsNullOrWhiteSpace(_formatString))
{
type.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(FormatStringAttribute)),
new CodeAttributeArgument(new CodePrimitiveExpression(_formatString))));
}
CodeConstructor defaultConstructor = new CodeConstructor();
defaultConstructor.Attributes = MemberAttributes.Public;
type.Members.Add(defaultConstructor);
CodeConstructor fromStreamConstructor = new CodeConstructor();
fromStreamConstructor.Attributes = MemberAttributes.Public;
fromStreamConstructor.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(DataReader)), "reader"));
fromStreamConstructor.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(StateDictionary)), "state"));
fromStreamConstructor.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(Logger)), "logger"));
fromStreamConstructor.BaseConstructorArgs.Add(CodeGen.GetArgument("reader"));
fromStreamConstructor.BaseConstructorArgs.Add(CodeGen.GetArgument("state"));
fromStreamConstructor.BaseConstructorArgs.Add(CodeGen.GetArgument("logger"));
type.Members.Add(fromStreamConstructor);
CodeMemberMethod preSerializer = new CodeMemberMethod();
preSerializer.Name = "PreSerializer";
preSerializer.Attributes = MemberAttributes.Private;
CodeMemberMethod postSerializer = new CodeMemberMethod();
postSerializer.Name = "PostSerializer";
postSerializer.Attributes = MemberAttributes.Private;
CodeMemberMethod preDeserializer = new CodeMemberMethod();
preDeserializer.Name = "PreDeserializer";
preDeserializer.Attributes = MemberAttributes.Private;
CodeMemberMethod postDeserializer = new CodeMemberMethod();
postDeserializer.Name = "PostDeserializer";
postDeserializer.Attributes = MemberAttributes.Private;
CodeMemberMethod fromStreamMethod = new CodeMemberMethod();
fromStreamMethod.Name = "FromStream";
fromStreamMethod.Attributes = MemberAttributes.Public | MemberAttributes.Override;
CodeMemberMethod toStreamMethod = new CodeMemberMethod();
toStreamMethod.Name = "ToStream";
toStreamMethod.Attributes = MemberAttributes.Public | MemberAttributes.Override;
if (PreserializeExpression.IsValid)
{
toStreamMethod.Statements.Add(CodeGen.CallMethod(CodeGen.GetThis(), "Resolve", CodeGen.GetPrimitive(PreserializeExpression.Expression)));
}
foreach (MemberEntry entry in Members)
{
IMemberReaderWriter readerWriter = entry as IMemberReaderWriter;
CodeMemberField field = entry.GetMemberDeclaration();
if (entry.Hidden)
{
field.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(HiddenMemberAttribute)),
new CodeAttributeArgument(CodeGen.GetPrimitive(true))));
}
if (entry.ReadOnly)
{
field.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(ReadOnlyMemberAttribute)),
new CodeAttributeArgument(CodeGen.GetPrimitive(true))));
}
if (entry.DisplayClass != Guid.Empty)
{
field.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(DisplayClassAttribute)),
new CodeAttributeArgument(CodeGen.GetPrimitive(entry.DisplayClass.ToString()))));
}
type.Members.Add(field);
CodeMemberMethod serMethod = entry.GetSerializerMethod();
CodeMemberMethod deserMethod = entry.GetDeserializerMethod();
CodeMemberMethod preserMethod = entry.GetPreSerializeMethod();
CodeMemberMethod postserMethod = entry.GetPostSerializeMethod();
CodeMemberMethod predeserMethod = entry.GetPreDeserializeMethod();
CodeMemberMethod postdeserMethod = entry.GetPostDeserializeMethod();
if (readerWriter == null)
{
type.Members.Add(serMethod);
type.Members.Add(deserMethod);
}
if (preserMethod.Statements.Count > 0)
{
type.Members.Add(preserMethod);
preSerializer.Statements.Add(CodeGen.CallMethod(CodeGen.GetThis(), preserMethod.Name));
}
if (postserMethod.Statements.Count > 0)
{
type.Members.Add(postserMethod);
postSerializer.Statements.Add(CodeGen.CallMethod(CodeGen.GetThis(), postserMethod.Name));
}
if (predeserMethod.Statements.Count > 0)
{
type.Members.Add(predeserMethod);
preDeserializer.Statements.Add(CodeGen.CallMethod(CodeGen.GetThis(),
predeserMethod.Name));
}
if (postdeserMethod.Statements.Count > 0)
{
type.Members.Add(postdeserMethod);
postDeserializer.Statements.Add(CodeGen.CallMethod(CodeGen.GetThis(),
postserMethod.Name));
}
CodeStatement readStatement = null;
CodeStatement writeStatement = null;
if (readerWriter != null)
{
CodeExpression readExpression = readerWriter.GetReaderExpression(GetReader());
if (entry.ValidateExpression.IsValid)
{
readExpression = CodeGen.CallMethod(CodeGen.GetThis(), "V", readExpression, CodeGen.GetPrimitive(entry.ValidateExpression.Expression));
}
readStatement =
CodeGen.GetAssign(CodeGen.GetThisField(field.Name), readExpression);
writeStatement =
new CodeExpressionStatement(readerWriter.GetWriterExpression(GetWriter(), CodeGen.GetThisField(field.Name)));
}
else
{
CodeExpression readExpression = CodeGen.CallMethod(CodeGen.GetThis(), deserMethod.Name, GetReader());
if (entry.ValidateExpression.IsValid)
{
readExpression = CodeGen.CallMethod(CodeGen.GetThis(), "V", readExpression, CodeGen.GetPrimitive(entry.ValidateExpression.Expression));
}
readStatement =
CodeGen.GetAssign(CodeGen.GetThisField(field.Name), readExpression);
writeStatement =
new CodeExpressionStatement(CodeGen.CallMethod(CodeGen.GetThis(), serMethod.Name,
GetWriter(),
CodeGen.GetThisField(field.Name)));
}
if (entry.OptionalExpression.IsValid)
{
readStatement = CodeGen.GetIf(entry.OptionalExpression.GetCheckExpression(), new[] { readStatement });
writeStatement = CodeGen.GetIf(entry.OptionalExpression.GetCheckExpression(), new[] { writeStatement });
}
fromStreamMethod.Statements.Add(readStatement);
toStreamMethod.Statements.Add(writeStatement);
}
if (preDeserializer.Statements.Count > 0)
{
fromStreamMethod.Statements.Insert(0, CodeGen.GetStatement(CodeGen.CallMethod(CodeGen.GetThis(), "PreDeserializer")));
type.Members.Add(preDeserializer);
}
toStreamMethod.Statements.Add(new CodeMethodInvokeExpression(GetWriter(), "Flush"));
if (preSerializer.Statements.Count > 0)
{
toStreamMethod.Statements.Insert(0, CodeGen.GetStatement(CodeGen.CallMethod(CodeGen.GetThis(), "PreSerializer")));
type.Members.Add(preSerializer);
}
if (postDeserializer.Statements.Count > 0)
{
fromStreamMethod.Statements.Add(CodeGen.CallMethod(CodeGen.GetThis(), "PostDeserializer"));
type.Members.Add(postDeserializer);
}
if (PostDeserializeExpression.IsValid)
{
fromStreamMethod.Statements.Add(CodeGen.CallMethod(CodeGen.GetThis(), "Resolve", CodeGen.GetPrimitive(PostDeserializeExpression.Expression)));
}
if (postSerializer.Statements.Count > 0)
{
toStreamMethod.Statements.Add(CodeGen.CallMethod(CodeGen.GetThis(), "PostSerializer"));
type.Members.Add(postSerializer);
}
type.Members.Add(fromStreamMethod);
type.Members.Add(toStreamMethod);
return(type);
}
internal static CodeExpression GetCalc(EvalExpression expr, CodeTypeReference fieldType, CodeExpression value)
{
return(CodeGen.CallMethod(CodeGen.GetThis(), "Calc", fieldType, CodeGen.GetPrimitive(expr.Expression), value));
}
internal static CodeExpression GetResolve(EvalExpression expr, CodeExpression value, CodeExpression writer)
{
return(CodeGen.CallMethod(CodeGen.GetThis(), "Resolve", CodeGen.GetPrimitive(expr.Expression), writer, value));
}
public CodeExpression GetWriterExpression(CodeExpression writer, CodeExpression obj)
{
return(CodeGen.CallMethod(CodeGen.GetThis(), "FixWPA", obj, writer, CodeGen.GetLength(Length), _intEntry.GetEndian()));
}
public CodeExpression GetReaderExpression(CodeExpression reader)
{
return(CodeGen.CallMethod(CodeGen.GetThis(), "RTEPA", _intEntry.GetTypeReference(), reader, _intEntry.GetEndian(), CodeGen.GetLength(TrailingLength)));
}
internal static CodeExpression GetCheck(EvalExpression expr, CodeExpression value, CodeExpression i)
{
return(CodeGen.CallMethod(CodeGen.GetThis(), "Check", CodeGen.GetPrimitive(expr.Expression), value, i));
}
public CodeExpression GetWriterExpression(CodeExpression writer, CodeExpression obj)
{
return(CodeGen.CallMethod(CodeGen.GetThis(), "WPA", obj, writer, ((IntegerPrimitiveMemberEntry)BaseEntry).GetEndian()));
}
public virtual CodeExpression GetReaderExpression(CodeExpression reader)
{
return(CodeGen.CreateObject(new CodeTypeReference(BaseType.Name), reader, CodeGen.CallMethod(CodeGen.GetThis(), "CS"), CodeGen.GetLogger()));
}
public CodeExpression GetWriterExpression(CodeExpression writer, CodeExpression obj)
{
return(CodeGen.CallMethod(obj, "ToStream",
writer, CodeGen.CallMethod(CodeGen.GetThis(), "CS"), CodeGen.GetLogger()));
}
public CodeExpression GetCheckExpression(CodeExpression valueExpression)
{
return(CodeGen.CallMethod(CodeGen.GetThis(), "Check", CodeGen.GetPrimitive(Expression), valueExpression));
}
public CodeExpression GetEvalExpression(CodeExpression valueExpression)
{
return(CodeGen.CallMethod(CodeGen.GetThis(), "Resolve", CodeGen.GetPrimitive(Expression), valueExpression));
}
