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 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 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())); } }
internal static CodeExpression CreateByteArray(byte[] bytes) { List <CodeExpression> inits = new List <CodeExpression>(); foreach (byte b in bytes) { inits.Add(CodeGen.GetPrimitive(b)); } return(new CodeArrayCreateExpression(typeof(byte[]), inits.ToArray())); }
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)); } }
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); }
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 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 override System.CodeDom.CodeTypeDeclaration GetCodeType() { CodeTypeDeclaration type = new CodeTypeDeclaration(Name); type.IsClass = true; type.Attributes = MemberAttributes.Final | MemberAttributes.Static; type.BaseTypes.Add(typeof(PySnippet)); CodeConstructor defaultConstructor = new CodeConstructor(); defaultConstructor.Attributes = MemberAttributes.Public; defaultConstructor.BaseConstructorArgs.Add(CodeGen.GetPrimitive(_script.Script)); type.Members.Add(defaultConstructor); return(type); }
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); }
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) { // No point doing anything if there is no length to write if (_reference.IsValid()) { if (StringEncoding == BinaryStringEncoding.ASCII) { return(CodeGen.CallMethod(writer, "Write", obj)); } else { return(CodeGen.CallMethod(writer, "Write", obj, CodeGen.GetEnum(StringEncoding))); } } else { return(CodeGen.CallMethod(writer, "Write", CodeGen.GetPrimitive(String.Empty))); } }
public override CodeTypeDeclaration GetCodeType() { CodeTypeDeclaration type = new CodeTypeDeclaration(Name); type.IsClass = true; type.BaseTypes.Add(new CodeTypeReference(typeof(GenericStreamParser <>).FullName, new CodeTypeReference(_baseType.Name))); type.Attributes = MemberAttributes.Public | MemberAttributes.Final; if (!String.IsNullOrWhiteSpace(_formatString)) { CodeConstructor constructor = new CodeConstructor(); constructor.Attributes = MemberAttributes.Public; constructor.BaseConstructorArgs.Add(CodeGen.GetPrimitive(_formatString)); type.Members.Add(constructor); } return(type); }
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) { CodeExpression ret; if (_isByteLength) { ret = CodeGen.CallMethod(typeof(ParserUtils), "WriteFixedByteLengthString", writer, GetEncoding(), obj, CodeGen.GetLength(Length), CodeGen.GetPrimitive((byte)Padding)); } else { ret = CodeGen.CallMethod(typeof(ParserUtils), "WriteFixedLengthString", writer, GetEncoding(), obj, CodeGen.GetLength(Length), CodeGen.GetPrimitive((char)Padding)); } return(ret); }
public override System.CodeDom.CodeMemberMethod GetDeserializerMethod() { CodeMemberMethod method = base.GetDeserializerMethod(); CodeTypeReference listType = CodeGen.CreateGenericType(typeof(List <>), BaseEntry.GetTypeReference()); method.Statements.Add(CodeGen.MakeVariable(listType, "ret", CodeGen.CreateObject(listType))); method.Statements.Add(CodeGen.MakeVariable(typeof(int), "i", CodeGen.GetPrimitive(0))); List <CodeStatement> loopStatements = new List <CodeStatement>(); loopStatements.Add(CodeGen.MakeVariable(BaseEntry.GetTypeReference(), "o", _memberEntry.GetReaderExpression(CodeGen.GetReader()))); loopStatements.Add(CodeGen.GetStatement(CodeGen.CallMethod(CodeGen.GetVariable("ret"), "Add", CodeGen.GetVariable("o")))); if (TermExpression.IsValid) { CodeStatement[] ret = new CodeStatement[] { CodeGen.GetReturn(CodeGen.CallMethod(CodeGen.GetVariable("ret"), "ToArray")) }; loopStatements.Add(CodeGen.GetIf(CodeGen.GetCheck(TermExpression, CodeGen.GetVariable("o"), CodeGen.GetVariable("i")), ret)); loopStatements.Add(CodeGen.GetIncrement(CodeGen.GetVariable("i"), 1)); } if (!_required) { method.Statements.Add( CodeGen.GetTryCatch(new CodeStatement[] { CodeGen.GetInfLoop(loopStatements.ToArray()) }, typeof(EndOfStreamException))); method.Statements.Add(CodeGen.GetReturn(CodeGen.CallMethod(CodeGen.GetVariable("ret"), "ToArray"))); } else { method.Statements.Add(CodeGen.GetInfLoop(loopStatements.ToArray())); } return(method); }
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 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); }
internal static CodeExpression GetCalc(EvalExpression expr, CodeTypeReference fieldType, CodeExpression value) { return(CodeGen.CallMethod(CodeGen.GetThis(), "Calc", fieldType, CodeGen.GetPrimitive(expr.Expression), value)); }
public CodeExpression GetEvalExpression(CodeExpression valueExpression) { return(CodeGen.CallMethod(CodeGen.GetThis(), "Resolve", CodeGen.GetPrimitive(Expression), valueExpression)); }
internal static CodeArrayCreateExpression CreateArray(CodeTypeReference t, int length) { return(CreateArray(t, CodeGen.GetPrimitive(length))); }
public CodeExpression GetWriterExpression(CodeExpression writer, CodeExpression obj) { return(_primitiveEntry.GetWriterExpression(writer, CodeGen.GetCast(_primitiveEntry.GetCastType(), CodeGen.CallMethod(typeof(ParserUtils), "GetBooleanValue", _primitiveEntry.GetDataType(), obj, CodeGen.GetPrimitive(_trueValue), CodeGen.GetPrimitive(_falseValue))))); }
internal static CodeExpression GetCheck(EvalExpression expr, CodeExpression value, CodeExpression i) { return(CodeGen.CallMethod(CodeGen.GetThis(), "Check", CodeGen.GetPrimitive(expr.Expression), value, i)); }
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 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)))); } }
internal static CodeExpression GetResolve(EvalExpression expr, CodeExpression value, CodeExpression writer) { return(CodeGen.CallMethod(CodeGen.GetThis(), "Resolve", CodeGen.GetPrimitive(expr.Expression), writer, value)); }
/// <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); }
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 CodeExpression GetReaderExpression(CodeExpression reader) { return(CodeGen.GetOperator(CodeGen.GetPrimitive(_falseValue), CodeBinaryOperatorType.IdentityInequality, CodeGen.GetCast(_primitiveEntry.GetDataType(), _primitiveEntry.GetReaderExpression(reader)))); }
public CodeExpression GetCheckExpression(CodeExpression valueExpression) { return(CodeGen.CallMethod(CodeGen.GetThis(), "Check", CodeGen.GetPrimitive(Expression), valueExpression)); }