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() )); }