コード例 #1
0
        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);
        }
コード例 #2
0
        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);
        }
コード例 #3
0
        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);
        }
コード例 #4
0
        public override System.CodeDom.CodeMemberMethod GetDeserializerMethod()
        {
            CodeMemberMethod    method = base.GetDeserializerMethod();
            IMemberReaderWriter entry  = BaseEntry as IMemberReaderWriter;

            if (_reference.IsValid())
            {
                CodeTypeReference    listType       = CodeGen.CreateGenericType(typeof(List <>), BaseEntry.GetTypeReference());
                List <CodeStatement> loopStatements = new List <CodeStatement>();

                method.Statements.Add(CodeGen.MakeVariable(listType, "ret", CodeGen.CreateObject(listType)));

                method.Statements.Add(CodeGen.MakeVariable(typeof(int), "length", GetLength()));

                loopStatements.Add(CodeGen.GetStatement(CodeGen.CallMethod(CodeGen.GetVariable("ret"), "Add", entry.GetReaderExpression(CodeGen.GetReader()))));

                if (_isByteLength)
                {
                    // Reassign reader to just the sub data
                    method.Statements.Add(CodeGen.MakeVariable(typeof(DataReader), "reader", CodeGen.CreateObject(typeof(DataReader),
                                                                                                                  CodeGen.CallMethod(CodeGen.GetArgument("reader"), "ReadBytes", GetLength()))));

                    method.Statements.Add(CodeGen.GetTryCatch(new CodeStatement[] { CodeGen.GetInfLoop(loopStatements.ToArray()) }, typeof(EndOfStreamException)));

                    method.Statements.Add(CodeGen.CallMethod(CodeGen.GetArgument("reader"), "Flush"));
                }
                else
                {
                    method.Statements.Add(CodeGen.GetForLoop("i", 0, CodeGen.GetVariable("length"), 1, loopStatements.ToArray()));
                }

                method.Statements.Add(CodeGen.GetReturn(CodeGen.CallMethod(CodeGen.GetVariable("ret"), "ToArray")));
            }
            else
            {
                method.Statements.Add(CodeGen.GetReturn(CodeGen.CreateArray(GetTypeReference(), 0)));
            }

            return(method);
        }