private void OutputParameters(CodeParameterDeclarationExpressionCollection parameters)
{
bool first = true;
bool multiline = parameters.Count > ParameterMultilineThreshold;
if (multiline)
{
Indent += 3;
}
IEnumerator en = parameters.GetEnumerator();
while (en.MoveNext())
{
CodeParameterDeclarationExpression current = (CodeParameterDeclarationExpression)en.Current;
if (!first)
{
output.Write(", ");
}
else
{
first = false;
}
if (multiline)
{
ContinueOnNewLine("");
}
GenerateExpression(current);
}
if (multiline)
{
Indent -= 3;
}
}
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 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);
}
private void Generate(CodeParameterDeclarationExpressionCollection parameters)
{
bool isFirst = true;
foreach (CodeParameterDeclarationExpression parameter in parameters)
{
if (!isFirst)
{
this.Write(", ");
}
else
{
isFirst = false;
}
this.WriteCustomAttributes(parameter.CustomAttributes, inLine: true);
switch (parameter.Direction)
{
case FieldDirection.Out:
this.Write("out ");
break;
case FieldDirection.Ref:
this.Write("ref ");
break;
}
this.Generate(parameter.Type);
this.Write(" ");
this.WriteName(parameter.Name);
}
}
static void populateParmList(CodeParameterDeclarationExpressionCollection parms, CodeTypeDelegate ctdDel)
{
foreach (CodeParameterDeclarationExpression cpde in ctdDel.Parameters)
{
parms.Add(cpde);
}
}
public static CodeDefaultProperty Property <T, T2, T3>(CodeTypeReference propertyType, MemberAttributes ma,
Expression <Func <T, T2, T3, string> > paramsAndName, bool indexer,
CodeStatement[] getStatements, params CodeStatement[] setStatements)
{
var c = new CodeMemberProperty
{
Attributes = ma,
Type = propertyType,
HasGet = true,
HasSet = true
};
if (getStatements != null)
{
c.GetStatements.AddRange(getStatements);
}
if (setStatements != null)
{
c.SetStatements.AddRange(setStatements);
}
CodeParameterDeclarationExpressionCollection parameters = new CodeParameterDeclarationExpressionCollection();
c.Name = CodeDom.GetMethodName <string>(paramsAndName, parameters);
return(new CodeDefaultProperty(c, parameters, indexer));
}
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));
}
}
}
private void ValidateParameters(CodeParameterDeclarationExpressionCollection parameters)
{
foreach (CodeParameterDeclarationExpression current in parameters)
{
ValidateParameterDeclarationExpression(current);
}
}
static CodeParameterDeclarationExpression[] _ToArray(CodeParameterDeclarationExpressionCollection refs)
{
var result = new CodeParameterDeclarationExpression[refs.Count];
refs.CopyTo(result, 0);
return(result);
}
// Output a list of parameters.
protected virtual void OutputParameters
(CodeParameterDeclarationExpressionCollection parameters)
{
bool splitLines = (parameters.Count >= 16);
bool first = true;
if (splitLines)
{
writer.Indent += 1;
}
foreach (CodeParameterDeclarationExpression expr in parameters)
{
if (!first)
{
Output.Write(", ");
if (splitLines)
{
ContinueOnNewLine("");
}
}
else
{
first = false;
}
GenerateParameterDeclarationExpression(expr);
}
if (splitLines)
{
writer.Indent -= 1;
}
}
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);
}
_ParamInfo[] _GetParamInfos(CodeParameterDeclarationExpressionCollection parms, CodeDomResolverScope scope = null)
{
var result = new _ParamInfo[parms.Count];
for (var i = 0; i < result.Length; i++)
{
_ParamInfo p = default(_ParamInfo);
p.IsOptional = false;
p.IsRetval = false;
p.Name = parms[i].Name;
p.DefaultValue = DBNull.Value;
var pd = parms[i];
switch (pd.Direction)
{
case FieldDirection.In:
break;
case FieldDirection.Out:
p.IsOut = true;
break;
case FieldDirection.Ref:
p.IsIn = p.IsOut = true;
break;
}
p.ParameterType = pd.Type;
if (null != scope)
{
p.ParameterType = _resolver.GetQualifiedType(pd.Type, scope);
}
result[i] = p;
}
return(result);
}
public static T Eval <T>(LambdaExpression le, CodeParameterDeclarationExpressionCollection pars)
{
List <object> o = new List <object>();
foreach (var e in le.Parameters)
{
o.Add(null);
}
foreach (var exp in new QueryVisitor((e) => (e is MethodCallExpression &&
(e as MethodCallExpression).Object is ParameterExpression &&
typeof(IDynType).IsAssignableFrom(((e as MethodCallExpression).Object as ParameterExpression).Type)))
.VisitMulti(le))
{
if (exp != null)
{
MethodCallExpression mc = (exp as MethodCallExpression);
ParameterExpression pe = mc.Object as ParameterExpression;
foreach (CodeParameterDeclarationExpression p in pars)
{
if (pe.Name == p.Name)
{
object t = Eval(mc.Arguments[0]);
p.Type = GetTypeReference(t);
}
}
}
}
return((T)le.Compile().DynamicInvoke(o.ToArray()));
}
/// <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 void GetMethodInvokeExpressionStatementForTest(bool isCSharp)
{
string comments = this.TestContext.DataRow["comments"].ToString();
string[] baseMethodNames = this.TestContext.DataRow["baseMethodNames"].ToString().Split(new char[] { ',' });
string paramDeclsArgs = this.TestContext.DataRow["parameters"].ToString();
NotificationMethodGenerator target = new NotificationMethodGenerator(CreateProxyGenerator(isCSharp));
CodeParameterDeclarationExpressionCollection expressions = GetCodeParameterDeclaraionExpressions(paramDeclsArgs);
CodeParameterDeclarationExpression[] parameters = new CodeParameterDeclarationExpression[expressions.Count];
expressions.CopyTo(parameters, 0);
foreach (string baseMethodName in baseMethodNames)
{
target.AddMethodFor(baseMethodName, expressions, comments);
CodeExpressionStatement actual = target.GetMethodInvokeExpressionStatementFor(baseMethodName);
CodeMethodInvokeExpression actualExpression = actual.Expression as CodeMethodInvokeExpression;
Assert.AreEqual(actualExpression.Method.MethodName, "On" + baseMethodName);
for (int idx = 0; idx < parameters.Length; idx++)
{
string paramName = ((CodeArgumentReferenceExpression)actualExpression.Parameters[idx]).ParameterName;
Assert.AreEqual(paramName, parameters[idx].Name);
}
}
}
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);
}
public static void Add(this CodeParameterDeclarationExpressionCollection collection, IEnumerable <ColumnInfo> columns)
{
foreach (var item in columns)
{
collection.Add(new CodeParameterDeclarationExpression(item.GetCodeType(), item.Name));
}
}
private CodeMemberMethod CreateMethodOverride(string methodName, CodeParameterDeclarationExpressionCollection declarationExpressionCollection, CodeTypeReference returnType, CodeMethodReturnStatement returnStatement)
{
CodeMemberMethod codeMemberMethod = CreateMethod(methodName, declarationExpressionCollection, returnType, returnStatement);
codeMemberMethod.Attributes = MemberAttributes.Public | MemberAttributes.Override;
return(codeMemberMethod);
}
private static void AdjustParameters(int fromLine, int lines, int chars, CodeParameterDeclarationExpressionCollection parameters)
{
foreach (CodeParameterDeclarationExpression param in parameters)
{
DoOneAdjust(fromLine, lines, chars, param);
}
}
protected virtual void OutputParameters(CodeParameterDeclarationExpressionCollection parameters)
{
bool first = true;
bool multiline = parameters.Count > ParameterMultilineThreshold;
if (multiline)
{
Indent += 3;
}
foreach (CodeParameterDeclarationExpression current in parameters)
{
if (first)
{
first = false;
}
else
{
Output.Write(", ");
}
if (multiline)
{
ContinueOnNewLine("");
}
GenerateExpression(current);
}
if (multiline)
{
Indent -= 3;
}
}
public static CodeMemberMethod Add(this CodeMemberMethod Method, CodeParameterDeclarationExpressionCollection Parameters)
{
foreach (CodeParameterDeclarationExpression Parameter in Parameters)
{
Method.Parameters.Add(Parameter);
}
return(Method);
}
public CodeDefaultProperty(CodeMemberProperty property,
CodeParameterDeclarationExpressionCollection parameters,
bool isDefault)
{
Parameters = parameters;
IsDefault = isDefault;
_property = property;
}
public void CloneParameters(CodeParameterDeclarationExpressionCollection source, CodeParameterDeclarationExpressionCollection dest)
{
dest.Clear();
foreach (CodeParam param in source)
{
dest.Add(CloneParam(param));
}
}
private void RefactorMethodParameterReferences(CodeParameterDeclarationExpressionCollection parameters, string oldName, string newName)
{
foreach (CodeParameterDeclarationExpression parameter in parameters)
{
RefactorCodeTypeReference(parameter.Type, oldName, newName);
RefactorCodeTypeReferencesInAttributes(parameter.CustomAttributes, oldName, newName);
}
}
protected CodeParameter AddParameter(CodeParameterDeclarationExpressionCollection collection, string name, object type, object position)
{
CodeTypeRef typeRef = ObjectToTypeRef(type);
CodeDomCodeParameter cdParam = new CodeDomCodeParameter(DTE, this, name, typeRef);
collection.Insert(PositionToParameterIndex(collection, position), cdParam.CodeObject);
return(cdParam);
}
public void Constructor1_NullItem()
{
CodeParameterDeclarationExpression[] parameters = new CodeParameterDeclarationExpression[] {
new CodeParameterDeclarationExpression(), null
};
CodeParameterDeclarationExpressionCollection coll = new CodeParameterDeclarationExpressionCollection(
parameters);
}
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 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);
}
public override CodeParameterDeclarationExpressionCollection GenerateConstructorParameter(Activity activity)
{
var parameters = new CodeParameterDeclarationExpressionCollection
{
new CodeParameterDeclarationExpression(GetServiceFieldType(), GetServiceFieldName())
};
return(parameters);
}
public void Constructor0()
{
CodeParameterDeclarationExpressionCollection coll = new CodeParameterDeclarationExpressionCollection();
Assert.IsFalse(((IList)coll).IsFixedSize, "#1");
Assert.IsFalse(((IList)coll).IsReadOnly, "#2");
Assert.AreEqual(0, coll.Count, "#3");
Assert.IsFalse(((ICollection)coll).IsSynchronized, "#4");
}
private void ValidateParameters(CodeParameterDeclarationExpressionCollection parameters)
{
foreach (CodeParameterDeclarationExpression current in parameters)
{
ValidateParameterDeclarationExpression(current);
}
}
public void AddRange(CodeParameterDeclarationExpressionCollection value) {}
protected virtual void OutputParameters(CodeParameterDeclarationExpressionCollection parameters)
{
bool first = true;
bool multiline = parameters.Count > ParameterMultilineThreshold;
if (multiline)
{
Indent += 3;
}
foreach (CodeParameterDeclarationExpression current in parameters)
{
if (first)
{
first = false;
}
else
{
Output.Write(", ");
}
if (multiline)
{
ContinueOnNewLine("");
}
GenerateExpression(current);
}
if (multiline)
{
Indent -= 3;
}
}
public CodeParameterDeclarationExpressionCollection(CodeParameterDeclarationExpressionCollection value) {}
private void OutputParameters(CodeParameterDeclarationExpressionCollection parameters)
{
bool first = true;
bool multiline = parameters.Count > ParameterMultilineThreshold;
if (multiline)
{
Indent += 3;
}
IEnumerator en = parameters.GetEnumerator();
while (en.MoveNext())
{
CodeParameterDeclarationExpression current = (CodeParameterDeclarationExpression)en.Current;
if (first)
{
first = false;
}
else
{
Output.Write(", ");
}
if (multiline)
{
ContinueOnNewLine("");
}
GenerateExpression(current);
}
if (multiline)
{
Indent -= 3;
}
}
private void GenerateParameterCommentStatements(CodeParameterDeclarationExpressionCollection codeParameterDeclarationExpressionCollection)
{
throw new NotImplementedException();
}
private void DisambiguateMethodParameterNames(CodeParameterDeclarationExpressionCollection parameters)
{
var list = parameters.Cast<CodeParameterDeclarationExpression>().ToList<CodeParameterDeclarationExpression>();
list.ForEach(p => DisambiguateMethodParameterName(p.Name, list));
}
private void CheckOptionalMethodParameters(CodeParameterDeclarationExpressionCollection parameters)
{
var startChanging = false;
foreach (CodeParameterDeclarationExpression parameter in parameters)
{
if (!startChanging)
{
startChanging = classBuilder.IsOptionalParameter(parameter);
}
else
{
classBuilder.MarkParameterAsOptional(parameter);
}
}
}
// Output a list of parameters.
protected virtual void OutputParameters
(CodeParameterDeclarationExpressionCollection parameters)
{
bool splitLines = (parameters.Count >= 16);
bool first = true;
if(splitLines)
{
writer.Indent += 1;
}
foreach(CodeParameterDeclarationExpression expr in parameters)
{
if(!first)
{
Output.Write(", ");
if(splitLines)
{
ContinueOnNewLine("");
}
}
else
{
first = false;
}
GenerateParameterDeclarationExpression(expr);
}
if(splitLines)
{
writer.Indent -= 1;
}
}
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;
}
private void RemovePreviousOverload(CodeParameterDeclarationExpressionCollection args, string methodName)
{
if (methodName == type.Name)
{
methodName = ".ctor";
}
if (args.Count > 0 && args[args.Count - 1].Name.Contains(" = "))
{
IEnumerable<CodeParameterDeclarationExpression> parameters = args.Cast<CodeParameterDeclarationExpression>().Take(args.Count - 1);
foreach (CodeMemberMethod method in (from method in this.type.Members.OfType<CodeMemberMethod>()
where method.Name == methodName &&
(method.Attributes & MemberAttributes.Override) == 0 &&
method.Parameters.Cast<CodeParameterDeclarationExpression>()
.SequenceEqual(parameters, new ParameterTypeComparer())
select method).ToList())
{
this.type.Members.Remove(method);
}
}
}
private static CodeParameterDeclarationExpression GetRefParameter(CodeParameterDeclarationExpressionCollection parameters, FieldDirection dir, CodeMemberField field)
{
foreach (CodeParameterDeclarationExpression expression in parameters)
{
if (expression.Name == field.Name)
{
if ((expression.Direction != dir) && (expression.Type.BaseType == field.Type.BaseType))
{
expression.Direction = FieldDirection.Ref;
return expression;
}
return null;
}
}
return null;
}
protected virtual void OutputParameters(CodeParameterDeclarationExpressionCollection parameters)
{
bool first = true;
foreach (CodeParameterDeclarationExpression expr in parameters)
{
if (first)
first = false;
else
output.Write(", ");
GenerateExpression(expr);
if (expr.DefaultValueExpression != null)
{
output.Write(" = ");
GenerateExpression(expr.DefaultValueExpression);
}
}
}
