public virtual void MakeOutArgument(CodeStatementCollection statements
            , CodeStatementCollection stmtsFinishResult
            , string idlMethodName
            , CodeTypeFactory codetypeFactoryOut
            , ref int nOutArgCounter
            , Udbus.Parsing.BuildContext context
            , ref CodeThrowExceptionStatement throwargOutPrev
            , IDLArgument idlMethodArg
            //, IDLMethodArgument idlMethodArg
            , Udbus.Parsing.IDLArgumentTypeNameBuilderBase nameBuilder
            , ref ParamCodeTypeHolderMarshalBase paramtypeHolder
            , ref CodeTypeReference typerefParam
            , out CodeConditionStatement condVarResult)
        {
            marshal.outward.ParamCodeTypeHolderMarshalOut paramtypeHolderOut = new marshal.outward.ParamCodeTypeHolderMarshalOut(codetypeFactoryOut);
            Udbus.Parsing.CodeBuilderHelper.BuildCodeParamType(paramtypeHolderOut, nameBuilder, idlMethodArg.Type, context);
            paramtypeHolder = paramtypeHolderOut;
            typerefParam = paramtypeHolder.paramtype.CodeType;

            // Initialise out parameter.
            this.AssignOutParamDefault(statements, idlMethodArg, typerefParam);

            // Read out parameter from message into temporary.
            string argResultVar = idlMethodArg.Name + "Result";
            CodeVariableReferenceExpression varrefResultVar = new CodeVariableReferenceExpression(argResultVar);

            condVarResult = new CodeConditionStatement(
                // * if (this.result == 0)
                exprResultOk,
                new CodeStatement[] // True statements
                {
                    // * <param_type> <arg_name>Result;
                    new CodeVariableDeclarationStatement(typerefParam, argResultVar),
                    // * this.result = reader.Marshal<type>(<marshal_function>, out <arg_name>Result);
                    new CodeAssignStatement(fieldrefResult,
                        paramtypeHolderOut.BuildReadExpression(varrefReader,
                            new CodeDirectionExpression(FieldDirection.Out, varrefResultVar)))
                }
                , new CodeStatement[] // False statements
                {
                    throwargOutPrev
                }
                );

            throwargOutPrev = this.ThrowArgOutException(idlMethodName, nOutArgCounter, idlMethodArg.Name, typerefParam);

            // * <arg_name> = <arg_name>Result;
            this.FinishArgument(idlMethodName, stmtsFinishResult, idlMethodArg, varrefResultVar);
            ++nOutArgCounter;
        }
        public virtual void MakeInArgument(CodeTypeFactory codetypefactoryIn
            , string idlMethodName
            , ref int nInArgCounter
            , Udbus.Parsing.BuildContext context
            , ref CodeThrowExceptionStatement throwargInPrev
            , IDLMethodArgument idlMethodArg
            , Udbus.Parsing.IDLArgumentTypeNameBuilderBase nameBuilder
            , ref ParamCodeTypeHolderMarshalBase paramtypeHolder
            , ref CodeTypeReference typerefParam
            , out CodeConditionStatement condVarResult)
        {
            marshal.inward.ParamCodeTypeHolderMarshalIn paramtypeHolderIn = new marshal.inward.ParamCodeTypeHolderMarshalIn(codetypefactoryIn);
            Udbus.Parsing.CodeBuilderHelper.BuildCodeParamType(paramtypeHolderIn, nameBuilder, idlMethodArg.Type, context);
            paramtypeHolder = paramtypeHolderIn;
            /*typerefParamIter = */
            typerefParam = paramtypeHolder.paramtype.CodeType;

            condVarResult = new CodeConditionStatement(
                // * if (this.result == 0)
                exprResultOk
                , new CodeStatement[] // True statements
                {
                    // * this.result = builder.Marshal<arg_type>(<marshal_function>, <arg_name>);
                    new CodeAssignStatement(fieldrefResult,
                        paramtypeHolderIn.BuildWriteExpression(varrefBuilder,
                            MarshalArgument(idlMethodName, idlMethodArg)))
                }
                , new CodeStatement[] // False statements
                {
                    throwargInPrev
                }
                );

            throwargInPrev = new CodeThrowExceptionStatement(
                new CodeMethodInvokeExpression(MarshalBuilderHelper.typerefexprArgumentInException, "Create",
                    new CodePrimitiveExpression(nInArgCounter + 1),
                    new CodePrimitiveExpression(idlMethodArg.Name),
                    new CodeTypeOfExpression(typerefParam),
                    fieldrefResult,
                    new CodePrimitiveExpression(idlMethodName),
                    fieldrefConnectionParameters
                )
            );

            ++nInArgCounter;
        }