public static CodeTypeReference PropertyType(CodeTypeFactory codetypefactoryOut, string idlPropertyType) { Udbus.Parsing.ICodeTypeDeclarationHolder declarationHolderProperty = new Udbus.Parsing.CodeTypeNoOpHolder(); Udbus.Parsing.IDLArgumentTypeNameBuilderBase nameBuilder = new Udbus.Parsing.IDLArgumentTypeNameBuilderNoOp(); marshal.outward.ParamCodeTypeHolderProperty paramtypeHolder = new marshal.outward.ParamCodeTypeHolderProperty(codetypefactoryOut, FieldDirection.Out); Udbus.Parsing.BuildContext context = new Udbus.Parsing.BuildContext(declarationHolderProperty); Udbus.Parsing.CodeBuilderHelper.BuildCodeParamType(paramtypeHolder, nameBuilder, idlPropertyType, context); return(paramtypeHolder.paramtype.CodeType); }
public override void PreProcess() { DictCreatorFactory dictfactoryIn = new marshal.inward.DictCreatorMarshalInFactory(); DictCreatorFactory dictfactoryOut = new marshal.outward.DictCreatorMarshalOutFactory(); codetypefactoryOut = new CodeTypeFactory(new marshal.outward.StructCreatorMarshalOutFactory(), dictfactoryOut, dictfactoryOut); codetypefactoryIn = new CodeTypeFactory(new marshal.inward.StructCreatorMarshalInFactory(), dictfactoryIn, dictfactoryIn); stmtAssignConnectionParameters = new CodeAssignStatement(fieldrefConnectionParameters, CodeBuilderCommon.argrefConnectionParameters); fieldrefDefaultConnectionParams = new CodeFieldReferenceExpression(null, DefaultConnectionParametersName); stmtAssignServiceConnectionParameters = new CodeAssignStatement(CodeBuilderCommon.fieldrefServiceConnectionParameters, CodeBuilderCommon.argrefServiceConnectionParameters); declarationHolderCustomTypesNs = new Udbus.Parsing.CodeTypeDeferredNamespaceDeclarationHolder(CodeBuilderCommon.nsDbusMarshalCustom); // If utilised, this namespace is nested in service's namespace. declarationHolderDictionaryMarshalNs = new Udbus.Parsing.CodeTypeDeferredNamespaceDeclarationHolder(CodeBuilderCommon.nsDbusMarshalNested); declarationHolder = new Udbus.Parsing.CodeMemberDeferredClassHolder(declarationHolderCustomTypesNs , "Marshal" , declarationHolderDictionaryMarshalNs , CodeBuilderCommon.GetNameMarshalDictionary() ); }
protected ParamCodeTypeFactory(CodeTypeFactory codetypeFactory) : this(codetypeFactory, FieldDirection.In) { }
public StructCreatorFullName(CodeTypeFactory codetypeFactory, Udbus.Parsing.IParamCodeTypeHandler owner) : base(codetypeFactory, owner) { }
//public StructCreator(IParamCodeTypeHandler owner) public StructCreator(CodeTypeFactory codetypeFactory, Udbus.Parsing.IParamCodeTypeHandler owner) : base(owner) { this.codetypeFactory = codetypeFactory; }
public DictCreatorIn(CodeTypeFactory codetypeFactory) : base(codetypeFactory) { }
internal override Udbus.Parsing.IStructParamCodeTypeHandler CreateStructCreator(CodeTypeFactory codetypeFactory, Udbus.Parsing.IParamCodeTypeHandler owner) { return new StructCreatorFullName(codetypeFactory, owner); }
internal Udbus.Parsing.IStructParamCodeTypeHandler CreateStructCreator(CodeTypeFactory codetypeFactory, Udbus.Parsing.IParamCodeTypeHandler owner) { return(this.structCreatorFactory.CreateStructCreator(codetypeFactory, owner)); }
static public void PreMakeSignals(CodeTypeDeclaration typeMarshal, CodeTypeFactory codetypefactoryOut, CodeTypeFactory codetypefactoryIn, Udbus.Parsing.CodeMemberDeferredClassHolder declarationHolder, IDLInterface idlIntf ) { // * private void AddMatchInternal(string matchrule) CodeMemberMethod methodAddMatch = MakeMethod(codetypefactoryOut, codetypefactoryIn, declarationHolder, idlIntf, AddMatchInternal, new MarshalBuilderHelperSignalAddMatchMethod()); methodAddMatch.Name = AddMatchInternalName; // Change the name to prevent name collision. methodAddMatch.Attributes = MemberAttributes.Private; typeMarshal.Members.Add(methodAddMatch); // * protected void RegisterForSignal(string matchrule, Udbus.Core.SignalEntry signalEntry, params Udbus.Core.IRegisterSignalHandlers[] registers) // * { // * this.AddMatchInternal(matchrule); // * Udbus.Core.RegisterSignalHandlerFunctions.RegisterForSignal(signalEntry, registers); // * } CodeMemberMethod methodRegisterForSignal = new CodeMemberMethod(); methodRegisterForSignal.Name = RegisterForSignal; CodeParameterDeclarationExpression paramdeclRegisters = new CodeParameterDeclarationExpression(typerefIRegisterSignalHandlersArray, registers); paramdeclRegisters.CustomAttributes.Add(CodeBuilderCommon.attribParams); methodRegisterForSignal.Parameters.Add(paramdeclMatchRule); methodRegisterForSignal.Parameters.Add(paramdeclSignalEntry); methodRegisterForSignal.Parameters.Add(paramdeclRegisters); methodRegisterForSignal.Statements.Add(invokeAddMatchInternal); methodRegisterForSignal.Statements.Add(invokeRegisterForSignal); typeMarshal.Members.Add(methodRegisterForSignal); // * protected Udbus.Core.IRegisterSignalHandlers RegisterSignalHandlers { get { return this.serviceConnectionParameters.RegisterSignalHandlers; } } CodeMemberProperty propRegisterSignalHandlers = new CodeMemberProperty(); propRegisterSignalHandlers.Attributes = MemberAttributes.Private | MemberAttributes.Final; propRegisterSignalHandlers.Name = proprefRegisterSignalHandlers.PropertyName; propRegisterSignalHandlers.Type = typerefIRegisterSignalHandlers; propRegisterSignalHandlers.GetStatements.Add(returnServiceParamsRegisterSignalHandlers); typeMarshal.Members.Add(propRegisterSignalHandlers); // * private static object lockGlobalSignalHandlers = new object(); CodeMemberField fieldLockGlobalSignalHandlers = new CodeMemberField(typeof(object), "lockGlobalSignalHandlers"); fieldLockGlobalSignalHandlers.Attributes = MemberAttributes.Static | MemberAttributes.Private; fieldLockGlobalSignalHandlers.InitExpression = new CodeObjectCreateExpression(fieldLockGlobalSignalHandlers.Type); typeMarshal.Members.Add(fieldLockGlobalSignalHandlers); // * private static System.Collections.Generic.Dictionary<Udbus.Serialization.DbusConnectionParameters, <interface>Service> globalSignalHandlers = new System.Collections.Generic.Dictionary<Udbus.Serialization.DbusConnectionParameters, <interface>Service); CodeTypeReference typerefGlobalSignalHandlers = new CodeTypeReference(typeof(Dictionary<,>)); CodeTypeReference typerefMarshal = new CodeTypeReference(typeMarshal.Name); typerefGlobalSignalHandlers.TypeArguments.Add(CodeBuilderCommon.typerefConnectionParameters); typerefGlobalSignalHandlers.TypeArguments.Add(typerefMarshal); CodeMemberField fieldGlobalSignalHandlers = new CodeMemberField(typerefGlobalSignalHandlers, "globalSignalHandlers"); fieldGlobalSignalHandlers.Attributes = MemberAttributes.Static | MemberAttributes.Private; fieldGlobalSignalHandlers.InitExpression = new CodeObjectCreateExpression(fieldGlobalSignalHandlers.Type); typeMarshal.Members.Add(fieldGlobalSignalHandlers); CodeMemberMethod methodGetSignalHandler = new CodeMemberMethod(); methodGetSignalHandler.Name = GetSignalHandler; methodGetSignalHandler.Attributes = MemberAttributes.Private; methodGetSignalHandler.ReturnType = typerefMarshal; CodeVariableReferenceExpression varrefLocalSignalHandler = new CodeVariableReferenceExpression("localSignalHandler"); CodeVariableReferenceExpression varrefLookupSignalHandler = new CodeVariableReferenceExpression("lookupSignalHandler"); CodeFieldReferenceExpression fieldrefLockGlobalSignalHandlers = new CodeFieldReferenceExpression(null, fieldLockGlobalSignalHandlers.Name); CodeFieldReferenceExpression fieldrefGlobalSignalHandlers = new CodeFieldReferenceExpression(null, fieldGlobalSignalHandlers.Name); methodGetSignalHandler.Statements.Add(new CodeVariableDeclarationStatement(typerefMarshal, varrefLocalSignalHandler.VariableName, new CodePrimitiveExpression(null))); methodGetSignalHandler.Statements.Add(new CodeVariableDeclarationStatement(typerefMarshal, varrefLookupSignalHandler.VariableName)); CodeTypeReferenceExpression typerefexprMonitor = new CodeTypeReferenceExpression(typeof(System.Threading.Monitor)); // * System.Threading.Monitor.Enter(lockGlobalSignalHandlers); methodGetSignalHandler.Statements.Add(new CodeExpressionStatement(new CodeMethodInvokeExpression(typerefexprMonitor, "Enter", fieldrefLockGlobalSignalHandlers))); methodGetSignalHandler.Statements.Add(new CodeTryCatchFinallyStatement( new CodeStatement[] // * try { { // * if (globalSignalHandlers.TryGetValue(this.ConnectionParameters, out lookupSignalHandler) == false) // * { new CodeConditionStatement(new CodeBinaryOperatorExpression(new CodeMethodInvokeExpression(fieldrefGlobalSignalHandlers, "TryGetValue" , proprefConnectionParameters, new CodeDirectionExpression(FieldDirection.Out, varrefLookupSignalHandler) ) , CodeBinaryOperatorType.IdentityEquality , new CodePrimitiveExpression(false) ) , new CodeStatement[] { // * globalSignalHandlers[this.ConnectionParameters] = this; new CodeAssignStatement(new CodeIndexerExpression(fieldrefGlobalSignalHandlers, proprefConnectionParameters), new CodeThisReferenceExpression()) } , new CodeStatement[] // else { // * localSignalHandler = lookupSignalHandler; new CodeAssignStatement(varrefLocalSignalHandler, varrefLookupSignalHandler) } // * } ) } ,new CodeCatchClause[]{} // * } catch { ,new CodeStatement[] // * } finally { { // * System.Threading.Monitor.Exit(lockGlobalSignalHandlers); new CodeExpressionStatement(new CodeMethodInvokeExpression(typerefexprMonitor, "Exit", fieldrefLockGlobalSignalHandlers)) } // * } )); // * if (localSignalHandler == null) methodGetSignalHandler.Statements.Add(new CodeConditionStatement(new CodeBinaryOperatorExpression(varrefLocalSignalHandler, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null)) // * localSignalHandler = this; , new CodeAssignStatement(varrefLocalSignalHandler, new CodeThisReferenceExpression()) )); // * return localSignalHandler; methodGetSignalHandler.Statements.Add(new CodeMethodReturnStatement(varrefLocalSignalHandler)); typeMarshal.Members.Add(methodGetSignalHandler); }
static public CodeMemberMethod MakeSignal(CodeNamespace ns, CodeTypeDeclaration typeMarshal, CodeTypeFactory codetypefactoryOut, Udbus.Parsing.CodeMemberDeferredClassHolder declarationHolder, IDLInterface idlIntf, IDLSignal idlMethod) { return MakeSignal(ns, typeMarshal, codetypefactoryOut, declarationHolder, idlIntf, idlMethod, new MarshalBuilderHelperSignal()); }
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; }
private static CodeMemberProperty MakePropertySet(CodeMemberProperty property, CodeTypeFactory codetypefactoryOut, CodeTypeFactory codetypefactoryIn, Udbus.Parsing.CodeMemberDeferredClassHolder declarationHolder, IDLInterface idlIntf, IDLProperty idlProperty, Udbus.Parsing.BuildContext context) { return MakePropertySet(property, codetypefactoryOut, codetypefactoryIn, declarationHolder, idlIntf, idlProperty, context, new MarshalBuilderHelperProperty()); }
private static void MakeProperty(CodeTypeFactory codetypefactoryOut, CodeTypeFactory codetypefactoryIn, Udbus.Parsing.CodeMemberDeferredClassHolder declarationHolder, IDLInterface idlIntf, CodeTypeDeclaration typeMarshal, IDLProperty idlProperty, bool hasGet, bool hasSet, Udbus.Parsing.BuildContext context) { CodeMemberProperty property = new CodeMemberProperty(); property.Attributes = MemberAttributes.Public | MemberAttributes.Final; property.Name = CodeBuilderCommon.GetCompilableName(idlProperty.Name); property.HasGet = hasGet; property.HasSet = hasSet; property.Comments.Add(new CodeCommentStatement(string.Format("{0} {1} \"{2}\"", idlProperty.Access, idlProperty.Name, idlProperty.Type))); // Parse the type string for the argument, creating required structs as we go, and returning a type for the argument. // We use the out factory because its out types we have to return and they tend to be less forgiving than in types. property.Type = CodeBuilderCommon.PropertyType(codetypefactoryOut, idlProperty.Type); if (hasGet) // If gettable property { MakePropertyGet(property, codetypefactoryOut, codetypefactoryIn, declarationHolder, idlIntf, idlProperty, context); } // Ends if gettable property if (hasSet) // If settable property { MakePropertySet(property, codetypefactoryOut, codetypefactoryIn, declarationHolder, idlIntf, idlProperty, context); } // Ends if settable property typeMarshal.Members.Add(property); }
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; }
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())); }
internal virtual Udbus.Parsing.IStructParamCodeTypeHandler CreateStructCreator(CodeTypeFactory codetypeFactory, Udbus.Parsing.IParamCodeTypeHandler owner) { return(new StructCreator(codetypeFactory, owner)); }
static public CodeMemberMethod MakeMethod(CodeTypeFactory codetypefactoryOut, CodeTypeFactory codetypefactoryIn, Udbus.Parsing.CodeMemberDeferredClassHolder declarationHolder, IDLInterface idlIntf, IDLMethod idlMethod) { return MakeMethod(codetypefactoryOut, codetypefactoryIn, declarationHolder, idlIntf, idlMethod, new MarshalBuilderHelperMethod()); }
public override void GenerateProperties(IDLInterface idlIntf) { // Properties. if (idlIntf.Properties != null && idlIntf.Properties.Count > 0) // If got properties { int firstPropertyIndex = type.Members.Count - 1; Udbus.Parsing.BuildContext context = new Udbus.Parsing.BuildContext(declarationHolder); DictCreatorFactory dictfactoryPropertyOut = new marshal.outward.DictCreatorMarshalOutPropertyFactory(); CodeTypeFactory codetypefactoryPropertyOut = new CodeTypeFactory(new marshal.outward.StructCreatorMarshalOutFactory(), dictfactoryPropertyOut, dictfactoryPropertyOut); foreach (IDLProperty idlProperty in idlIntf.Properties) { bool hasGet = CodeBuilderCommon.HasGet(idlProperty); bool hasSet = CodeBuilderCommon.HasSet(idlProperty); if (!hasGet && !hasSet) { continue; } MakeProperty(codetypefactoryPropertyOut, codetypefactoryIn, declarationHolder, idlIntf, type, idlProperty, hasGet, hasSet, context); } // Ends loop over properties } // Ends if got properties }
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; }
internal Udbus.Parsing.IStructParamCodeTypeHandler CreateStructCreator(CodeTypeFactory codetypeFactory, Udbus.Parsing.IParamCodeTypeHandler owner) { return this.structCreatorFactory.CreateStructCreator(codetypeFactory, owner); }
public DictCreatorOutProperty(CodeTypeFactory codetypeFactory) : base(codetypeFactory) { }
public DictCreator(CodeTypeFactory codetypeFactory) { this.codetypeFactory = codetypeFactory; }
internal FieldHandler(CodeTypeFactory codetypeFactory, Udbus.Parsing.StructCreatorBase owner) : base(codetypeFactory) { this.owner = owner; }
public ParamCodeTypeFactory(CodeTypeFactory codetypeFactory, FieldDirection fieldDirection) : base(fieldDirection) { this.codetypeFactory = codetypeFactory; }
public ArrayParamCodeTypeHolder(Udbus.Parsing.IParamCodeTypeHandler owner, CodeTypeFactory codetypeFactory, FieldDirection fieldDirection) : base(codetypeFactory, fieldDirection) { this.owner = owner; }
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 ParamCodeTypeHolderMarshalBase(CodeTypeFactory codetypeFactory, FieldDirection fieldDirection) : base(codetypeFactory, fieldDirection) { }
internal override Udbus.Parsing.IStructParamCodeTypeHandler CreateStructCreator(CodeTypeFactory codetypeFactory, Udbus.Parsing.IParamCodeTypeHandler owner) { return(new StructCreatorFullName(codetypeFactory, owner)); }
internal virtual Udbus.Parsing.IStructParamCodeTypeHandler CreateStructCreator(CodeTypeFactory codetypeFactory, Udbus.Parsing.IParamCodeTypeHandler owner) { return new StructCreator(codetypeFactory, owner); }
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() )); }