/// <inheritdoc />
public override void WriteClassSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
if(IsUnsupportedGeneric(reflection, writer))
return;
string name = (string)reflection.Evaluate(apiNameExpression);
bool isAbstract = (bool)reflection.Evaluate(apiIsAbstractTypeExpression);
bool isSealed = (bool)reflection.Evaluate(apiIsSealedTypeExpression);
WriteAccessModifier(reflection, writer);
if(isSealed)
{
writer.WriteKeyword("final");
writer.WriteString(" ");
}
else if(isAbstract)
{
writer.WriteKeyword("abstract");
writer.WriteString(" ");
}
writer.WriteKeyword("class");
writer.WriteString(" ");
writer.WriteString(name);
WriteBaseClass(reflection, writer);
WriteInterfaceList(reflection, writer);
}
// namespace: done
/// <inheritdoc />
public override void WriteNamespaceSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
string name = reflection.Evaluate(apiNameExpression).ToString();
writer.WriteKeyword("namespace");
writer.WriteString(" ");
writer.WriteIdentifier(name);
}
/// <summary>
/// Write out event syntax
/// </summary>
/// <param name="reflection">The reflection information</param>
/// <param name="writer">The syntax writer to which it is written</param>
public override void WriteEventSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
if (reflection == null)
{
throw new ArgumentNullException(nameof(reflection));
}
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
if (!this.IsUnsupported(reflection, writer))
{
if (reflection.Select(apiParametersExpression).Count > 0)
{
writer.WriteMessage("UnsupportedIndex_" + this.Language);
}
else
{
string identifier = ReadMemberName(reflection);
writer.WriteKeyword("function");
writer.WriteString(" add_");
writer.WriteIdentifier(identifier);
writer.WriteString("(");
writer.WriteParameter("value");
writer.WriteString(");");
writer.WriteLine();
writer.WriteKeyword("function");
writer.WriteString(" remove_");
writer.WriteIdentifier(identifier);
writer.WriteString("(");
writer.WriteParameter("value");
writer.WriteString(");");
}
}
}
/// <summary>
/// Write out the record constructor syntax
/// </summary>
/// <param name="reflection">The reflection information</param>
/// <param name="writer">The syntax writer to which it is written</param>
private static void WriteRecordConstructorSyntax(
XPathNavigator reflection, SyntaxWriter writer)
{
string nameSpace = ReadNamespaceName(reflection);
string containingType = ReadContainingTypeName(reflection);
writer.WriteString(nameSpace);
writer.WriteString(".$create_");
writer.WriteString(containingType);
writer.WriteString(" = ");
writer.WriteKeyword("function");
WriteParameterList(reflection, writer);
writer.WriteString(";");
}
/// <summary>
/// Write out normal method syntax
/// </summary>
/// <param name="reflection">The reflection information</param>
/// <param name="writer">The syntax writer to which it is written</param>
public override void WriteNormalMethodSyntax(XPathNavigator reflection,
SyntaxWriter writer)
{
if (this.IsUnsupported(reflection, writer))
{
return;
}
if (HasAttribute(reflection, "System.AttachedPropertyAttribute"))
{
this.WriteAttachedPropertySyntax(reflection, writer);
return;
}
string identifier = ReadMemberName(reflection);
bool isStatic = (bool)reflection.Evaluate(SyntaxGeneratorTemplate.apiIsStaticExpression);
bool isGlobal = (bool)reflection.Evaluate(memberIsGlobalExpression);
if (isStatic && !isGlobal)
{
writer.WriteIdentifier(ReadFullContainingTypeName(reflection));
writer.WriteString(".");
writer.WriteIdentifier(identifier);
writer.WriteString(" = ");
writer.WriteKeyword("function");
}
else
{
writer.WriteKeyword("function");
writer.WriteString(" ");
writer.WriteIdentifier(identifier);
}
WriteParameterList(reflection, writer);
writer.WriteString(";");
}
private void ParameterDeclaration(string name, XPathNavigator type, SyntaxWriter writer)
{
writer.WriteKeyword("Dim");
writer.WriteString(" ");
writer.WriteParameter(name);
writer.WriteString(" ");
writer.WriteKeyword("As");
writer.WriteString(" ");
string typeName = (string)type.Evaluate(apiNameExpression);
if (reservedWords.Contains(typeName))
{
writer.WriteString("[");
WriteTypeReference(type, writer);
writer.WriteString("]");
}
else
{
WriteTypeReference(type, writer);
}
writer.WriteLine();
}
/// <summary>
/// Write out delegate syntax
/// </summary>
/// <param name="reflection">The reflection information</param>
/// <param name="writer">The syntax writer to which it is written</param>
public override void WriteDelegateSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
if (reflection == null)
{
throw new ArgumentNullException(nameof(reflection));
}
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
writer.WriteKeyword("function");
WriteParameterList(reflection, writer);
writer.WriteString(";");
}
/// <summary>
/// Write out enumeration syntax
/// </summary>
/// <param name="reflection">The reflection information</param>
/// <param name="writer">The syntax writer to which it is written</param>
public override void WriteEnumerationSyntax(XPathNavigator reflection,
SyntaxWriter writer)
{
string identifier = ReadFullTypeName(reflection);
writer.WriteIdentifier(identifier);
writer.WriteString(" = ");
writer.WriteKeyword("function");
writer.WriteString("();");
writer.WriteLine();
writer.WriteIdentifier(identifier);
writer.WriteString(".createEnum('");
writer.WriteIdentifier(identifier);
writer.WriteString("', ");
writer.WriteString(HasAttribute(reflection,
"System.FlagsAttribute") ? "true" : "false");
writer.WriteString(");");
}
/// <summary>
/// Write out interface syntax
/// </summary>
/// <param name="reflection">The reflection information</param>
/// <param name="writer">The syntax writer to which it is written</param>
public override void WriteInterfaceSyntax(XPathNavigator reflection,
SyntaxWriter writer)
{
if (!this.IsUnsupported(reflection, writer))
{
string identifier = ReadFullTypeName(reflection);
writer.WriteIdentifier(identifier);
writer.WriteString(" = ");
writer.WriteKeyword("function");
writer.WriteString("();");
writer.WriteLine();
writer.WriteIdentifier(identifier);
writer.WriteString(".createInterface('");
writer.WriteIdentifier(identifier);
writer.WriteString("');");
}
}
/// <inheritdoc />
public override void WriteNamespaceSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
if (reflection == null)
{
throw new ArgumentNullException(nameof(reflection));
}
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
string name = reflection.Evaluate(apiNameExpression).ToString();
writer.WriteKeyword("package");
writer.WriteString(" ");
writer.WriteIdentifier(name);
}
private void WriteMethodThrows(XPathNodeIterator exceptions, XPathNavigator reflection, SyntaxWriter writer)
{
writer.WriteString(" ");
writer.WriteKeyword("throws");
writer.WriteString(" ");
while (exceptions.MoveNext())
{
XPathNavigator exception = exceptions.Current;
WriteTypeReference(exception, writer);
if (exceptions.CurrentPosition < exceptions.Count)
{
writer.WriteString(",");
}
writer.WriteLine();
}
}
/// <inheritdoc />
public override void WriteNormalMethodSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
if (reflection == null)
{
throw new ArgumentNullException(nameof(reflection));
}
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
if (IsUnsupportedUnsafe(reflection, writer))
{
return;
}
if (IsUnsupportedGeneric(reflection, writer))
{
return;
}
if (IsUnsupportedExplicit(reflection, writer))
{
return;
}
if (IsUnsupportedVarargs(reflection, writer))
{
return;
}
string name = (string)reflection.Evaluate(apiNameExpression);
XPathNavigator returnType = reflection.SelectSingleNode(apiReturnTypeExpression);
WriteProcedureModifiers(reflection, writer);
writer.WriteKeyword("function");
writer.WriteString(" ");
writer.WriteIdentifier(name);
WriteParameterList(reflection, writer);
if (returnType != null)
{
writer.WriteString(" : ");
WriteTypeReference(returnType, writer);
}
}
/// <inheritdoc />
public override void WriteDelegateSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
if (reflection == null)
{
throw new ArgumentNullException(nameof(reflection));
}
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
if (IsUnsupportedUnsafe(reflection, writer))
{
return;
}
if (IsUnsupportedGeneric(reflection, writer))
{
return;
}
string name = (string)reflection.Evaluate(apiNameExpression);
bool isSerializable = (bool)reflection.Evaluate(apiIsSerializableTypeExpression);
writer.WriteString("/** @delegate */");
writer.WriteLine();
if (isSerializable)
{
WriteAttribute("T:System.SerializableAttribute", writer);
}
WriteAttributes(reflection, writer);
WriteVisibility(reflection, writer);
writer.WriteString(" ");
writer.WriteKeyword("delegate");
writer.WriteString(" ");
WriteReturnValue(reflection, writer);
writer.WriteString(" ");
writer.WriteIdentifier(name);
WriteMethodParameters(reflection, writer);
}
/// <inheritdoc />
public override void WriteCastSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
if (reflection == null)
{
throw new ArgumentNullException(nameof(reflection));
}
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
XPathNavigator parameter = reflection.SelectSingleNode(apiParametersExpression);
if (parameter == null)
{
return;
}
XPathNavigator inputType = parameter.SelectSingleNode(typeExpression);
XPathNavigator outputType = reflection.SelectSingleNode(apiReturnTypeExpression);
if ((inputType == null) || (outputType == null))
{
return;
}
ParameterDeclaration("input", inputType, writer);
ParameterDeclaration("output", outputType, writer);
writer.WriteLine();
writer.WriteParameter("output");
writer.WriteString(" = ");
writer.WriteKeyword("CType");
writer.WriteString("(");
writer.WriteParameter("input");
writer.WriteString(", ");
WriteTypeReference(outputType, writer);
writer.WriteString(")");
}
/// <inheritdoc />
public override void WriteEnumerationSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
if (reflection == null)
{
throw new ArgumentNullException(nameof(reflection));
}
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
string name = (string)reflection.Evaluate(apiNameExpression);
WriteAccessModifier(reflection, writer);
writer.WriteKeyword("enum");
writer.WriteString(" ");
writer.WriteString(name);
// no JScript support for underlying types
}
/// <summary>
/// Write out constructor syntax
/// </summary>
/// <param name="reflection">The reflection information</param>
/// <param name="writer">The syntax writer to which it is written</param>
public override void WriteConstructorSyntax(XPathNavigator reflection,
SyntaxWriter writer)
{
if (!this.IsUnsupported(reflection, writer))
{
if ((bool)reflection.Evaluate(typeIsRecordExpression))
{
WriteRecordConstructorSyntax(reflection, writer);
}
else
{
string identifier = ReadFullContainingTypeName(reflection);
writer.WriteIdentifier(identifier);
writer.WriteString(" = ");
writer.WriteKeyword("function");
WriteParameterList(reflection, writer);
writer.WriteString(";");
}
}
}
/// <inheritdoc />
public override void WriteEventSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
if (reflection == null)
{
throw new ArgumentNullException(nameof(reflection));
}
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
// !EFW - Added unsafe check
if (IsUnsupportedUnsafe(reflection, writer))
{
return;
}
bool isStatic = (bool)reflection.Evaluate(apiIsStaticExpression);
bool isFamily = (bool)reflection.Evaluate(apiIsFamilyMemberExpression);
XPathNavigator declaringType = reflection.SelectSingleNode(apiContainingTypeExpression);
XPathNavigator handler = reflection.SelectSingleNode(apiHandlerOfEventExpression);
if (!(isStatic | isFamily))
{
ParameterDeclaration("instance", declaringType, writer);
}
ParameterDeclaration("handler", handler, writer);
// adder
writer.WriteLine();
writer.WriteKeyword("AddHandler");
writer.WriteString(" ");
WriteMemberName(reflection, writer);
writer.WriteString(", ");
writer.WriteParameter("handler");
writer.WriteLine();
}
/// <summary>
/// Write out field syntax
/// </summary>
/// <param name="reflection">The reflection information</param>
/// <param name="writer">The syntax writer to which it is written</param>
public override void WriteFieldSyntax(XPathNavigator reflection,
SyntaxWriter writer)
{
if (!this.IsUnsupported(reflection, writer))
{
string identifier = ReadMemberName(reflection);
// EFW - Added "var" keyword before field name
writer.WriteKeyword("var");
writer.WriteString(" ");
if ((bool)reflection.Evaluate(
SyntaxGeneratorTemplate.apiIsStaticExpression))
{
writer.WriteIdentifier(ReadFullContainingTypeName(
reflection));
writer.WriteString(".");
}
writer.WriteIdentifier(identifier);
}
}
private void WriteImplementedInterfaces(string keyword, XPathNavigator reflection, SyntaxWriter writer)
{
XPathNodeIterator implements = reflection.Select(apiImplementedInterfacesExpression);
if (implements.Count != 0)
{
writer.WriteString(" ");
writer.WriteKeyword(keyword);
writer.WriteString(" ");
while (implements.MoveNext())
{
XPathNavigator implement = implements.Current;
WriteTypeReference(implement, writer);
if (implements.CurrentPosition < implements.Count)
{
WriteWithLineBreakIfNeeded(writer, ", ", "\t");
}
}
}
}
/// <summary>
/// Write out attached property syntax
/// </summary>
/// <param name="reflection">The reflection information</param>
/// <param name="writer">The syntax writer to which it is written</param>
public override void WriteAttachedPropertySyntax(
XPathNavigator reflection, SyntaxWriter writer)
{
string containingTypeName = ReadContainingTypeName(reflection);
string memberName = ReadMemberName(reflection);
string fullName = String.Concat(containingTypeName, ".",
memberName.Substring(3));
if (memberName.StartsWith("Get", StringComparison.OrdinalIgnoreCase))
{
writer.WriteKeyword("var");
writer.WriteString(" value = obj['");
writer.WriteString(fullName);
writer.WriteString("'];");
}
else
if (memberName.StartsWith("Set", StringComparison.OrdinalIgnoreCase))
{
writer.WriteString("obj['");
writer.WriteString(fullName);
writer.WriteString("'] = value;");
}
}
private void WriteInterfaceList(string keyword, XPathNavigator reflection, SyntaxWriter writer)
{
XPathNodeIterator implements = reflection.Select(apiImplementedInterfacesExpression);
if (implements.Count == 0)
{
return;
}
writer.WriteString(" ");
writer.WriteKeyword(keyword);
writer.WriteString(" ");
while (implements.MoveNext())
{
XPathNavigator implement = implements.Current;
WriteTypeReference(implement, writer);
if (implements.CurrentPosition < implements.Count)
{
writer.WriteString(", ");
}
}
}
/// <inheritdoc />
public override void WriteConstructorSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
// !EFW - Added unsafe check
if(IsUnsupportedUnsafe(reflection, writer))
return;
string name = (string)reflection.Evaluate(apiContainingTypeNameExpression);
WriteAttributes(reflection, writer);
writer.WriteKeyword("new");
writer.WriteString(" : ");
WriteParameters(reflection, writer);
writer.WriteKeyword("->");
writer.WriteString(" ");
writer.WriteIdentifier(name);
}
// References
/// <inheritdoc />
protected override void WriteTypeReference(XPathNavigator reference, SyntaxWriter writer)
{
switch(reference.LocalName)
{
case "arrayOf":
int rank = Convert.ToInt32(reference.GetAttribute("rank", String.Empty),
CultureInfo.InvariantCulture);
XPathNavigator element = reference.SelectSingleNode(typeExpression);
WriteTypeReference(element, writer);
writer.WriteString("[");
for(int i = 1; i < rank; i++)
writer.WriteString(",");
writer.WriteString("]");
break;
case "pointerTo":
XPathNavigator pointee = reference.SelectSingleNode(typeExpression);
writer.WriteKeyword("nativeptr");
writer.WriteString("<");
WriteTypeReference(pointee, writer);
writer.WriteString(">");
break;
case "referenceTo":
XPathNavigator referee = reference.SelectSingleNode(typeExpression);
WriteTypeReference(referee, writer);
break;
case "type":
string id = reference.GetAttribute("api", String.Empty);
WriteNormalTypeReference(id, writer);
XPathNodeIterator typeModifiers = reference.Select(typeModifiersExpression);
while(typeModifiers.MoveNext())
WriteTypeReference(typeModifiers.Current, writer);
break;
case "template":
string name = reference.GetAttribute("name", String.Empty);
writer.WriteString("'");
writer.WriteString(name);
XPathNodeIterator modifiers = reference.Select(typeModifiersExpression);
while(modifiers.MoveNext())
WriteTypeReference(modifiers.Current, writer);
break;
case "specialization":
writer.WriteString("<");
XPathNodeIterator arguments = reference.Select(specializationArgumentsExpression);
while(arguments.MoveNext())
{
if(arguments.CurrentPosition > 1)
writer.WriteString(", ");
WriteTypeReference(arguments.Current, writer);
}
writer.WriteString(">");
break;
}
}
private void WriteParameters(XPathNodeIterator parameters, SyntaxWriter writer)
{
List<KeyValuePair<string, XPathNavigator>> optionalParams = new List<KeyValuePair<string, XPathNavigator>>();
writer.WriteLine();
while(parameters.MoveNext())
{
XPathNavigator parameter = parameters.Current;
// !EFW - Added support for optional parameter values
XPathNavigator argument = (XPathNavigator)parameter.SelectSingleNode(parameterArgumentExpression);
bool isOptional = (bool)parameter.Evaluate(parameterIsOptionalExpression);
string name = (string)parameter.Evaluate(parameterNameExpression);
bool isOut = (bool)parameter.Evaluate(parameterIsOutExpression);
bool isRef = (bool)parameter.Evaluate(parameterIsRefExpression);
XPathNavigator type = parameter.SelectSingleNode(parameterTypeExpression);
writer.WriteString(" ");
// !EFW - Write out parameter attributes
WriteAttributes(parameter, writer, null, true);
// !EFW - Optional indicated by OptionalAttribute?
if(isOptional)
if(argument == null)
{
WriteAttribute("T:System.Runtime.InteropServices.OptionalAttribute", false, writer);
writer.WriteString(" ");
}
else
{
writer.WriteString("?");
optionalParams.Add(new KeyValuePair<string, XPathNavigator>(name, argument));
}
writer.WriteParameter(name);
writer.WriteString(" : ");
WriteTypeReference(type, writer);
if(isOut || isRef)
{
writer.WriteString(" ");
writer.WriteKeyword("byref");
}
if(parameters.CurrentPosition != parameters.Count)
{
writer.WriteString(" * ");
writer.WriteLine();
}
else
writer.WriteString(" ");
}
// !EFW - Write out the optional value assignments. F# uses a function to assign defaults so we'll
// just list them in a "comment" block. There's probably a better way to do this but I know nothing
// about F#.
if(optionalParams.Count != 0)
{
writer.WriteLine();
writer.WriteString("(* Defaults:");
writer.WriteLine();
foreach(var kv in optionalParams)
{
writer.WriteString(" ");
writer.WriteKeyword("let ");
writer.WriteIdentifier("_");
writer.WriteIdentifier(kv.Key);
writer.WriteString(" = defaultArg ");
writer.WriteIdentifier(kv.Key);
writer.WriteString(" ");
this.WriteValue(kv.Value, writer);
writer.WriteLine();
}
writer.WriteString("*)");
writer.WriteLine();
}
}
private void WriteGenericTemplateConstraints(XPathNavigator reflection, SyntaxWriter writer)
{
XPathNodeIterator templates = reflection.Select(apiTemplatesExpression);
if(templates.Count == 0)
return;
foreach(XPathNavigator template in templates)
{
bool constrained = (bool)template.Evaluate(templateIsConstrainedExpression);
if(constrained)
{
string name = (string)template.Evaluate(templateNameExpression);
writer.WriteString(" ");
writer.WriteKeyword("when");
writer.WriteString(" '");
writer.WriteString(name);
writer.WriteString(" : ");
}
else
{
continue;
}
bool value = (bool)template.Evaluate(templateIsValueTypeExpression);
bool reference = (bool)template.Evaluate(templateIsReferenceTypeExpression);
bool constructor = (bool)template.Evaluate(templateIsConstructableExpression);
XPathNodeIterator constraints = template.Select(templateConstraintsExpression);
// keep track of whether there is a previous constraint, so we know whether to put a comma
bool previous = false;
if(value)
{
if(previous)
writer.WriteString(", ");
writer.WriteKeyword("struct");
previous = true;
}
if(reference)
{
if(previous)
writer.WriteString(", ");
writer.WriteKeyword("not struct");
previous = true;
}
if(constructor)
{
if(previous)
writer.WriteString(", ");
writer.WriteKeyword("new");
writer.WriteString("()");
previous = true;
}
foreach(XPathNavigator constraint in constraints)
{
if(previous)
writer.WriteString(" and ");
WriteTypeReference(constraint, writer);
previous = true;
}
}
}
private static void WriteVisibility(string visibility, SyntaxWriter writer)
{
switch(visibility)
{
case "public":
writer.WriteKeyword("Public");
break;
case "family":
writer.WriteKeyword("Protected");
break;
case "family or assembly":
writer.WriteKeyword("Protected Friend");
break;
case "family and assembly":
writer.WriteKeyword("Friend"); // not right, but same outside assembly
break;
case "assembly":
writer.WriteKeyword("Friend");
break;
case "private":
writer.WriteKeyword("Private");
break;
}
}
private static void WriteProcedureModifiers(XPathNavigator reflection, SyntaxWriter writer)
{
// interface members don't get modified
string typeSubgroup = (string)reflection.Evaluate(apiContainingTypeSubgroupExpression);
if(typeSubgroup == "interface")
return;
bool isStatic = (bool)reflection.Evaluate(apiIsStaticExpression);
bool isVirtual = (bool)reflection.Evaluate(apiIsVirtualExpression);
bool isAbstract = (bool)reflection.Evaluate(apiIsAbstractProcedureExpression);
bool isFinal = (bool)reflection.Evaluate(apiIsFinalExpression);
bool isOverride = (bool)reflection.Evaluate(apiIsOverrideExpression);
WriteVisibility(reflection, writer);
writer.WriteString(" ");
if(isStatic)
{
writer.WriteKeyword("Shared");
writer.WriteString(" ");
}
else
{
if(isVirtual)
{
if(isAbstract)
{
writer.WriteKeyword("MustOverride");
writer.WriteString(" ");
}
else if(isOverride)
{
writer.WriteKeyword("Overrides");
writer.WriteString(" ");
if(isFinal)
{
writer.WriteKeyword("NotOverridable");
writer.WriteString(" ");
}
}
else
{
if(!isFinal)
{
writer.WriteKeyword("Overridable");
writer.WriteString(" ");
}
}
}
}
}
private void WriteDotNetObject(XPathNavigator reflection, SyntaxWriter writer, string kind)
{
string name = reflection.Evaluate(apiNameExpression).ToString();
bool isSerializable = (bool)reflection.Evaluate(apiIsSerializableTypeExpression);
XPathNodeIterator implements = reflection.Select(apiImplementedInterfacesExpression);
XPathNavigator baseClass = reflection.SelectSingleNode(apiBaseClassExpression);
bool hasBaseClass = (baseClass != null) && !((bool)baseClass.Evaluate(typeIsObjectExpression));
// CLR considers interfaces abstract.
bool isAbstract = (bool)reflection.Evaluate(apiIsAbstractTypeExpression) && kind != "interface";
bool isSealed = (bool)reflection.Evaluate(apiIsSealedTypeExpression);
if(isAbstract)
WriteAttribute("T:Microsoft.FSharp.Core.AbstractClassAttribute", true, writer);
if(isSealed)
WriteAttribute("T:Microsoft.FSharp.Core.SealedAttribute", true, writer);
if(isSerializable)
WriteAttribute("T:System.SerializableAttribute", true, writer);
WriteAttributes(reflection, writer);
writer.WriteKeyword("type");
writer.WriteString(" ");
writer.WriteIdentifier(name);
WriteGenericTemplates(reflection, writer);
writer.WriteString(" = ");
if(hasBaseClass || implements.Count != 0)
{
writer.WriteLine();
writer.WriteString(" ");
}
writer.WriteKeyword(kind);
if(hasBaseClass || implements.Count != 0)
{
writer.WriteLine();
}
if(hasBaseClass)
{
writer.WriteString(" ");
writer.WriteKeyword("inherit");
writer.WriteString(" ");
WriteTypeReference(baseClass, writer);
writer.WriteLine();
}
while(implements.MoveNext())
{
XPathNavigator implement = implements.Current;
writer.WriteString(" ");
writer.WriteKeyword("interface");
writer.WriteString(" ");
WriteTypeReference(implement, writer);
writer.WriteLine();
}
if(hasBaseClass || implements.Count != 0)
{
writer.WriteString(" ");
}
else
{
writer.WriteString(" ");
}
writer.WriteKeyword("end");
}
/// <summary>
/// Write out property syntax if supported
/// </summary>
/// <param name="reflection">The reflection information</param>
/// <param name="writer">The syntax writer to which it is written</param>
public override void WritePropertySyntax(XPathNavigator reflection,
SyntaxWriter writer)
{
if (this.IsUnsupported(reflection, writer))
{
return;
}
if (HasAttribute(reflection, "System.IntrinsicPropertyAttribute"))
{
this.WriteFieldSyntax(reflection, writer);
return;
}
string identifier = ReadMemberName(reflection);
bool isStatic = (bool)reflection.Evaluate(
SyntaxGeneratorTemplate.apiIsStaticExpression);
bool isReadProp = (bool)reflection.Evaluate(
SyntaxGeneratorTemplate.apiIsReadPropertyExpression);
bool isWriteProp = (bool)reflection.Evaluate(
SyntaxGeneratorTemplate.apiIsWritePropertyExpression);
// EFW - Unused so removed
// XPathNavigator navigator = reflection.SelectSingleNode(
// SyntaxGeneratorTemplate.apiReturnTypeExpression);
if (isReadProp)
{
if (isStatic)
{
writer.WriteIdentifier(ReadFullContainingTypeName(
reflection));
writer.WriteString(".");
writer.WriteString("get_");
writer.WriteIdentifier(identifier);
writer.WriteString(" = ");
writer.WriteKeyword("function");
}
else
{
writer.WriteKeyword("function");
writer.WriteString(" ");
writer.WriteString("get_");
writer.WriteIdentifier(identifier);
}
WriteParameterList(reflection, writer);
writer.WriteString(";");
writer.WriteLine();
}
if (isWriteProp)
{
if (isStatic)
{
writer.WriteIdentifier(ReadFullContainingTypeName(
reflection));
writer.WriteString(".");
writer.WriteString("set_");
writer.WriteIdentifier(identifier);
writer.WriteString(" = ");
writer.WriteKeyword("function");
}
else
{
writer.WriteKeyword("function");
writer.WriteString(" ");
writer.WriteString("set_");
writer.WriteIdentifier(identifier);
}
writer.WriteString("(");
writer.WriteParameter("value");
writer.WriteString(");");
}
}
/// <inheritdoc />
public override void WriteFieldSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
if (reflection == null)
{
throw new ArgumentNullException(nameof(reflection));
}
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
if (IsUnsupportedUnsafe(reflection, writer))
{
return;
}
string name = (string)reflection.Evaluate(apiNameExpression);
bool isStatic = (bool)reflection.Evaluate(apiIsStaticExpression);
bool isLiteral = (bool)reflection.Evaluate(apiIsLiteralFieldExpression);
bool isInitOnly = (bool)reflection.Evaluate(apiIsInitOnlyFieldExpression);
bool isFamily = (bool)reflection.Evaluate(apiIsFamilyMemberExpression);
XPathNavigator declaringType = reflection.SelectSingleNode(apiContainingTypeExpression);
XPathNavigator fieldType = reflection.SelectSingleNode(apiReturnTypeExpression);
if (!(isStatic || isFamily))
{
ParameterDeclaration("instance", declaringType, writer);
}
ParameterDeclaration("value", fieldType, writer);
// get value
writer.WriteLine();
writer.WriteParameter("value");
writer.WriteString(" = ");
if (isStatic)
{
WriteTypeReference(declaringType, writer);
}
else
{
if (isFamily)
{
writer.WriteKeyword("Me");
}
else
{
writer.WriteParameter("instance");
}
}
writer.WriteString(".");
writer.WriteIdentifier(name);
writer.WriteLine();
// set value
if (isLiteral || isInitOnly)
{
return;
}
writer.WriteLine();
if (isStatic)
{
WriteTypeReference(declaringType, writer);
}
else
{
if (isFamily)
{
writer.WriteKeyword("Me");
}
else
{
writer.WriteParameter("instance");
}
}
writer.WriteString(".");
writer.WriteIdentifier(name);
writer.WriteString(" = ");
writer.WriteParameter("value");
}
/// <inheritdoc />
public override void WriteOperatorSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
string name = (string)reflection.Evaluate(apiNameExpression);
string identifier = null;
bool isStatic = (bool)reflection.Evaluate(apiIsStaticExpression);
if(!(bool)reflection.Evaluate(apiIsUdtReturnExpression))
{
switch(name)
{
// unary math operators
case "UnaryPlus":
identifier = "+";
break;
case "UnaryNegation":
identifier = "-";
break;
case "Increment":
identifier = "++";
break;
case "Decrement":
identifier = "--";
break;
// unary logical operators
case "LogicalNot":
identifier = "not";
break;
case "True":
identifier = "true";
break;
case "False":
identifier = "false";
break;
// binary comparison operators
case "Equality":
identifier = "=";
break;
case "Inequality":
identifier = "<>";
break;
case "LessThan":
identifier = "<";
break;
case "GreaterThan":
identifier = ">";
break;
case "LessThanOrEqual":
identifier = "<=";
break;
case "GreaterThanOrEqual":
identifier = ">=";
break;
// binary math operators
case "Addition":
identifier = "+";
break;
case "Subtraction":
identifier = "-";
break;
case "Multiply":
identifier = "*";
break;
case "Division":
identifier = "/";
break;
case "Modulus":
identifier = "%";
break;
// binary logical operators
case "BitwiseAnd":
identifier = "&&&";
break;
case "BitwiseOr":
identifier = "|||";
break;
case "ExclusiveOr":
identifier = "^^^";
break;
// bit-array operators
case "OnesComplement":
identifier = null; // No F# equiv.
break;
case "LeftShift":
identifier = "<<<";
break;
case "RightShift":
identifier = ">>>";
break;
case "Assign":
identifier = "=";
break;
// unrecognized operator
default:
identifier = null;
break;
}
}
if(identifier == null)
{
writer.WriteMessage("UnsupportedOperator_" + Language);
}
else
{
if(isStatic)
{
writer.WriteKeyword("static");
writer.WriteString(" ");
}
writer.WriteKeyword("let");
writer.WriteString(" ");
writer.WriteKeyword("inline");
writer.WriteKeyword(" ");
writer.WriteString("(");
writer.WriteIdentifier(identifier);
writer.WriteString(")");
WriteParameters(reflection, writer);
writer.WriteString(" : ");
WriteReturnValue(reflection, writer);
}
}
/// <inheritdoc />
public override void WriteEventSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
// !EFW - Added unsafe check
if(IsUnsupportedUnsafe(reflection, writer))
return;
string name = (string)reflection.Evaluate(apiNameExpression);
XPathNavigator handler = reflection.SelectSingleNode(apiHandlerOfEventExpression);
XPathNavigator args = reflection.SelectSingleNode(apiEventArgsExpression);
bool isVirtual = (bool)reflection.Evaluate(apiIsVirtualExpression) && !(bool)reflection.Evaluate(apiIsAbstractProcedureExpression);
int iterations = isVirtual ? 2 : 1;
for(int i = 0; i < iterations; i++)
{
WriteAttributes(reflection, writer);
WriteVisibility(reflection, writer);
if(isVirtual)
if(i == 0)
{
writer.WriteKeyword("abstract");
writer.WriteString(" ");
}
else
{
writer.WriteKeyword("override");
writer.WriteString(" ");
}
else
{
WriteMemberKeyword(reflection, writer);
}
writer.WriteIdentifier(name);
writer.WriteString(" : ");
writer.WriteReferenceLink("T:Microsoft.FSharp.Control.IEvent`2");
writer.WriteString("<");
WriteTypeReference(handler, writer);
writer.WriteString(",");
writer.WriteLine();
writer.WriteString(" ");
if(args == null)
{
writer.WriteReferenceLink("T:System.EventArgs");
}
else
{
WriteTypeReference(args, writer);
}
writer.WriteString(">");
if(i == 0)
writer.WriteLine();
}
}
/// <summary>
/// Write out class syntax
/// </summary>
/// <param name="reflection">The reflection information</param>
/// <param name="writer">The syntax writer to which it is written</param>
public override void WriteClassSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
if (reflection == null)
{
throw new ArgumentNullException(nameof(reflection));
}
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
if (this.IsUnsupported(reflection, writer))
{
return;
}
if (HasAttribute(reflection, "System.RecordAttribute"))
{
WriteRecordSyntax(reflection, writer);
return;
}
string identifier = ReadFullTypeName(reflection);
writer.WriteIdentifier(identifier);
writer.WriteString(" = ");
writer.WriteKeyword("function");
writer.WriteString("();");
writer.WriteLine();
writer.WriteLine();
writer.WriteIdentifier("Type");
writer.WriteString(".createClass(");
writer.WriteLine();
writer.WriteString("\t'");
writer.WriteString(identifier);
writer.WriteString("'");
bool hasBaseClass = false;
XPathNavigator reference = reflection.SelectSingleNode(apiBaseClassExpression);
if (!(reference == null || (bool)reference.Evaluate(typeIsObjectExpression)))
{
WriteIndentedNewLine(writer);
this.WriteTypeReference(reference, writer);
hasBaseClass = true;
}
XPathNodeIterator iterator = reflection.Select(apiImplementedInterfacesExpression);
if (iterator.Count != 0)
{
if (!hasBaseClass)
{
WriteIndentedNewLine(writer);
writer.WriteString("null");
}
WriteIndentedNewLine(writer);
while (iterator.MoveNext())
{
XPathNavigator current = iterator.Current;
this.WriteTypeReference(current, writer);
if (iterator.CurrentPosition < iterator.Count)
{
WriteIndentedNewLine(writer);
}
}
}
writer.WriteString(");");
}
/// <inheritdoc />
public override void WritePropertySyntax(XPathNavigator reflection, SyntaxWriter writer)
{
if (reflection == null)
{
throw new ArgumentNullException(nameof(reflection));
}
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
if (IsUnsupportedUnsafe(reflection, writer))
{
return;
}
if (IsUnsupportedExplicit(reflection, writer))
{
return;
}
string name = (string)reflection.Evaluate(apiNameExpression);
bool isGettable = (bool)reflection.Evaluate(apiIsReadPropertyExpression);
bool isSettable = (bool)reflection.Evaluate(apiIsWritePropertyExpression);
if (isGettable)
{
writer.WriteString("/** @property */");
writer.WriteLine();
// !EFW - Added support for getter/setter attributes
XPathNavigator getter = reflection.SelectSingleNode(apiGetterExpression);
if (getter != null && getter.HasChildren)
{
this.WriteAttributes(getter, writer);
}
// write getter method
WriteAttributes(reflection, writer);
WriteProcedureModifiers(reflection, writer);
WriteReturnValue(reflection, writer);
writer.WriteString(" ");
writer.WriteIdentifier("get_" + name);
WriteMethodParameters(reflection, writer);
writer.WriteLine();
}
if (isSettable)
{
writer.WriteString("/** @property */");
writer.WriteLine();
// !EFW - Added support for getter/setter attributes
XPathNavigator setter = reflection.SelectSingleNode(apiSetterExpression);
if (setter != null && setter.HasChildren)
{
this.WriteAttributes(setter, writer);
}
// write setter method
WriteAttributes(reflection, writer);
WriteProcedureModifiers(reflection, writer);
writer.WriteKeyword("void");
writer.WriteString(" ");
writer.WriteIdentifier("set_" + name);
// parameters
writer.WriteString("(");
WriteReturnValue(reflection, writer);
writer.WriteString(" ");
writer.WriteParameter("value");
writer.WriteString(")");
// end parameters
writer.WriteLine();
}
}
/// <inheritdoc />
protected override void WriteTypeReference(XPathNavigator reference, SyntaxWriter writer)
{
if (reference == null)
{
throw new ArgumentNullException(nameof(reference));
}
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
switch (reference.LocalName)
{
case "arrayOf":
int rank = Convert.ToInt32(reference.GetAttribute("rank", String.Empty),
CultureInfo.InvariantCulture);
XPathNavigator element = reference.SelectSingleNode(typeExpression);
WriteTypeReference(element, writer);
writer.WriteString("(");
for (int i = 1; i < rank; i++)
{
writer.WriteString(",");
}
writer.WriteString(")");
break;
case "pointerTo":
XPathNavigator pointee = reference.SelectSingleNode(typeExpression);
WriteTypeReference(pointee, writer);
writer.WriteString("*");
break;
case "referenceTo":
XPathNavigator referee = reference.SelectSingleNode(typeExpression);
WriteTypeReference(referee, writer);
break;
case "type":
string id = reference.GetAttribute("api", String.Empty);
XPathNodeIterator typeModifiers = reference.Select(typeModifiersExpression);
// !EFW - Support value tuple syntax
if (id.StartsWith("T:System.ValueTuple`", StringComparison.Ordinal))
{
writer.WriteString("(");
while (typeModifiers.MoveNext())
{
XPathNodeIterator args = typeModifiers.Current.Select(specializationArgumentsExpression);
while (args.MoveNext())
{
if (args.CurrentPosition > 1)
{
writer.WriteString(", ");
}
var elementName = args.Current.GetAttribute("elementName", String.Empty);
if (elementName != null)
{
writer.WriteString(elementName);
writer.WriteString(" As ");
}
WriteTypeReference(args.Current, writer);
}
}
writer.WriteString(")");
}
else if (id.StartsWith("T:System.Nullable`", StringComparison.Ordinal))
{
// !EFW - Support nullable type syntax
while (typeModifiers.MoveNext())
{
XPathNodeIterator args = typeModifiers.Current.Select(specializationArgumentsExpression);
while (args.MoveNext())
{
if (args.CurrentPosition > 1)
{
writer.WriteString(", ");
}
WriteTypeReference(args.Current, writer);
}
}
writer.WriteString("?");
}
else
{
WriteNormalTypeReference(id, writer);
while (typeModifiers.MoveNext())
{
WriteTypeReference(typeModifiers.Current, writer);
}
}
break;
case "template":
string name = reference.GetAttribute("name", String.Empty);
writer.WriteString(name);
XPathNodeIterator modifiers = reference.Select(typeModifiersExpression);
while (modifiers.MoveNext())
{
WriteTypeReference(modifiers.Current, writer);
}
break;
case "specialization":
writer.WriteString("(");
writer.WriteKeyword("Of");
writer.WriteString(" ");
XPathNodeIterator arguments = reference.Select(specializationArgumentsExpression);
while (arguments.MoveNext())
{
if (arguments.CurrentPosition > 1)
{
writer.WriteString(", ");
}
WriteTypeReference(arguments.Current, writer);
}
writer.WriteString(")");
break;
}
}
/// <inheritdoc />
public override void WriteFieldSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
if(IsUnsupportedUnsafe(reflection, writer))
return;
string name = (string)reflection.Evaluate(apiNameExpression);
bool isStatic = (bool)reflection.Evaluate(apiIsStaticExpression);
bool isLiteral = (bool)reflection.Evaluate(apiIsLiteralFieldExpression);
bool isInitOnly = (bool)reflection.Evaluate(apiIsInitOnlyFieldExpression);
bool isSerialized = (bool)reflection.Evaluate(apiIsSerializedFieldExpression);
XPathNavigator type = reflection.SelectSingleNode(apiReturnTypeExpression);
if(!isSerialized)
WriteAttribute("T:System.NonSerializedAttribute", writer);
WriteAttributes(reflection, writer);
WriteVisibility(reflection, writer);
writer.WriteString(" ");
if(isStatic)
{
if(isLiteral)
{
writer.WriteKeyword("Const");
}
else
{
writer.WriteKeyword("Shared");
}
writer.WriteString(" ");
}
if(isInitOnly)
{
writer.WriteKeyword("ReadOnly");
writer.WriteString(" ");
}
writer.WriteIdentifier(name);
writer.WriteString(" ");
writer.WriteKeyword("As");
writer.WriteString(" ");
WriteTypeReference(type, writer);
}
private static void WriteVisibility(string visibility, SyntaxWriter writer)
{
if(visibilityDictionary.ContainsKey(visibility) && visibilityDictionary[visibility] != null)
{
writer.WriteKeyword(visibilityDictionary[visibility]);
writer.WriteString(" ");
}
}
/// <inheritdoc />
public override void WriteClassSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
string name = (string)reflection.Evaluate(apiNameExpression);
bool isAbstract = (bool)reflection.Evaluate(apiIsAbstractTypeExpression);
bool isSealed = (bool)reflection.Evaluate(apiIsSealedTypeExpression);
bool isSerializable = (bool)reflection.Evaluate(apiIsSerializableTypeExpression);
if(isSerializable)
WriteAttribute("T:System.SerializableAttribute", writer);
WriteAttributes(reflection, writer);
WriteVisibility(reflection, writer);
writer.WriteString(" ");
if(isAbstract)
{
if(isSealed)
{
// static -- VB doesn't really handle this case
writer.WriteKeyword("NotInheritable");
writer.WriteString(" ");
}
else
{
writer.WriteKeyword("MustInherit");
writer.WriteString(" ");
}
}
else if(isSealed)
{
writer.WriteKeyword("NotInheritable");
writer.WriteString(" ");
}
writer.WriteKeyword("Class");
writer.WriteString(" ");
writer.WriteIdentifier(name);
WriteGenericTemplates(reflection, writer);
WriteBaseClass(reflection, writer);
WriteImplementedInterfaces(reflection, writer);
}
/// <inheritdoc />
public override void WriteDelegateSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
// !EFW - Added unsafe check
if(IsUnsupportedUnsafe(reflection, writer))
return;
string name = (string)reflection.Evaluate(apiNameExpression);
bool isSerializable = (bool)reflection.Evaluate(apiIsSerializableTypeExpression);
if(isSerializable)
WriteAttribute("T:System.SerializableAttribute", true, writer);
WriteAttributes(reflection, writer);
writer.WriteKeyword("type");
writer.WriteString(" ");
writer.WriteIdentifier(name);
writer.WriteString(" = ");
writer.WriteLine();
writer.WriteString(" ");
writer.WriteKeyword("delegate");
writer.WriteString(" ");
writer.WriteKeyword("of");
writer.WriteString(" ");
WriteParameters(reflection, writer);
writer.WriteKeyword("->");
writer.WriteString(" ");
WriteReturnValue(reflection, writer);
}
// Parameters
private void WriteParameters(XPathNavigator reflection, SyntaxWriter writer)
{
XPathNodeIterator parameters = reflection.Select(apiParametersExpression);
if(parameters.Count > 0)
WriteParameters(parameters, writer);
else
{
writer.WriteKeyword("unit");
writer.WriteString(" ");
}
}
/// <inheritdoc />
public override void WritePropertySyntax(XPathNavigator reflection, SyntaxWriter writer)
{
if (reflection == null)
{
throw new ArgumentNullException(nameof(reflection));
}
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
if (IsUnsupportedUnsafe(reflection, writer))
{
return;
}
if (IsUnsupportedExplicit(reflection, writer))
{
return;
}
if (reflection.Select(apiParametersExpression).Count > 0)
{
writer.WriteMessage("UnsupportedIndex_" + Language);
return;
}
string name = (string)reflection.Evaluate(apiNameExpression);
bool isGettable = (bool)reflection.Evaluate(apiIsReadPropertyExpression);
bool isSettable = (bool)reflection.Evaluate(apiIsWritePropertyExpression);
XPathNavigator type = reflection.SelectSingleNode(apiReturnTypeExpression);
if (isGettable)
{
string getVisibility = (string)reflection.Evaluate(apiGetVisibilityExpression);
if (!String.IsNullOrEmpty(getVisibility))
{
WriteVisibility(getVisibility, writer);
writer.WriteString(" ");
}
WriteProcedureModifiers(reflection, writer);
writer.WriteKeyword("function get");
writer.WriteString(" ");
writer.WriteIdentifier(name);
// Some F# properties don't generate return type info for some reason. It's probably unsupported
// but just ignore them for now and write out what we do have.
if (type != null)
{
writer.WriteString(" () : ");
WriteTypeReference(type, writer);
}
else
{
writer.WriteString(" ()");
}
writer.WriteLine();
}
if (isSettable)
{
string setVisibility = (string)reflection.Evaluate(apiSetVisibilityExpression);
if (!String.IsNullOrEmpty(setVisibility))
{
WriteVisibility(setVisibility, writer);
writer.WriteString(" ");
}
WriteProcedureModifiers(reflection, writer);
writer.WriteKeyword("function set");
writer.WriteString(" ");
writer.WriteIdentifier(name);
writer.WriteString(" (");
writer.WriteParameter("value");
// Some F# properties don't generate return type info for some reason. It's probably unsupported
// but just ignore them for now and write out what we do have.
if (type != null)
{
writer.WriteString(" : ");
WriteTypeReference(type, writer);
}
writer.WriteString(")");
}
}
// Return Value
private void WriteReturnValue(XPathNavigator reflection, SyntaxWriter writer)
{
XPathNavigator type = reflection.SelectSingleNode(apiReturnTypeExpression);
if(type == null)
writer.WriteKeyword("unit");
else
WriteTypeReference(type, writer);
}
/// <inheritdoc />
public override void WriteConstructorSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
if(IsUnsupportedUnsafe(reflection, writer))
return;
bool isStatic = (bool)reflection.Evaluate(apiIsStaticExpression);
WriteAttributes(reflection, writer);
if(isStatic)
{
writer.WriteKeyword("Shared");
}
else
{
WriteVisibility(reflection, writer);
}
writer.WriteString(" ");
writer.WriteKeyword("Sub");
writer.WriteString(" ");
writer.WriteIdentifier("New");
WriteParameters(reflection, writer);
}
/// <inheritdoc />
public override void WriteEnumerationSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
string name = (string)reflection.Evaluate(apiNameExpression);
bool isSerializable = (bool)reflection.Evaluate(apiIsSerializableTypeExpression);
if(isSerializable)
WriteAttribute("T:System.SerializableAttribute", true, writer);
WriteAttributes(reflection, writer);
writer.WriteKeyword("type");
writer.WriteString(" ");
WriteVisibility(reflection, writer);
writer.WriteIdentifier(name);
}
/// <inheritdoc />
public override void WriteNormalMethodSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
// !EFW - Added unsafe check
if(IsUnsupportedUnsafe(reflection, writer))
return;
if(IsUnsupportedVarargs(reflection, writer))
return;
string name = (string)reflection.Evaluate(apiNameExpression);
XPathNavigator type = reflection.SelectSingleNode(apiReturnTypeExpression);
bool isExplicit = (bool)reflection.Evaluate(apiIsExplicitImplementationExpression);
WriteAttributes(reflection, writer);
WriteProcedureModifiers(reflection, writer);
if(type == null)
writer.WriteKeyword("Sub");
else
writer.WriteKeyword("Function");
writer.WriteString(" ");
writer.WriteIdentifier(name);
WriteGenericTemplates(reflection, writer);
WriteParameters(reflection, writer);
if(type != null)
{
writer.WriteString(" ");
writer.WriteKeyword("As");
writer.WriteString(" ");
WriteTypeReference(type, writer);
}
if(isExplicit)
{
if(writer.Position > MaxPosition)
{
writer.WriteLine();
writer.WriteString("\t");
}
else
writer.WriteString(" ");
writer.WriteKeyword("Implements");
writer.WriteString(" ");
XPathNodeIterator implementations = reflection.Select(apiImplementedMembersExpression);
while(implementations.MoveNext())
{
XPathNavigator implementation = implementations.Current;
XPathNavigator contract = implementation.SelectSingleNode(attributeTypeExpression);
// string id = implementation.GetAttribute("api", String.Empty);
if(implementations.CurrentPosition > 1)
writer.WriteString(", ");
WriteTypeReference(contract, writer);
writer.WriteString(".");
WriteMemberReference(implementation, writer);
}
}
}
/// <inheritdoc />
public override void WriteNormalMethodSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
// !EFW - Added unsafe check
if(IsUnsupportedUnsafe(reflection, writer))
return;
if(IsUnsupportedVarargs(reflection, writer))
return;
string name = (string)reflection.Evaluate(apiNameExpression);
bool isStatic = (bool)reflection.Evaluate(apiIsStaticExpression);
bool isVirtual = (bool)reflection.Evaluate(apiIsVirtualExpression) && !(bool)reflection.Evaluate(apiIsAbstractProcedureExpression);
int iterations = isVirtual ? 2 : 1;
for(int i = 0; i < iterations; i++)
{
WriteAttributes(reflection, writer);
WriteVisibility(reflection, writer);
if(isStatic)
{
writer.WriteKeyword("static");
writer.WriteString(" ");
}
if(isVirtual)
if(i == 0)
{
writer.WriteKeyword("abstract");
writer.WriteString(" ");
}
else
{
writer.WriteKeyword("override");
writer.WriteString(" ");
}
else
{
WriteMemberKeyword(reflection, writer);
}
writer.WriteIdentifier(name);
writer.WriteString(" : ");
WriteParameters(reflection, writer);
writer.WriteKeyword("->");
writer.WriteString(" ");
WriteReturnValue(reflection, writer);
writer.WriteString(" ");
WriteGenericTemplateConstraints(reflection, writer);
if(i == 0)
writer.WriteLine();
}
}
/// <inheritdoc />
public override void WriteOperatorSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
string name = (string)reflection.Evaluate(apiNameExpression);
XPathNavigator type = reflection.SelectSingleNode(apiReturnTypeExpression);
string identifier = null;
if(!(bool)reflection.Evaluate(apiIsUdtReturnExpression))
{
switch(name)
{
// unary math operators
case "UnaryPlus":
identifier = "+";
break;
case "UnaryNegation":
identifier = "-";
break;
case "Increment":
identifier = "++";
break;
case "Decrement":
identifier = "--";
break;
// unary logical operators
case "LogicalNot":
identifier = "Not";
break;
case "True":
identifier = "IsTrue";
break;
case "False":
identifier = "IsFalse";
break;
// binary comparison operators
case "Equality":
identifier = "=";
break;
case "Inequality":
identifier = "<>";
break;
case "LessThan":
identifier = "<";
break;
case "GreaterThan":
identifier = ">";
break;
case "LessThanOrEqual":
identifier = "<=";
break;
case "GreaterThanOrEqual":
identifier = ">=";
break;
// binary math operators
case "Addition":
identifier = "+";
break;
case "Subtraction":
identifier = "-";
break;
case "Multiply":
identifier = "*";
break;
case "Division":
identifier = "/";
break;
case "Exponent":
identifier = "^";
break;
case "Modulus":
identifier = "Mod";
break;
case "IntegerDivision":
identifier = @"\";
break;
// binary logical operators
case "BitwiseAnd":
identifier = "And";
break;
case "BitwiseOr":
identifier = "Or";
break;
case "ExclusiveOr":
identifier = "Xor";
break;
// bit-array operators
case "OnesComplement":
identifier = "~";
break;
case "LeftShift":
identifier = "<<";
break;
case "RightShift":
identifier = ">>";
break;
// concatenation
case "Concatenate":
identifier = "&";
break;
// casting operators
case "Implicit":
case "Explicit":
identifier = "CType";
break;
case "Assign":
identifier = "=";
break;
// didn't recognize an operator
default:
identifier = null;
break;
}
}
if(identifier == null)
{
writer.WriteMessage("UnsupportedOperator_" + Language);
return;
}
WriteProcedureModifiers(reflection, writer);
if(name == "Implicit")
{
writer.WriteKeyword("Widening");
writer.WriteString(" ");
}
else if(name == "Explicit")
{
writer.WriteKeyword("Narrowing");
writer.WriteString(" ");
}
writer.WriteKeyword("Operator");
writer.WriteString(" ");
writer.WriteIdentifier(identifier);
WriteParameters(reflection, writer);
writer.WriteString(" ");
writer.WriteKeyword("As");
writer.WriteString(" ");
WriteTypeReference(type, writer);
}
/// <inheritdoc />
public override void WritePropertySyntax(XPathNavigator reflection, SyntaxWriter writer)
{
// !EFW - Added unsafe check
if(IsUnsupportedUnsafe(reflection, writer))
return;
string name = (string)reflection.Evaluate(apiNameExpression);
bool isGettable = (bool)reflection.Evaluate(apiIsReadPropertyExpression);
bool isSettable = (bool)reflection.Evaluate(apiIsWritePropertyExpression);
bool isStatic = (bool)reflection.Evaluate(apiIsStaticExpression);
bool isVirtual = (bool)reflection.Evaluate(apiIsVirtualExpression) && !(bool)reflection.Evaluate(apiIsAbstractProcedureExpression);
int iterations = isVirtual ? 2 : 1;
for(int i = 0; i < iterations; i++)
{
WriteAttributes(reflection, writer);
WriteVisibility(reflection, writer);
if(isStatic)
{
writer.WriteKeyword("static");
writer.WriteString(" ");
}
if(isVirtual)
if(i == 0)
{
writer.WriteKeyword("abstract");
writer.WriteString(" ");
}
else
{
writer.WriteKeyword("override");
writer.WriteString(" ");
}
else
{
WriteMemberKeyword(reflection, writer);
}
writer.WriteIdentifier(name);
writer.WriteString(" : ");
WriteReturnValue(reflection, writer);
writer.WriteString(" ");
writer.WriteKeyword("with");
writer.WriteString(" ");
if(isGettable)
{
// !EFW - Added support for getter/setter attributes
XPathNavigator getter = reflection.SelectSingleNode(apiGetterExpression);
if(getter != null && getter.HasChildren)
{
writer.WriteLine();
writer.WriteString("\t");
this.WriteAttributes(getter, writer, "\t");
writer.WriteString("\t");
}
string getVisibility = (string)reflection.Evaluate(apiGetVisibilityExpression);
if(!String.IsNullOrEmpty(getVisibility))
{
WriteVisibility(getVisibility, writer);
}
writer.WriteKeyword("get");
}
if(isSettable)
{
if(isGettable)
writer.WriteString(", ");
// !EFW - Added support for getter/setter attributes
XPathNavigator setter = reflection.SelectSingleNode(apiSetterExpression);
if(setter != null && setter.HasChildren)
{
writer.WriteLine();
writer.WriteString("\t");
this.WriteAttributes(setter, writer, "\t");
writer.WriteString("\t");
}
string setVisibility = (string)reflection.Evaluate(apiSetVisibilityExpression);
if(!String.IsNullOrEmpty(setVisibility))
{
WriteVisibility(setVisibility, writer);
}
writer.WriteKeyword("set");
}
if(i == 0)
writer.WriteLine();
}
}
/// <inheritdoc />
public override void WritePropertySyntax(XPathNavigator reflection, SyntaxWriter writer)
{
if(IsUnsupportedUnsafe(reflection, writer))
return;
string name = (string)reflection.Evaluate(apiNameExpression);
bool hasGetter = (bool)reflection.Evaluate(apiIsReadPropertyExpression);
bool hasSetter = (bool)reflection.Evaluate(apiIsWritePropertyExpression);
bool isDefault = (bool)reflection.Evaluate(apiIsDefaultMemberExpression);
bool isExplicit = (bool)reflection.Evaluate(apiIsExplicitImplementationExpression);
XPathNavigator type = reflection.SelectSingleNode(apiReturnTypeExpression);
WriteAttributes(reflection, writer);
WriteProcedureModifiers(reflection, writer);
if(hasGetter && !hasSetter)
{
writer.WriteKeyword("ReadOnly");
writer.WriteString(" ");
}
else if(hasSetter && !hasGetter)
{
writer.WriteKeyword("WriteOnly");
writer.WriteString(" ");
}
if(isDefault)
{
writer.WriteKeyword("Default");
writer.WriteString(" ");
}
writer.WriteKeyword("Property");
writer.WriteString(" ");
writer.WriteIdentifier(name);
WriteParameters(reflection, writer);
writer.WriteString(" ");
writer.WriteKeyword("As");
writer.WriteString(" ");
WriteTypeReference(type, writer);
if(isExplicit)
{
if(writer.Position > MaxPosition)
{
writer.WriteLine();
writer.WriteString("\t");
}
else
{
writer.WriteString(" ");
}
writer.WriteKeyword("Implements");
writer.WriteString(" ");
XPathNodeIterator implementations = reflection.Select(apiImplementedMembersExpression);
while(implementations.MoveNext())
{
XPathNavigator implementation = implementations.Current;
XPathNavigator contract = implementation.SelectSingleNode(memberDeclaringTypeExpression);
//string id = implementation.GetAttribute("api", String.Empty);
if(implementations.CurrentPosition > 1)
writer.WriteString(", ");
WriteTypeReference(contract, writer);
writer.WriteString(".");
WriteMemberReference(implementation, writer);
//writer.WriteReferenceLink(id);
}
}
if(hasGetter)
{
writer.WriteLine();
// !EFW - Added support for getter/setter attributes
XPathNavigator getter = reflection.SelectSingleNode(apiGetterExpression);
if(getter != null && getter.HasChildren)
{
writer.WriteString("\t");
this.WriteAttributes(getter, writer, "\t");
}
writer.WriteString("\t");
string getVisibility = (string)reflection.Evaluate(apiGetVisibilityExpression);
if(!String.IsNullOrEmpty(getVisibility))
{
WriteVisibility(getVisibility, writer);
writer.WriteString(" ");
}
writer.WriteKeyword("Get");
}
if(hasSetter)
{
writer.WriteLine();
// !EFW - Added support for getter/setter attributes
XPathNavigator setter = reflection.SelectSingleNode(apiSetterExpression);
if(setter != null && setter.HasChildren)
{
writer.WriteString("\t");
this.WriteAttributes(setter, writer, "\t");
}
writer.WriteString("\t");
string setVisibility = (string)reflection.Evaluate(apiSetVisibilityExpression);
if(!String.IsNullOrEmpty(setVisibility))
{
WriteVisibility(setVisibility, writer);
writer.WriteString(" ");
}
writer.WriteKeyword("Set");
}
}
/// <inheritdoc />
public override void WriteFieldSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
// !EFW - Added unsafe check
if(IsUnsupportedUnsafe(reflection, writer))
return;
string name = (string)reflection.Evaluate(apiNameExpression);
bool isStatic = (bool)reflection.Evaluate(apiIsStaticExpression);
bool isInitOnly = (bool)reflection.Evaluate(apiIsInitOnlyFieldExpression);
bool isSerialized = (bool)reflection.Evaluate(apiIsSerializedFieldExpression);
if(!isSerialized)
WriteAttribute("T:System.NonSerializedAttribute", true, writer);
WriteAttributes(reflection, writer);
if(isStatic)
{
writer.WriteKeyword("static");
writer.WriteString(" ");
}
writer.WriteKeyword("val");
writer.WriteString(" ");
if(!isInitOnly)
{
writer.WriteKeyword("mutable");
writer.WriteString(" ");
}
WriteVisibility(reflection, writer);
writer.WriteIdentifier(name);
writer.WriteString(": ");
WriteReturnValue(reflection, writer);
}
/// <inheritdoc />
public override void WriteEventSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
// !EFW - Added unsafe check
if(IsUnsupportedUnsafe(reflection, writer))
return;
string name = (string)reflection.Evaluate(apiNameExpression);
XPathNavigator handler = reflection.SelectSingleNode(apiHandlerOfEventExpression);
WriteAttributes(reflection, writer);
WriteProcedureModifiers(reflection, writer);
writer.WriteString("Event");
writer.WriteString(" ");
writer.WriteIdentifier(name);
writer.WriteString(" ");
writer.WriteKeyword("As");
writer.WriteString(" ");
WriteTypeReference(handler, writer);
WriteExplicitImplementations(reflection, writer);
}
private void WriteExplicitImplementations(XPathNavigator reflection, SyntaxWriter writer)
{
bool isExplicit = (bool)reflection.Evaluate(apiIsExplicitImplementationExpression);
if(isExplicit)
{
if(writer.Position > MaxPosition)
{
writer.WriteLine();
writer.WriteString("\t");
}
else
writer.WriteString(" ");
writer.WriteKeyword("Implements");
writer.WriteString(" ");
XPathNodeIterator implementations = reflection.Select(apiImplementedMembersExpression);
while(implementations.MoveNext())
{
XPathNavigator implementation = implementations.Current;
XPathNavigator contract = implementation.SelectSingleNode(memberDeclaringTypeExpression);
//string id = implementation.GetAttribute("api", String.Empty);
if(implementations.CurrentPosition > 1)
writer.WriteString(", ");
WriteTypeReference(contract, writer);
writer.WriteString(".");
WriteMemberReference(implementation, writer);
//writer.WriteReferenceLink(id);
}
}
}
private void WriteValue(XPathNavigator parent, SyntaxWriter writer)
{
XPathNavigator type = parent.SelectSingleNode(attributeTypeExpression);
XPathNavigator value = parent.SelectSingleNode(valueExpression);
switch (value.LocalName)
{
case "nullValue":
writer.WriteKeyword("null");
break;
case "defaultValue":
// I'm making an assumption about syntax here
writer.WriteString("new ");
this.WriteTypeReference(type, writer);
writer.WriteString("()");
break;
case "typeValue":
// this isn't really supported in J#; there is no compile-time way to get a type representation
// writer.WriteKeyword("typeof");
// writer.WriteString("(");
WriteTypeReference(value.SelectSingleNode(typeExpression), writer);
// writer.WriteString(")");
break;
case "enumValue":
XPathNodeIterator fields = value.SelectChildren(XPathNodeType.Element);
while (fields.MoveNext())
{
string name = fields.Current.GetAttribute("name", String.Empty);
if (fields.CurrentPosition > 1)
{
writer.WriteString("|");
}
WriteTypeReference(type, writer);
writer.WriteString(".");
writer.WriteString(name);
}
break;
case "value":
string text = value.Value;
string typeId = type.GetAttribute("api", String.Empty);
switch (typeId)
{
case "T:System.String":
writer.WriteString("\"");
writer.WriteString(text);
writer.WriteString("\"");
break;
case "T:System.Boolean":
writer.WriteKeyword(Convert.ToBoolean(text, CultureInfo.InvariantCulture) ?
"true" : "false");
break;
case "T:System.Char":
writer.WriteString("'");
writer.WriteString(text);
writer.WriteString("'");
break;
// !EFW - Bug fix. Support numeric values and other potential types.
// Note that decimal isn't supported as an attribute value so it is omitted.
case "T:System.Byte":
case "T:System.Double":
case "T:System.SByte":
case "T:System.Int16":
case "T:System.Int64":
case "T:System.Int32":
case "T:System.UInt16":
case "T:System.UInt32":
case "T:System.UInt64":
writer.WriteString(text);
break;
case "T:System.Single":
writer.WriteString(text);
writer.WriteString("f");
break;
default:
// If not a recognized type, just write out the value so that something shows
if (type.LocalName != "arrayOf")
{
writer.WriteString(text);
}
else
{
// It's an array. We don't get the values so just write out the type.
writer.WriteString("new ");
this.WriteTypeReference(type, writer);
writer.WriteString(" { ... }");
}
break;
}
break;
}
}
// Write member | abstract | override
private static void WriteMemberKeyword(XPathNavigator reflection, SyntaxWriter writer)
{
bool isOverride = (bool)reflection.Evaluate(apiIsOverrideExpression);
bool isAbstract = (bool)reflection.Evaluate(apiIsAbstractProcedureExpression);
if(isOverride)
writer.WriteKeyword("override");
else
if(isAbstract)
writer.WriteKeyword("abstract");
else
writer.WriteKeyword("member");
writer.WriteString(" ");
}
/// <summary>
/// Write out property syntax if supported
/// </summary>
/// <param name="reflection">The reflection information</param>
/// <param name="writer">The syntax writer to which it is written</param>
public override void WritePropertySyntax(XPathNavigator reflection, SyntaxWriter writer)
{
if (reflection == null)
{
throw new ArgumentNullException(nameof(reflection));
}
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
if (this.IsUnsupported(reflection, writer))
{
return;
}
if (HasAttribute(reflection, "System.IntrinsicPropertyAttribute"))
{
this.WriteFieldSyntax(reflection, writer);
return;
}
string identifier = ReadMemberName(reflection);
bool isStatic = (bool)reflection.Evaluate(apiIsStaticExpression);
bool isReadProp = (bool)reflection.Evaluate(apiIsReadPropertyExpression);
bool isWriteProp = (bool)reflection.Evaluate(apiIsWritePropertyExpression);
if (isReadProp)
{
if (isStatic)
{
writer.WriteIdentifier(ReadFullContainingTypeName(reflection));
writer.WriteString(".");
writer.WriteString("get_");
writer.WriteIdentifier(identifier);
writer.WriteString(" = ");
writer.WriteKeyword("function");
}
else
{
writer.WriteKeyword("function");
writer.WriteString(" ");
writer.WriteString("get_");
writer.WriteIdentifier(identifier);
}
WriteParameterList(reflection, writer);
writer.WriteString(";");
writer.WriteLine();
}
if (isWriteProp)
{
if (isStatic)
{
writer.WriteIdentifier(ReadFullContainingTypeName(reflection));
writer.WriteString(".");
writer.WriteString("set_");
writer.WriteIdentifier(identifier);
writer.WriteString(" = ");
writer.WriteKeyword("function");
}
else
{
writer.WriteKeyword("function");
writer.WriteString(" ");
writer.WriteString("set_");
writer.WriteIdentifier(identifier);
}
writer.WriteString("(");
writer.WriteParameter("value");
writer.WriteString(");");
}
}
private void WriteValue(XPathNavigator parent, SyntaxWriter writer)
{
XPathNavigator type = parent.SelectSingleNode(attributeTypeExpression);
XPathNavigator value = parent.SelectSingleNode(valueExpression);
switch(value.LocalName)
{
case "nullValue":
writer.WriteKeyword("null");
break;
case "typeValue":
writer.WriteKeyword("typeof");
writer.WriteString("(");
WriteTypeReference(value.SelectSingleNode(typeExpression), writer);
writer.WriteString(")");
break;
case "enumValue":
XPathNodeIterator fields = value.SelectChildren(XPathNodeType.Element);
while(fields.MoveNext())
{
string name = fields.Current.GetAttribute("name", String.Empty);
if(fields.CurrentPosition > 1)
writer.WriteString("|");
WriteTypeReference(type, writer);
writer.WriteString(".");
writer.WriteString(name);
}
break;
case "value":
string text = value.Value;
string typeId = type.GetAttribute("api", String.Empty);
switch(typeId)
{
case "T:System.String":
writer.WriteString("\"");
writer.WriteString(text);
writer.WriteString("\"");
break;
case "T:System.Boolean":
writer.WriteKeyword(Convert.ToBoolean(text, CultureInfo.InvariantCulture) ?
"true" : "false");
break;
case "T:System.Char":
writer.WriteString("'");
writer.WriteString(text);
writer.WriteString("'");
break;
// !EFW - Bug fix. Support numeric values and other potential types.
// Note that decimal isn't supported as an attribute value so it is omitted.
case "T:System.Byte":
case "T:System.Double":
case "T:System.SByte":
case "T:System.Int16":
case "T:System.Int64":
case "T:System.Int32":
case "T:System.UInt16":
case "T:System.UInt32":
case "T:System.UInt64":
writer.WriteString(text);
break;
case "T:System.Single":
writer.WriteString(text);
writer.WriteString("f");
break;
default:
// If not a recognized type, just write out the value so that something shows
if(type.LocalName != "arrayOf")
writer.WriteString(text);
else
{
// It's an array. We don't get the values so just write out the type.
writer.WriteString("new ");
this.WriteTypeReference(type, writer);
writer.WriteString(" { ... }");
}
break;
}
break;
}
}
/// <inheritdoc />
public override void WriteDelegateSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
if(IsUnsupportedUnsafe(reflection, writer))
return;
string name = (string)reflection.Evaluate(apiNameExpression);
bool isSerializable = (bool)reflection.Evaluate(apiIsSerializableTypeExpression);
XPathNavigator type = reflection.SelectSingleNode(apiReturnTypeExpression);
if(isSerializable)
WriteAttribute("T:System.SerializableAttribute", writer);
WriteAttributes(reflection, writer);
WriteVisibility(reflection, writer);
writer.WriteString(" ");
writer.WriteKeyword("Delegate");
writer.WriteString(" ");
if(type == null)
{
writer.WriteKeyword("Sub");
}
else
{
writer.WriteKeyword("Function");
}
writer.WriteString(" ");
writer.WriteIdentifier(name);
WriteGenericTemplates(reflection, writer, true); // Need to write variance info for interfaces and delegates
WriteParameters(reflection, writer);
if(type != null)
{
writer.WriteString(" ");
writer.WriteKeyword("As");
writer.WriteString(" ");
WriteTypeReference(type, writer);
}
}