public void AddRange() { CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression(); CodeParameterDeclarationExpression param2 = new CodeParameterDeclarationExpression(); CodeParameterDeclarationExpression param3 = new CodeParameterDeclarationExpression(); CodeParameterDeclarationExpressionCollection coll1 = new CodeParameterDeclarationExpressionCollection(); coll1.Add(param1); coll1.Add(param2); CodeParameterDeclarationExpressionCollection coll2 = new CodeParameterDeclarationExpressionCollection(); coll2.Add(param3); coll2.AddRange(coll1); Assert.AreEqual(3, coll2.Count, "#1"); Assert.AreEqual(1, coll2.IndexOf(param1), "#2"); Assert.AreEqual(2, coll2.IndexOf(param2), "#3"); Assert.AreEqual(0, coll2.IndexOf(param3), "#4"); CodeParameterDeclarationExpressionCollection coll3 = new CodeParameterDeclarationExpressionCollection(); coll3.Add(param3); coll3.AddRange(new CodeParameterDeclarationExpression[] { param1, param2 }); Assert.AreEqual(3, coll2.Count, "#5"); Assert.AreEqual(1, coll2.IndexOf(param1), "#6"); Assert.AreEqual(2, coll2.IndexOf(param2), "#7"); Assert.AreEqual(0, coll2.IndexOf(param3), "#8"); }
public DynaArgumentCollection(DynaArgument[] args) : this() { foreach (DynaArgument arg in args) { codeArgs.Add(arg.CodeArgument); } }
public CodeParameterDeclarationExpressionCollection GenerateOnEventMethodInputParameters(TibcoBWProcess tibcoBwProcessToGenerate) { var parameters = new CodeParameterDeclarationExpressionCollection(); parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(CSharpTypeConstant.SystemObject), "sender")); parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.EventArgs"), "args")); return(parameters); }
private CodeParameterDeclarationExpressionCollection GenerateParametters(List <GameDataVariable> variables) { CodeParameterDeclarationExpressionCollection retVal = new CodeParameterDeclarationExpressionCollection(); retVal.Add(new CodeParameterDeclarationExpression(typeof(string), "I18nFile")); foreach (var v in variables) { retVal.Add(GetParametter(v)); } return(retVal); }
public void Add() { CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression(); CodeParameterDeclarationExpression param2 = new CodeParameterDeclarationExpression(); CodeParameterDeclarationExpressionCollection coll = new CodeParameterDeclarationExpressionCollection(); Assert.AreEqual(0, coll.Add(param1), "#1"); Assert.AreEqual(1, coll.Count, "#2"); Assert.AreEqual(0, coll.IndexOf(param1), "#3"); Assert.AreEqual(1, coll.Add(param2), "#4"); Assert.AreEqual(2, coll.Count, "#5"); Assert.AreEqual(1, coll.IndexOf(param2), "#6"); }
/// <summary> /// Generates a CodeParameterDeclarationExpresseionCollection from a semicolon separated string of /// comma delimited type-name value pair argument strings. /// </summary> /// <param name="paramDeclArgs"></param> /// <returns></returns> private static CodeParameterDeclarationExpressionCollection GetCodeParameterDeclaraionExpressions(string paramDeclsArgs) { CodeParameterDeclarationExpressionCollection parameters = null; if (paramDeclsArgs != "null") { parameters = new CodeParameterDeclarationExpressionCollection(); string[] paramDecls = paramDeclsArgs.Split(new char[] { ';' }); foreach (string paramDecl in paramDecls) { if (paramDecl != "") { string[] args = paramDecl.Split(new char[] { ',' }); Assert.AreEqual(args.Length, 2, "Params definition file not in the correct format!"); CodeParameterDeclarationExpression codeParam = new CodeParameterDeclarationExpression(args[0], args[1]); parameters.Add(codeParam); } // else Note: setting an empty CodeParamDeclExp creates a 'void' param (we don't do this for code gen) // codeParam = new CodeParameterDeclarationExpression(); } } return(parameters); }
public CodeParameterDeclarationExpressionCollection AddParameters(CodeParameterDeclarationExpressionCollection collection, params object[] paramNameValue) { int j = paramNameValue.GetLength(0); if (j % 2 == 1) { j--; } CodeTypeReference name; string val; for (int i = 0; i < j; i += 2) { name = NewType(paramNameValue[i]); if (paramNameValue[i + 1].GetType() == typeof(ArgRef)) { //val = ((ArgRef)paramNameValue[i+1]).ParameterName; val = ((ArgRef)paramNameValue[i + 1]); } else { val = paramNameValue[i + 1].ToString(); } collection.Add(new CodeParameterDeclarationExpression(name, val)); } return(collection); }
public static void Add(this CodeParameterDeclarationExpressionCollection collection, IEnumerable <ColumnInfo> columns) { foreach (var item in columns) { collection.Add(new CodeParameterDeclarationExpression(item.GetCodeType(), item.Name)); } }
public void Constructor2() { CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression(); CodeParameterDeclarationExpression param2 = new CodeParameterDeclarationExpression(); CodeParameterDeclarationExpressionCollection c = new CodeParameterDeclarationExpressionCollection(); c.Add(param1); c.Add(param2); CodeParameterDeclarationExpressionCollection coll = new CodeParameterDeclarationExpressionCollection(c); Assert.AreEqual(2, coll.Count, "#1"); Assert.AreEqual(0, coll.IndexOf(param1), "#2"); Assert.AreEqual(1, coll.IndexOf(param2), "#3"); }
private CodeParameterDeclarationExpressionCollection GenerateParameters(NativeSignature ntSig, ref string comments) { ThrowIfNull(ntSig); if (comments == null) { comments = string.Empty; } CodeParameterDeclarationExpressionCollection col = new CodeParameterDeclarationExpressionCollection(); Int32 count = 0; foreach (NativeParameter ntParam in ntSig.Parameters) { string comment = null; CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(); param.Name = ntParam.Name; param.Type = GenerateTypeReferenceImpl(ntParam.NativeType, ref comment); param.UserData[TransformConstants.Param] = ntParam; col.Add(param); if (string.IsNullOrEmpty(param.Name)) { param.Name = "param" + count; } // Add the type comment to the procedure comments += Environment.NewLine; comments += param.Name + ": " + comment; count += 1; } return(col); }
static void populateParmList(CodeParameterDeclarationExpressionCollection parms, CodeTypeDelegate ctdDel) { foreach (CodeParameterDeclarationExpression cpde in ctdDel.Parameters) { parms.Add(cpde); } }
internal override void AddToConstructor(CodeConstructor functionalConstructor) { if (!this.IsList) { functionalConstructor.Parameters.Add(new CodeParameterDeclarationExpression(this.ReturnType, this.propertyName)); if (!this.FromBaseType) { functionalConstructor.Statements.Add(new CodeAssignStatement(CodeDomHelper.CreateFieldReference("this", this.propertyName), new CodeVariableReferenceExpression(this.propertyName))); } else { functionalConstructor.BaseConstructorArgs.Add(new CodeVariableReferenceExpression(this.propertyName)); } } else { CodeParameterDeclarationExpressionCollection parameters = functionalConstructor.Parameters; CodeTypeReference[] codeTypeReference = new CodeTypeReference[] { new CodeTypeReference(this.clrTypeName) }; parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("IEnumerable", codeTypeReference), this.propertyName)); if (!this.FromBaseType) { CodeTypeReference listType = this.GetListType(); functionalConstructor.Statements.Add(new CodeAssignStatement(CodeDomHelper.CreateFieldReference("this", NameGenerator.ChangeClrName(this.propertyName, NameOptions.MakeField)), new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(listType), "Initialize", this.GetListParameters(true, true)))); } else { functionalConstructor.BaseConstructorArgs.Add(new CodeVariableReferenceExpression(this.propertyName)); } } }
protected CodeParameterDeclarationExpressionCollection GetParametersList(XSharpParser.ParameterListContext paramList) { CodeParameterDeclarationExpressionCollection pList = new CodeParameterDeclarationExpressionCollection(); // if (paramList != null) { foreach (var param in paramList._Params) { CodeParameterDeclarationExpression pm = new CodeParameterDeclarationExpression(); pm.Name = param.Id.GetText(); pm.Type = BuildDataType(param.Type); pm.Direction = FieldDirection.In; if (param.Modifiers != null) { if (param.Modifiers.REF() != null) { pm.Direction = FieldDirection.Ref; } else if (param.Modifiers.OUT() != null) { pm.Direction = FieldDirection.Out; } } // pList.Add(pm); } } // return(pList); }
public void Remove() { CodeParameterDeclarationExpression cpde1 = new CodeParameterDeclarationExpression(); CodeParameterDeclarationExpression cpde2 = new CodeParameterDeclarationExpression(); CodeParameterDeclarationExpressionCollection coll = new CodeParameterDeclarationExpressionCollection(); coll.Add(cpde1); coll.Add(cpde2); Assert.AreEqual(2, coll.Count, "#1"); Assert.AreEqual(0, coll.IndexOf(cpde1), "#2"); Assert.AreEqual(1, coll.IndexOf(cpde2), "#3"); coll.Remove(cpde1); Assert.AreEqual(1, coll.Count, "#4"); Assert.AreEqual(-1, coll.IndexOf(cpde1), "#5"); Assert.AreEqual(0, coll.IndexOf(cpde2), "#6"); }
public void CloneParameters(CodeParameterDeclarationExpressionCollection source, CodeParameterDeclarationExpressionCollection dest) { dest.Clear(); foreach (CodeParam param in source) { dest.Add(CloneParam(param)); } }
public void AddRange_Self() { CodeParameterDeclarationExpressionCollection coll = new CodeParameterDeclarationExpressionCollection(); coll.Add(new CodeParameterDeclarationExpression()); Assert.AreEqual(1, coll.Count, "#1"); coll.AddRange(coll); Assert.AreEqual(2, coll.Count, "#2"); }
public CodeParameterDeclarationExpressionCollection GenerateMethodsParameters() { var sqlQuery = new CodeParameterDeclarationExpression(CSharpTypeConstant.SystemString, "query"); var sqlQueryParameter = new CodeParameterDeclarationExpression() { Type = new CodeTypeReference(CSharpTypeConstant.SystemObject), Name = "paramater = null", // TODO : find a way to do it properly // CustomAttributes = new CodeAttributeDeclarationCollection { // new CodeAttributeDeclaration ("Optional") // } }; var parameters = new CodeParameterDeclarationExpressionCollection(); parameters.Add(sqlQuery); parameters.Add(sqlQueryParameter); return(parameters); }
private void addParamToDeclaration(EventType evt, ParameterType param, CodeParameterDeclarationExpressionCollection targetCollection) { //todo add param to the collection setParamName(evt, param); CodeParameterDeclarationExpression _type = new CodeParameterDeclarationExpression(GetTypeReference(param.type), param.name); targetCollection.Add(_type); }
// CodeParameterDeclarationExpressionCollection helpers // -- this one is possibly dangerous? public static CodeParameterDeclarationExpressionCollection CreateParameterList(params object[] parameters) { // must have an even number of arguments for // a list of pairs to be valid if (parameters.Length % 2 != 0) { throw new ArgumentException("Must supply an even number of arguments."); } CodeParameterDeclarationExpressionCollection exps = new CodeParameterDeclarationExpressionCollection(); for (Int32 i = 0; i < parameters.Length; i += 2) { if (!typeof(string).IsInstanceOfType(parameters[i + 1])) { throw new ArgumentException(String.Format(CultureInfo.InvariantCulture, "Argument {0} should be of type string.", i + 1)); } if (typeof(Type).IsInstanceOfType(parameters[i])) { exps.Add(new CodeParameterDeclarationExpression( (Type)parameters[i], (string)parameters[i + 1])); } else if (typeof(string).IsInstanceOfType(parameters[i])) { exps.Add(new CodeParameterDeclarationExpression( (string)parameters[i], (string)parameters[i + 1])); } else if (typeof(CodeTypeReference).IsInstanceOfType(parameters[i])) { exps.Add(new CodeParameterDeclarationExpression( (CodeTypeReference)parameters[i], (string)parameters[i + 1])); } else { throw new ArgumentException(String.Format(CultureInfo.InvariantCulture, "Argument {0} should be of Type, string, or CodeTypeReference.", i)); } } return(exps); }
static void PopulateMethodParameters(IMethodSignature member, CodeParameterDeclarationExpressionCollection parameters, HashSet <string> excludeAttributes, bool isExtension = false) { foreach (var parameter in member.Parameters) { FieldDirection direction = 0; if (parameter.IsOut) { direction |= FieldDirection.Out; } else if (parameter.ParameterType.IsByReference) { direction |= FieldDirection.Ref; } var parameterType = parameter.ParameterType; if (parameterType is RequiredModifierType requiredModifierType) { parameterType = requiredModifierType.ElementType; } // order is crucial because a RequiredModifierType can be a ByReferenceType if (parameterType is ByReferenceType byReferenceType) { parameterType = byReferenceType.ElementType; } var type = CreateCodeTypeReference(parameterType); if (isExtension) { type = ModifyCodeTypeReference(type, "this"); isExtension = false; } // special case of ref is in // TODO: Move CustomAttributes.Any(a => a.AttributeType.FullName == "System.Runtime.CompilerServices.IsReadOnlyAttribute") to extension method once other PR is merged if (parameter.CustomAttributes.Any(a => a.AttributeType.FullName == "System.Runtime.CompilerServices.IsReadOnlyAttribute")) { type = ModifyCodeTypeReference(type, "in"); direction = FieldDirection.In; } var name = parameter.HasConstant ? string.Format(CultureInfo.InvariantCulture, "{0} = {1}", parameter.Name, FormatParameterConstant(parameter)) : parameter.Name; var expression = new CodeParameterDeclarationExpression(type, name) { Direction = direction, CustomAttributes = CreateCustomAttributes(parameter, excludeAttributes) }; parameters.Add(expression); } }
/// <summary> /// Adds a method invoke expression and a partial method definition based on the specified base method name /// to the internal method collection. /// </summary> /// <param name="baseMethodName">base method name w/o the On prefix (like Created for OnCreated)</param> /// <param name="parameterDeclaration">parameter declaration for the only param of the method to be generated</param> /// <param name="comments">the comments for the partial property definition</param> public void AddMethodFor(string baseMethodName, CodeParameterDeclarationExpression parameterDeclaration, string comments) { CodeParameterDeclarationExpressionCollection parameters = new CodeParameterDeclarationExpressionCollection(); if (parameterDeclaration != null) { parameters.Add(parameterDeclaration); } this.AddMethodFor(baseMethodName, parameters, comments); }
public CodeNamespace Build() { var namespaceResult = new CodeNamespace(TargetAppNameSpaceService.loggerNameSpace()); namespaceResult.Imports.Add(new CodeNamespaceImport("System")); var dataAccessInterface = new CodeTypeDeclaration(); dataAccessInterface.Name = "ILogger"; dataAccessInterface.IsInterface = true; var message = new CodeParameterDeclarationExpression("System.String", "message"); var parameters = new CodeParameterDeclarationExpressionCollection(); parameters.Add(message); var voidReturnType = new CodeTypeReference(CSharpTypeConstant.SystemVoid); var debugMethod = new CodeMemberMethod { Name = "Debug", ReturnType = voidReturnType }; debugMethod.Parameters.AddRange(parameters); dataAccessInterface.Members.Add(debugMethod); var infoMethod = new CodeMemberMethod { Name = "Info", ReturnType = voidReturnType }; infoMethod.Parameters.AddRange(parameters); dataAccessInterface.Members.Add(infoMethod); var errorMethod = new CodeMemberMethod { Name = "Error", ReturnType = voidReturnType }; errorMethod.Parameters.AddRange(parameters); dataAccessInterface.Members.Add(errorMethod); var warnMethod = new CodeMemberMethod { Name = "Warning", ReturnType = voidReturnType }; warnMethod.Parameters.AddRange(parameters); dataAccessInterface.Members.Add(warnMethod); namespaceResult.Types.Add(dataAccessInterface); return(namespaceResult); }
public void Constructor1_Deny_Unrestricted() { CodeParameterDeclarationExpressionCollection coll = new CodeParameterDeclarationExpressionCollection(array); coll.CopyTo(array, 0); Assert.AreEqual(1, coll.Add(cpde), "Add"); Assert.AreSame(cpde, coll[0], "this[int]"); coll.AddRange(array); coll.AddRange(coll); Assert.IsTrue(coll.Contains(cpde), "Contains"); Assert.AreEqual(0, coll.IndexOf(cpde), "IndexOf"); coll.Insert(0, cpde); coll.Remove(cpde); }
public static CodeParameterDeclarationExpressionCollection Clone(this CodeParameterDeclarationExpressionCollection collection) { if (collection == null) { return(null); } CodeParameterDeclarationExpressionCollection c = new CodeParameterDeclarationExpressionCollection(); foreach (CodeParameterDeclarationExpression expression in collection) { c.Add(expression.Clone()); } return(c); }
/// <summary> /// Generate the method and add to code compile unit /// </summary> /// <param name="component"></param> /// <param name="e"></param> /// <param name="methodName"></param> /// <param name="addMethod"></param> private void Generate(IComponent component, EventDescriptor e, string methodName, bool addMethod) { TypeProvider typeProvider = (TypeProvider)this.serviceProvider.GetService(typeof(ITypeProvider)); CodeCompileUnit ccu = this.loader.CodeBesideCCU; Type delegateType = e.EventType; MethodInfo invokeInfo = delegateType.GetMethod("Invoke"); Type returnType = invokeInfo.ReturnType; MemberAttributes modifiers = MemberAttributes.Private; PropertyDescriptor modifiersProp = TypeDescriptor.GetProperties(component)["DefaultEventModifiers"]; if (modifiersProp != null && modifiersProp.PropertyType == typeof(MemberAttributes)) { modifiers = (MemberAttributes)modifiersProp.GetValue(component); } CodeParameterDeclarationExpressionCollection paramCollection = new CodeParameterDeclarationExpressionCollection(); foreach (ParameterInfo paramInfo in invokeInfo.GetParameters()) { CodeParameterDeclarationExpression codeParamExpression = new CodeParameterDeclarationExpression(); codeParamExpression.Name = paramInfo.Name; codeParamExpression.Type = new CodeTypeReference(paramInfo.ParameterType); paramCollection.Add(codeParamExpression); } // create code member method CodeMemberMethod method = new CodeMemberMethod(); method.Name = methodName; method.Parameters.AddRange(paramCollection); method.ReturnType = new CodeTypeReference(returnType); method.Attributes = modifiers; if (addMethod) { // The assumption here is that we have only one namespace and type being designed ccu.Namespaces[0].Types[0].Members.Add(method); } else { ccu.Namespaces[0].Types[0].Members.Remove(method); } typeProvider.RefreshCodeCompileUnit(this.loader.CodeBesideCCU, new EventHandler(RefreshCCU)); }
private void RemoveDuplicateParameters(CodeParameterDeclarationExpressionCollection parameters) { var toKeep = parameters .Cast <CodeParameterDeclarationExpression>() .GroupBy(x => new { x.Name }) .SelectMany(x => x.Take(1)) .ToArray(); parameters.Clear(); foreach (var objToKeep in toKeep) { parameters.Add(objToKeep); } }
//public static T ParamRef<T>(string name) //{ // return default(T); //} internal static T GetMethodName <T>(LambdaExpression exp, CodeParameterDeclarationExpressionCollection pars) { foreach (var p in exp.Parameters) { var par = new CodeParameterDeclarationExpression(p.Type, p.Name); if (typeof(IRefParam).IsAssignableFrom(p.Type)) { par.Direction = FieldDirection.Ref; } if (typeof(IOutParam).IsAssignableFrom(p.Type)) { par.Direction = FieldDirection.Out; } if (typeof(IParamArray).IsAssignableFrom(p.Type)) { par.CustomAttributes.Add(Define.Attribute(typeof(ParamArrayAttribute))); } if (p.Type.IsGenericType && ( p.Type.GetGenericTypeDefinition() == typeof(RefParam <>) || p.Type.GetGenericTypeDefinition() == typeof(OutParam <>) || p.Type.GetGenericTypeDefinition() == typeof(ParamArray <>)) ) { Type rt = p.Type.GetGenericArguments()[0]; if (p.Type.GetGenericTypeDefinition() == typeof(ParamArray <>) && !rt.IsArray) { par.Type = new CodeTypeReference(rt.ToString() + "[]"); } else { par.Type = new CodeTypeReference(rt); } } //if (typeof(IParamArray).IsAssignableFrom(p.Type)) // pars.Add() //else // pars.Add(par); pars.Add(par); } return(Eval <T>(exp, pars)); }
public CodeParameterDeclarationExpressionCollection GenerateStartMethodInputParameters(TibcoBWProcess tibcoBwProcessToGenerate) { var parameters = new CodeParameterDeclarationExpressionCollection(); if (tibcoBwProcessToGenerate.StartActivity != null && tibcoBwProcessToGenerate.StartActivity.Parameters != null) { foreach (var parameter in tibcoBwProcessToGenerate.StartActivity.Parameters) { parameters.Add(new CodeParameterDeclarationExpression { Name = "start_" + parameter.Name, Type = new CodeTypeReference(parameter.Type) }); } } return(parameters); }
public static CodeParameterDeclarationExpressionCollection ConvertQueryStatementParameter(Dictionary <string, string> queryStatementParameters) { var methodInputParameters = new CodeParameterDeclarationExpressionCollection(); if (queryStatementParameters == null) { return(methodInputParameters); } foreach (var queryParam in queryStatementParameters) { methodInputParameters.Add(new CodeParameterDeclarationExpression { Name = VariableHelper.ToVariableName(queryParam.Key), Type = ConvertSQLTypeToObjectType(queryParam.Value) }); } return(methodInputParameters); }
static void PopulateMethodParameters(IMethodSignature member, CodeParameterDeclarationExpressionCollection parameters, HashSet <string> excludeAttributes, bool isExtension = false) { foreach (var parameter in member.Parameters) { FieldDirection direction = 0; if (parameter.IsOut) { direction |= FieldDirection.Out; } else if (parameter.ParameterType.IsByReference) { direction |= FieldDirection.Ref; } var parameterType = parameter.ParameterType.IsByReference ? parameter.ParameterType.GetElementType() : parameter.ParameterType; var type = CreateCodeTypeReference(parameterType); if (isExtension) { type = ModifyCodeTypeReference(type, "this"); isExtension = false; } var name = parameter.HasConstant ? string.Format(CultureInfo.InvariantCulture, "{0} = {1}", parameter.Name, FormatParameterConstant(parameter)) : parameter.Name; var expression = new CodeParameterDeclarationExpression(type, name) { Direction = direction, CustomAttributes = CreateCustomAttributes(parameter, excludeAttributes) }; parameters.Add(expression); } }
public CodeMemberMethod GenerateBasicMethodDefinition(Smoke* smoke, Smoke.Method* method, string cppSignature, CodeTypeReference iface) { // do we actually want that method? string className = ByteArrayManager.GetString(smokeClass->className); string completeSignature = className + "::" + cppSignature; if (translator.ExcludedMethods.Any(regex => regex.IsMatch(completeSignature))) { return null; } CodeParameterDeclarationExpressionCollection args = new CodeParameterDeclarationExpressionCollection(); int count = 1; bool isRef; // make instance operators static and bring the arguments in the correct order string methName = ByteArrayManager.GetString(smoke->methodNames[method->name]); bool isOperator = false; string explicitConversionType = null; if (methName.StartsWith("operator")) { string op = methName.Substring(8); if (unsupportedOperators.Contains(op)) { // not supported Debug.Print(" |--Won't wrap method {0}::{1}", className, cppSignature); return null; } if (op == "<<") { methName = "Write"; } else if (op == ">>") { methName = "Read"; } // binary/unary operator if (binaryOperators.Contains(op) || unaryOperators.Contains(op)) { // instance operator if (smoke->classes[method->classId].size > 0) { if (op == "*" && method->numArgs == 0 || (op == "++" || op == "--") && method->numArgs == 1) { // dereference operator and postfix in-/decrement operator are not supported Debug.Print(" |--Won't wrap method {0}::{1}", className, cppSignature); return null; } try { CodeParameterDeclarationExpression exp = new CodeParameterDeclarationExpression(translator.CppToCSharp(className, type, out isRef), "one"); args.Add(exp); } catch (NotSupportedException) { Debug.Print(" |--Won't wrap method {0}::{1}", className, cppSignature); return null; } } else { // global operator if (op == "*" && method->numArgs == 0 || (op == "++" || op == "--") && method->numArgs == 2) { // dereference operator and postfix in-/decrement operator are not supported Debug.Print(" |--Won't wrap method {0}::{1}", className, cppSignature); return null; } } isOperator = true; } else if (op[0] == ' ') { // conversion operator explicitConversionType = op.Substring(1); if (explicitConversionType.Contains("QVariant")) { return null; } try { explicitConversionType = translator.CppToCSharp(explicitConversionType, type, out isRef).GetStringRepresentation(); if (smoke->classes[method->classId].size > 0) { CodeParameterDeclarationExpression exp = new CodeParameterDeclarationExpression(translator.CppToCSharp(className, type, out isRef), "value"); args.Add(exp); } } catch (NotSupportedException) { Debug.Print(" |--Won't wrap method {0}::{1}", className, cppSignature); return null; } isOperator = true; } } // translate return type CodeTypeReference returnType; try { returnType = translator.CppToCSharp(smoke->types + method->ret, type, out isRef); } catch (NotSupportedException) { Debug.Print(" |--Won't wrap method {0}::{1}", className, cppSignature); return null; } CodeMemberMethod cmm; if ((method->flags & (uint) Smoke.MethodFlags.mf_ctor) > 0) { cmm = new CodeConstructor(); cmm.Attributes = 0; // initialize to 0 so we can do |= ((CodeConstructor) cmm).ChainedConstructorArgs.Add(new CodeSnippetExpression("(System.Type) null")); } else { cmm = new CodeMemberMethod(); cmm.Attributes = 0; // initialize to 0 so we can do |= string csName = methName; if (!isOperator && methName != "finalize") { // capitalize the first letter StringBuilder builder = new StringBuilder(csName); builder[0] = char.ToUpper(builder[0]); string tmp = builder.ToString(); // If the new name clashes with a name of a type declaration, keep the lower-case name. var typesWithSameName = from member in data.GetAccessibleMembers(smokeClass) where member.Type == MemberTypes.NestedType && member.Name == tmp select member; var propertiesWithSameName = (from member in data.GetAccessibleMembers(smokeClass) where member.Type == MemberTypes.Property && member.Name == tmp select member).ToList(); if (iface != null && propertiesWithSameName.Count() == 1 && (method->flags & (uint) Smoke.MethodFlags.mf_protected) == 0 && (method->flags & (uint) Smoke.MethodFlags.mf_virtual) == 0) { cmm.PrivateImplementationType = iface; csName = tmp; } else { if (propertiesWithSameName.Any()) { if ((method->flags & (uint) Smoke.MethodFlags.mf_virtual) == 0) { Debug.Print( " |--Conflicting names: method/(type or property): {0} in class {1} - keeping original method name", tmp, className); } else { csName = tmp; } } else if (typesWithSameName.Any()) { Debug.Print(" |--Conflicting names: method/classname: {0} in class {1} - keeping original method name", tmp, className); } else { csName = tmp; } } } if (explicitConversionType != null) { cmm.Name = "explicit operator " + explicitConversionType; cmm.ReturnType = new CodeTypeReference(" "); } else { cmm.Name = csName; cmm.ReturnType = returnType; } } // translate arguments string[] methodArgs = this.GetMethodArgs(smoke, method); for (short* typeIndex = smoke->argumentList + method->args; *typeIndex > 0; typeIndex++) { try { args.Add(this.GetArgument(smoke, typeIndex, methodArgs, args, ref count)); } catch (NotSupportedException) { Debug.Print(" |--Won't wrap method {0}::{1}", className, cppSignature); return null; } } this.RemovePreviousOverload(args, cmm.Name); // for destructors we already have this stuff set if ((method->flags & (uint) Smoke.MethodFlags.mf_dtor) == 0) { // set access if ((method->flags & (uint) Smoke.MethodFlags.mf_protected) > 0) { cmm.Attributes |= MemberAttributes.Family; } else { cmm.Attributes |= MemberAttributes.Public; } if (isOperator) { cmm.Attributes |= MemberAttributes.Final | MemberAttributes.Static; } else if (cmm.Name == "ToString" && args.Count == 0 && cmm.ReturnType.BaseType == "System.String") { cmm.Attributes = MemberAttributes.Public | MemberAttributes.Override; } else { if ((method->flags & (uint) Smoke.MethodFlags.mf_static) > 0) { cmm.Attributes |= MemberAttributes.Static; } else { // virtual/final MemberAttributes access; bool foundInInterface; bool isOverride = MethodOverrides(smoke, method, out access, out foundInInterface); // methods that have to be implemented from interfaces can't override anything if (iface == null && isOverride) { cmm.Attributes = access | MemberAttributes.Override; } else if (foundInInterface) { cmm.Attributes = access; } if ((method->flags & (uint) Smoke.MethodFlags.mf_purevirtual) > 0) { if (!m_internalImplementation) { cmm.Attributes = (cmm.Attributes & ~MemberAttributes.ScopeMask) | MemberAttributes.Abstract; // The code generator doesn't like MemberAttributes.Abstract | MemberAttributes.Override being set. if (isOverride && !type.IsInterface) { cmm.ReturnType.BaseType = "override " + cmm.ReturnType.BaseType == "System.Void" ? "void" : cmm.ReturnType.BaseType; } } else { cmm.Attributes |= MemberAttributes.Override; } } if ((method->flags & (uint) Smoke.MethodFlags.mf_virtual) == 0 && (method->flags & (uint) Smoke.MethodFlags.mf_purevirtual) == 0 && !isOverride) { cmm.Attributes |= MemberAttributes.Final | MemberAttributes.New; } } } } else { // hack, so we don't have to use CodeSnippetTypeMember to generator the destructor cmm.ReturnType = new CodeTypeReference(" "); } // add the parameters foreach (CodeParameterDeclarationExpression exp in args) { cmm.Parameters.Add(exp); } this.DocumentMemberFromInterface(iface, cmm); this.DistributeMethod(cmm); if (PostMethodDefinitionHooks != null) { PostMethodDefinitionHooks(smoke, method, cmm, this.type); } this.CorrectParameterNames(cmm); return cmm; }