public virtual CodeConditionStatement FinishInArguments(string idlMethodName, MarshalBuilderHelper codebuilder, CodeConditionStatement condMethodSignature
            , CodeConditionStatement condIn, CodeConditionStatement condInIter, CodeThrowExceptionStatement throwargInPrev)
        {
            if (condIn != null) // If got arguments to add
            {
                if (condInIter != null && condInIter != condIn) // If multiple arguments
                {
                    // Check the final argument is ok.
                    // * if (this.result != 0) { throw UdbusMessageMethodArgumentInException.Create(...); }
                    condInIter.TrueStatements.Add(codebuilder.ThrowArgInException(throwargInPrev));

                } // Ends if multiple arguments

                condMethodSignature.TrueStatements.Add(condIn);
                condIn = condMethodSignature;

                CodeConditionStatement condMethodResult = codebuilder.AddBodyLength(idlMethodName);
                condMethodResult.TrueStatements.Add(condIn);
                condIn = condMethodResult;

            } // Ends if got arguments to add
            return condIn;
        }
        static public CodeMemberMethod MakeMethod(CodeTypeFactory codetypefactoryOut, CodeTypeFactory codetypefactoryIn,
            Udbus.Parsing.CodeMemberDeferredClassHolder declarationHolder,
            IDLInterface idlIntf,
            IDLMethod idlMethod,
            MarshalBuilderHelper codebuilder)
        {
            CodeMemberMethod method = new CodeMemberMethod();
            CodeComment commentMethod = new CodeComment(idlMethod.Name);
            method.Comments.Add(new CodeCommentStatement(idlMethod.Name));
            method.Name = idlMethod.Name;
            method.Attributes = MemberAttributes.Public;

            foreach (IDLMethodArgument idlMethodArg in idlMethod.Arguments)
            {
                method.Comments.Add(new CodeCommentStatement(string.Format("{0} {1} \"{2}\"", idlMethodArg.Direction, idlMethodArg.Name, idlMethodArg.Type)));
            }

            // Context used for all arguments in method.
            Udbus.Parsing.BuildContext context = new Udbus.Parsing.BuildContext(declarationHolder);
            MakeMethodParameters(codetypefactoryOut, codetypefactoryIn,
                declarationHolder,
                idlIntf,
                method.Name,
                idlMethod.Name,
                idlMethod.Arguments,
                method.Parameters,
                method.Statements,
                context,
                codebuilder
            );

            return method;
        }
        static public void MakeSignalParameters(CodeTypeDeclaration typedeclArgs,
            CodeTypeFactory codetypefactoryOut,
            Udbus.Parsing.CodeMemberDeferredClassHolder declarationHolder,
            IDLInterface idlIntf,
            string methodName,
            string idlSignalName,
            IList<IDLSignalArgument> arguments,
            CodeParameterDeclarationExpressionCollection parameters,
            CodeStatementCollection statements,
            Udbus.Parsing.BuildContext context,
            MarshalBuilderHelper codebuilder)
        {
            CodeStatementCollection statementsTryRecv = new CodeStatementCollection();
            int nOutArgCounter = 0;
            List<CodeMethodInvokeExpression> invokemethodsBuild = new List<CodeMethodInvokeExpression>();
            CodeConditionStatement condOut = null; // Root if statement for out parameters.
            CodeConditionStatement condOutIter = null; // Most nested if statement for out parameters.
            CodeStatementCollection stmtsFinishResult = new CodeStatementCollection();
            CodeTypeReference typerefParamIter = CodeBuilderCommon.typerefUnknownParameters;
            string argNameIter = arguments != null && arguments.Count > 0 ? arguments[0].Name : "UnknownParameters";

            CodeThrowExceptionStatement throwargOutPrev = codebuilder.CreateArgumentOutException(idlSignalName);

            // WAXME
            //CodeConstructor constructorArgs = new CodeConstructor();
            //constructorArgs.Attributes = MemberAttributes.Public;
            foreach (IDLSignalArgument idlSignalArg in arguments)
            {
                argNameIter = idlSignalArg.Name;

                // Parse the type string for the argument, creating required structs as we go, and returning a type for the argument.
                //Udbus.Parsing.IDLArgumentTypeNameBuilderBase nameBuilder = new IDLMethodArgumentTypeNameBuilder(idlIntf, idlMethod, idlMethodArg);
                Udbus.Parsing.IDLArgumentTypeNameBuilderBase nameBuilder = new IDLArgumentTypeNameBuilder(idlIntf, methodName);
                ParamCodeTypeHolderMarshalBase paramtypeHolder = null;
                CodeTypeReference typerefParam = null;
                if (condOut == null)
                {
                    codebuilder.PrefixOutParams(ref condOut, ref condOutIter, idlSignalName, ref nOutArgCounter, ref throwargOutPrev);
                }

                // Handle the signal argument in the message.
                CodeConditionStatement condVarResult;
                codebuilder.MakeOutArgument(statements
                    , stmtsFinishResult
                    , idlSignalName
                    , codetypefactoryOut // Yeah I messed up the naming
                    , ref nOutArgCounter
                    , context
                    , ref throwargOutPrev
                    , idlSignalArg
                    , nameBuilder
                    , ref paramtypeHolder
                    , ref typerefParam
                    , out condVarResult
                );

                codebuilder.StoreCondIterator(ref condOut, ref condOutIter, condVarResult);

                // WAXME
                // Add a field to the <signal>Args class.
                //string argFieldName = CodeBuilderCommon.GetSignalArgFieldName(idlSignalArg.Name);
                //CodeFieldReferenceExpression fielrefdRefArgField = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), argFieldName);
                //typedeclArgs.Members.Add(new CodeMemberField(paramtypeHolder.paramtype.CodeType, argFieldName));
                //CodeMemberProperty propArgField = new CodeMemberProperty();
                //propArgField.Attributes = MemberAttributes.Public | MemberAttributes.Final;
                //propArgField.Type = paramtypeHolder.paramtype.CodeType;
                //propArgField.Name = PropertyNameFromFieldName(argFieldName);
                //propArgField.GetStatements.Add(new CodeMethodReturnStatement(fielrefdRefArgField));
                //typedeclArgs.Members.Add(propArgField);
                //constructorArgs.Parameters.Add(new CodeParameterDeclarationExpression(paramtypeHolder.paramtype.CodeType, argFieldName));
                //// * this.<signal_arg> = <signal_arg>;
                //constructorArgs.Statements.Add(new CodeAssignStatement(fielrefdRefArgField, new CodeArgumentReferenceExpression(argFieldName)));

            } // Ends loop over arguments

            //typedeclArgs.Members.Add(constructorArgs);

            codebuilder.AssignResults(statementsTryRecv, condOut, condOutIter, stmtsFinishResult, throwargOutPrev
                , idlSignalName, ref nOutArgCounter
            );
            List<CodeStatement> statementsReponse = new List<CodeStatement>();

            // Now receive the response.
            // Create message reader.
            // * Udbus.Core.UdbusMessageReader reader = new Udbus.Core.UdbusMessageReader(msgHandleResp);
            statementsTryRecv.Insert(0, codebuilder.CreateMessageReader());
            statementsReponse.AddRange(statementsTryRecv.Cast<CodeStatement>());
            statements.Add(new CodeConditionStatement(exprResultOk, statementsReponse.ToArray()));
        }
        static public CodeMemberMethod MakeSignal(CodeNamespace ns, CodeTypeDeclaration typeMarshal, CodeTypeFactory codetypefactoryOut,
            Udbus.Parsing.CodeMemberDeferredClassHolder declarationHolder,
            IDLInterface idlIntf,
            IDLSignal idlSignal,
            MarshalBuilderHelper codebuilder)
        {
            string signalMethodName = "Handle" + CodeBuilderCommon.GetSignalTypeName(idlSignal.Name);

            //// * public class <signal_as_type>Args : EventArgs
            CodeTypeDeclaration typeArgs = new CodeTypeDeclaration(CodeBuilderCommon.GetSignalEventTypeName(idlSignal.Name));
            //typeArgs.BaseTypes.Add(typerefSignalEventArgs);

            // * const string StorageSpaceLowMatchRule = "type=\'signal\',interface=\'<interface>\',member=\'<signal>'";
            CodeMemberField fieldMatchRule = new CodeMemberField(typeof(string), CodeBuilderCommon.GetSignalCompilableName(idlSignal.Name) + "MatchRule");
            fieldMatchRule.InitExpression = new CodePrimitiveExpression(string.Format("type='signal',interface='{0}',member='{1}'", idlIntf.Name, idlSignal.Name));
            fieldMatchRule.Attributes = MemberAttributes.Private | MemberAttributes.Const;
            typeMarshal.Members.Add(fieldMatchRule);
            CodeFieldReferenceExpression fieldrefMatchrule = new CodeFieldReferenceExpression(null, fieldMatchRule.Name);

            // * private Udbus.Core.SignalKey StorageSpaceLowSignalKey { get { return new Udbus.Core.SignalKey(this.ConnectionParameters.Path, this.ConnectionParameters.Interface, "storage_space_low"); } }
            // * private Udbus.Core.SignalEntry StorageSpaceLowSignalEntry { get { return new Udbus.Core.SignalEntry(this.StorageSpaceLowSignalKey, this.HandleStorageSpaceLow); } }
            CodeMethodReferenceExpression methodrefSignal = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), signalMethodName);
            CodeMemberProperty propSignalKey = new CodeMemberProperty();
            propSignalKey.Name = CodeBuilderCommon.GetSignalCompilableName(idlSignal.Name) + "Key";
            propSignalKey.Type = typerefSignalKey;
            propSignalKey.Attributes = MemberAttributes.Private | MemberAttributes.Final;
            propSignalKey.GetStatements.Add(new CodeMethodReturnStatement(new CodeObjectCreateExpression(typerefSignalKey
                , proprefConnectionParametersPath, proprefConnectionParametersInterface, new CodePrimitiveExpression(idlSignal.Name)
            )));
            CodeMemberProperty propSignalEntry = new CodeMemberProperty();
            propSignalEntry.Name = CodeBuilderCommon.GetSignalCompilableName(idlSignal.Name) + "Entry";
            propSignalEntry.Type = typerefSignalEntry;
            propSignalEntry.Attributes = MemberAttributes.Private | MemberAttributes.Final;
            propSignalEntry.GetStatements.Add(new CodeMethodReturnStatement(new CodeObjectCreateExpression(typerefSignalEntry
                , new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), propSignalKey.Name)
                , methodrefSignal
            )));
            typeMarshal.Members.Add(propSignalKey);
            typeMarshal.Members.Add(propSignalEntry);

            // * public virtual void RegisterForStorageSpaceLow()
            // * {
            // *     this.RegisterForSignal(StorageSpaceLowMatchRule, this.StorageSpaceLowSignalEntry, this.RegisterSignalHandlers);
            // * }
            CodeMemberMethod methodRegisterForSpecificSignal = new CodeMemberMethod();
            methodRegisterForSpecificSignal.Name = CodeBuilderCommon.GetSignalRegisterFunction(idlSignal.Name);
            methodRegisterForSpecificSignal.Statements.Add(new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), RegisterForSignal
                , fieldrefMatchrule
                , new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), propSignalEntry.Name)
                , new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), proprefRegisterSignalHandlers.PropertyName)
            ));
            typeMarshal.Members.Add(methodRegisterForSpecificSignal);

            CodeMemberEvent eventSignal = CodeBuilderCommon.CreateSignalEvent(idlSignal);
            CodeVariableReferenceExpression varrefSignalHandler = new CodeVariableReferenceExpression("signalHandler");
            CodeEventReferenceExpression eventrefSignalHandlerSignal = new CodeEventReferenceExpression(varrefSignalHandler, eventSignal.Name);
            CodeMethodInvokeExpression invokeGetSignalHandler = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), GetSignalHandler);
            CodeTypeReference typerefMarshal = new CodeTypeReference(typeMarshal.Name);
            CodeMemberProperty propEventSignal = new CodeMemberProperty();
            propEventSignal.Name = CodeBuilderCommon.GetSignalEventPropertyName(idlSignal.Name);
            propEventSignal.Attributes = MemberAttributes.Public | MemberAttributes.Final;
            propEventSignal.Type = eventSignal.Type;
            // * return this.GetSignalHandler().storageSpaceLowEvent;
            propEventSignal.GetStatements.Add(new CodeMethodReturnStatement(new CodeEventReferenceExpression(invokeGetSignalHandler, eventSignal.Name)));

            // * <service> signalHandler = this.GetSignalHandler();
            propEventSignal.SetStatements.Add(new CodeVariableDeclarationStatement(typerefMarshal, varrefSignalHandler.VariableName, invokeGetSignalHandler));
            // * if (signalHandler.<signal>Event == null)
            propEventSignal.SetStatements.Add(new CodeConditionStatement(new CodeBinaryOperatorExpression(eventrefSignalHandlerSignal, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null))
                // *     signalHandler.RegisterFor<signal>();
                , new CodeExpressionStatement(new CodeMethodInvokeExpression(varrefSignalHandler, methodRegisterForSpecificSignal.Name))
            ));
            // * signalHandler.<signal>Event = value;
            propEventSignal.SetStatements.Add(
                new CodeAssignStatement(eventrefSignalHandlerSignal, new CodePropertySetValueReferenceExpression())
            );
            // * private event System.EventHandler< <signal>Args > <signal>Event { ... }
            // * public System.EventHandler< <signal>Args > <signal>;
            typeMarshal.Members.Add(eventSignal);
            typeMarshal.Members.Add(propEventSignal);

            // * public event System.EventHandler< <signal>Args > <signal>;
            //string eventPropertyName = CodeBuilderCommon.GetSignalEventName(idlSignal.Name);
            //CodeMemberEvent eventSignal = new CodeMemberEvent();
            //eventSignal.Attributes = MemberAttributes.Public;
            //eventSignal.Name = CodeBuilderCommon.GetSignalEventName(idlSignal.Name);
            //CodeTypeReference typerefEvent = new CodeTypeReference(typeof(System.EventHandler<>));
            //typerefEvent.TypeArguments.Add(new CodeTypeReference(CodeBuilderCommon.GetSignalEventTypeName(idlSignal.Name)));
            //eventSignal.Type = typerefEvent;
            //typeMarshal.Members.Add(eventSignal);

            //// * public void RegisterFor<signal_compilable>()
            //// * {
            //// *     this.AddMatchInternal("type='signal',interface='<interface>',member='<signal>'");
            //// * }
            //CodeMemberMethod methodRegister = new CodeMemberMethod();
            //methodRegister.Attributes = MemberAttributes.Public;
            //methodRegister.Name = GetSignalRegisterFunctionName(idlSignal.Name);
            //methodRegister.Statements.Add(
            //    new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), AddMatchInternal.Name
            //        ,new CodePrimitiveExpression(string.Format(
            //            "type='signal',interface='{0}',member='{1}'", idlIntf.Name, idlSignal.Name
            //        ))
            //    )
            //);
            //typeMarshal.Members.Add(methodRegister);

            //CodeMemberMethod methodRegisterWithInterface = new CodeMemberMethod();
            //methodRegisterWithInterface.Attributes = MemberAttributes.Public;
            //methodRegisterWithInterface.Name = methodRegister.Name;
            //methodRegisterWithInterface.Parameters.Add(new CodeParameterDeclarationExpression(typerefIRegisterSignalHandlers, register));
            //methodRegisterWithInterface.Statements.Add(new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), methodRegister.Name));
            //// * new Udbus.Core.SignalEntry(new Udbus.Core.SignalKey(this.ConnectionParameters.Path, this.ConnectionParameters.Interface, "storage_space_low")
            //methodRegisterWithInterface.Statements.Add(new CodeMethodInvokeExpression(argrefRegister, AddSignalHandler
            //    , new CodeObjectCreateExpression(typerefSignalEntry
            //        , new CodeObjectCreateExpression(typerefSignalKey
            //            , MarshalBuilderHelper.proprefThisConnectionParametersPath
            //            , MarshalBuilderHelper.proprefThisConnectionParametersInterface
            //            , new CodePrimitiveExpression(idlSignal.Name)
            //        )
            //        , methodrefSignal
            //    )
            //));
            //typeMarshal.Members.Add(methodRegisterWithInterface);

            // * Handle<signal>(<signal>Args args)
            CodeMemberMethod method = new CodeMemberMethod();
            CodeComment commentMethod = new CodeComment(idlSignal.Name);
            method.Comments.Add(new CodeCommentStatement(idlSignal.Name));
            method.Name = signalMethodName;
            method.Attributes = MemberAttributes.Public;
            method.Parameters.Add(MarshalBuilderHelper.paramdeclMessageResponse);

            foreach (IDLSignalArgument idlSignalArg in idlSignal.Arguments)
            {
                method.Comments.Add(new CodeCommentStatement(string.Format(" {0} \"{1}\"", idlSignalArg.Name, idlSignalArg.Type)));
            }

            // Context used for all arguments in method.
            Udbus.Parsing.BuildContext context = new Udbus.Parsing.BuildContext(declarationHolder);
            MakeSignalParameters(typeArgs, codetypefactoryOut,
                declarationHolder,
                idlIntf,
                method.Name,
                idlSignal.Name,
                idlSignal.Arguments,
                method.Parameters,
                method.Statements,
                context,
                codebuilder
            );

            //ns.Types.Add(typeArgs);
            return method;
        }
 private static CodeMemberProperty MakePropertySet(CodeMemberProperty property, CodeTypeFactory codetypefactoryOut, CodeTypeFactory codetypefactoryIn,
     Udbus.Parsing.CodeMemberDeferredClassHolder declarationHolder,
     IDLInterface idlIntf,
     IDLProperty idlProperty,
     Udbus.Parsing.BuildContext context,
     MarshalBuilderHelper codebuilder)
 {
     List<IDLMethodArgument> arguments = new List<IDLMethodArgument>(new IDLMethodArgument[]
     {
         //<arg name="interface_name" type="s"/>
         //<arg name="property_name" type="s"/>
         new IDLMethodArgument{ Name="interface_name", Type="s", Direction="in" },
         new IDLMethodArgument{ Name="property_name", Type="s", Direction="in" },
         //<arg name="value" type="<PropertyType>"/>
         new IDLMethodArgument{ Name="value", Type=idlProperty.Type, Direction="in"}
     }
     );
     MakeMethodParameters(codetypefactoryOut, codetypefactoryIn,
         declarationHolder,
         idlIntf,
         "Set",
         idlProperty.Name,
         arguments,
         new CodeParameterDeclarationExpressionCollection(),
         property.SetStatements,
         context,
         codebuilder
     );
     return property;
 }
        static public void MakeMethodParameters(CodeTypeFactory codetypefactoryOut, CodeTypeFactory codetypefactoryIn,
            Udbus.Parsing.CodeMemberDeferredClassHolder declarationHolder,
            IDLInterface idlIntf,
            string methodName,
            string idlMethodName,
            IList<IDLMethodArgument> arguments,
            CodeParameterDeclarationExpressionCollection parameters,
            CodeStatementCollection statements,
            Udbus.Parsing.BuildContext context,
            MarshalBuilderHelper codebuilder)
        {
            CodeStatementCollection statementsTryRecv = new CodeStatementCollection();
            CodeConditionStatement condMethodSignature = new CodeConditionStatement(
                exprResultOk
                , new CodeStatement[]
                {
                    codebuilder.SetSignature() 
                }
                , new CodeStatement[]
                {
                    // * throw Udbus.Core.Exceptions.UdbusMessageBuilderException.Create("BodyAdd", serial, "<method_name>", this.result, this.ConnectionParameters);
                    codebuilder.ThrowMessageBuilderException(idlMethodName, "BodyAdd")
                }
            );

            // Check for in parameters.
            bool bInParameters = codebuilder.InitialiseSignature(arguments, statements);

            int nInArgSigCounter = 0;
            int nInArgCounter = 0;
            int nOutArgCounter = 0;
            List<CodeMethodInvokeExpression> invokemethodsBuild = new List<CodeMethodInvokeExpression>();
            CodeConditionStatement condOut = null; // Root if statement for out parameters.
            CodeConditionStatement condOutIter = null; // Most nested if statement for out parameters.
            CodeConditionStatement condIn = null; // Root if statement for in parameters.
            CodeConditionStatement condInIter = null; // Most nested if statement for in parameters.
            CodeStatementCollection stmtsFinishResult = new CodeStatementCollection();
            //Udbus.Parsing.BuildContext context = new Udbus.Parsing.BuildContext(declarationHolder);
            CodeTypeReference typerefParamIter = CodeBuilderCommon.typerefUnknownParameters;
            string argNameIter = arguments != null && arguments.Count > 0 ? arguments[0].Name : "UnknownParameters";

            CodeThrowExceptionStatement throwargOutPrev = codebuilder.CreateArgumentOutException(idlMethodName);

            CodeThrowExceptionStatement throwargInPrev = codebuilder.ThrowMessageBuilderException(idlMethodName, "SetSignature");

            foreach (IDLMethodArgument idlMethodArg in arguments)
            {
                argNameIter = idlMethodArg.Name;

                // Parse the type string for the argument, creating required structs as we go, and returning a type for the argument.
                //Udbus.Parsing.IDLArgumentTypeNameBuilderBase nameBuilder = new IDLMethodArgumentTypeNameBuilder(idlIntf, idlMethod, idlMethodArg);
                Udbus.Parsing.IDLArgumentTypeNameBuilderBase nameBuilder = new IDLArgumentTypeNameBuilder(idlIntf, methodName);
                ParamCodeTypeHolderMarshalBase paramtypeHolder = null;
                CodeParameterDeclarationExpression param = null;
                CodeTypeReference typerefParam = null;
                if (idlMethodArg.Direction == "out") // If output parameter
                {
                    if (condOut == null)
                    {
                        codebuilder.PrefixOutParams(ref condOut, ref condOutIter, idlMethodName, ref nOutArgCounter, ref throwargOutPrev);
                    }

                    CodeConditionStatement condVarResult;
                    codebuilder.MakeOutArgument(statements
                        , stmtsFinishResult
                        , idlMethodName
                        , codetypefactoryOut // Yeah I messed up the naming
                        , ref nOutArgCounter
                        , context
                        , ref throwargOutPrev
                        , idlMethodArg
                        , nameBuilder
                        , ref paramtypeHolder
                        , ref typerefParam
                        , out condVarResult
                    );

                    codebuilder.StoreCondIterator(ref condOut, ref condOutIter, condVarResult);

                } // Ends if output parameter
                else // Else not output parameter
                {
                    // Add signature for argument.
                    nInArgSigCounter = codebuilder.DeclareSignature(statements, nInArgSigCounter, idlMethodArg.Type);

                    CodeConditionStatement condVarResult;
                    codebuilder.MakeInArgument(codetypefactoryIn // Yeah I messed up the naming
                        //, method.Statements
                        , idlMethodName
                        , ref nInArgCounter
                        , context
                        , ref throwargInPrev
                        , idlMethodArg
                        , nameBuilder
                        , ref paramtypeHolder
                        , ref typerefParam
                        , out condVarResult
                    );

                    codebuilder.StoreCondIterator(ref condIn, ref condInIter, condVarResult);

                } // Ends else not output parameter

                param = codebuilder.AddParameter(parameters, idlMethodArg.Name, idlMethodArg.Direction, typerefParam);

            } // Ends loop over arguments

            codebuilder.AssignResults(statementsTryRecv, condOut, condOutIter, stmtsFinishResult, throwargOutPrev
                ,idlMethodName, ref nOutArgCounter
            );
            codebuilder.TerminateSignature(statements, bInParameters, nInArgSigCounter);
            codebuilder.AddSerialNumber(statements);
            codebuilder.InitialiseMessageBuilder(statements);
            codebuilder.DeclareMessageHandle(statements);

            CodeStatement stmtBuildMethod = codebuilder.InvokeBuild(statements, methodName);

            condIn = codebuilder.FinishInArguments(idlMethodName, codebuilder, condMethodSignature, condIn, condInIter, throwargInPrev);

            // Add a using statement ??? Nope. Add a try/finally statement. Ahhh CodeDOM is there no construct you can't mangle ?
            CodeVariableReferenceExpression varrefSendHandle = codebuilder.DeclareSendHandle();
            CodeStatementCollection statementsTrySend = new CodeStatementCollection();
#if !USE_FLUID_MESSAGE_BUILDER
            // Use individual statements to build message.
            statementsTrySend.Add(stmtBuildMethod);

            if (condIn != null)
            {
                statementsTrySend.Add(condIn);
            }
            else
            {
                // Need to set the signature even for methods with no parameters (?).
                //statementsTrySend.Add(condMethodSignature);
            }
#endif // !USE_FLUID_MESSAGE_BUILDER


            codebuilder.CallSend(idlMethodName, varrefSendHandle, statementsTrySend);

            codebuilder.TryCatchSend(statements, varrefSendHandle, statementsTrySend);

            List<CodeStatement> statementsReponse = new List<CodeStatement>();

            // Now receive the response.
            codebuilder.HandleResponse(idlMethodName, statementsTryRecv, statementsReponse);

            statements.Add(new CodeConditionStatement(exprResultOk,
                statementsReponse.ToArray()
            ));
        }