private void WriteGenericTemplates(XPathNavigator type, SyntaxWriter writer, bool writeVariance)
{
XPathNodeIterator templates = type.Select(apiTemplatesExpression);
if (templates.Count == 0) return;
writer.WriteString("(");
writer.WriteKeyword("Of");
writer.WriteString(" ");
while (templates.MoveNext())
{
XPathNavigator template = templates.Current;
if (templates.CurrentPosition > 1) writer.WriteString(", ");
if (writeVariance)
{
bool contravariant = (bool)template.Evaluate(templateIsContravariantExpression);
bool covariant = (bool)template.Evaluate(templateIsCovariantExpression);
if (contravariant)
{
writer.WriteKeyword("In");
writer.WriteString(" ");
}
if (covariant)
{
writer.WriteKeyword("Out");
writer.WriteString(" ");
}
}
string name = template.GetAttribute("name", String.Empty);
writer.WriteString(name);
}
writer.WriteString(")");
}
// class: done
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);
}
// class: done
public override void WriteClassSyntax (XPathNavigator reflection, SyntaxWriter writer) {
string name = reflection.Evaluate(apiNameExpression).ToString();
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) {
writer.WriteKeyword("static");
} else {
writer.WriteKeyword("abstract");
}
writer.WriteString(" ");
} else {
if (isSealed) {
writer.WriteKeyword("sealed");
writer.WriteString(" ");
}
}
writer.WriteKeyword("class");
writer.WriteString(" ");
writer.WriteIdentifier(name);
WriteGenericTemplates(reflection, writer);
WriteBaseClassAndImplementedInterfaces(reflection, writer);
WriteGenericTemplateConstraints(reflection, writer);
}
public override void WriteClassSyntax (XPathNavigator reflection, SyntaxWriter writer) {
if (IsUnsupportedGeneric(reflection, writer)) return;
string name = reflection.Evaluate(apiNameExpression).ToString();
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 (isSealed) {
writer.WriteKeyword("final");
writer.WriteString(" ");
} else if (isAbstract) {
writer.WriteKeyword("abstract");
writer.WriteString(" ");
}
writer.WriteKeyword("class");
writer.WriteString(" ");
writer.WriteIdentifier(name);
XPathNavigator baseClass = reflection.SelectSingleNode(apiBaseClassExpression);
if ((baseClass != null) && !((bool) baseClass.Evaluate(typeIsObjectExpression))) {
writer.WriteString(" ");
writer.WriteKeyword("extends");
writer.WriteString(" ");
WriteTypeReference(baseClass, writer);
}
WriteImplementedInterfaces(reflection, writer);
}
public override void WriteSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
writer.WriteStartBlock(Language);
// Check the list of assemblies for which to generate XAML syntax
string assemblyName = (string)reflection.Evaluate(apiContainingAssemblyExpression);
string namespaceName = (string)reflection.Evaluate(apiContainingNamespaceNameExpression);
if (!xamlAssemblies.ContainsKey(assemblyName.ToLower()))
{
WriteXamlBoilerplate(XamlBoilerplateID.nonXamlAssemblyBoilerplate, writer);
}
else
{
string group = (string)reflection.Evaluate(apiGroupExpression);
switch (group)
{
case "namespace":
WriteNamespaceSyntax(reflection, writer);
break;
case "type":
WriteTypeSyntax(reflection, writer);
break;
case "member":
WriteMemberSyntax(reflection, writer);
break;
}
WriteXamlXmlnsUri(assemblyName, namespaceName, writer);
}
writer.WriteEndBlock();
}
public override void WriteDelegateSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
string name = (string)reflection.Evaluate(apiNameExpression);
bool isSerializable = (bool)reflection.Evaluate(apiIsSerializableTypeExpression);
if (isSerializable) WriteAttribute("T:System.SerializableAttribute", 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);
}
public override void WriteSyntax (XPathNavigator reflection, SyntaxWriter writer) {
string group = (string)reflection.Evaluate(groupExpression);
string subgroup = (string)reflection.Evaluate(subgroupExpression);
if (group == "type" && subgroup == "class") {
string prefix = WebControlPrefix(reflection);
if (!String.IsNullOrEmpty(prefix)) {
WriteClassSyntax(reflection, writer, prefix);
}
}
if (group == "member") {
string prefix = null;
XPathNavigator containingType = reflection.SelectSingleNode(containingTypeExpression);
if (containingType != null) prefix = WebControlPrefix(containingType);
if (!String.IsNullOrEmpty(prefix)) {
if (subgroup == "property") {
WritePropertySyntax(reflection, writer, prefix);
} else if (subgroup == "event") {
WriteEventSyntax(reflection, writer, prefix);
}
}
}
}
public override void WriteNamespaceSyntax (XPathNavigator reflection, SyntaxWriter writer) {
string name = (string)reflection.Evaluate(apiNameExpression);
writer.WriteKeyword("package");
writer.WriteString(" ");
writer.WriteIdentifier(name);
}
public override void WriteEnumerationSyntax (XPathNavigator reflection, SyntaxWriter writer) {
string name = (string)reflection.Evaluate(apiNameExpression);
WriteAttributeList(reflection, writer);
WriteAccessModifier(reflection, writer);
writer.WriteKeyword("enum");
writer.WriteString(" ");
writer.WriteString(name);
// no JScript support for underlying types
}
public override void WriteInterfaceSyntax (XPathNavigator reflection, SyntaxWriter writer) {
if (IsUnsupportedGeneric(reflection, writer)) return;
string name = (string)reflection.Evaluate(apiNameExpression);
WriteAttributeList(reflection, writer);
WriteAccessModifier(reflection, writer);
writer.WriteKeyword("interface");
writer.WriteString(" ");
writer.WriteString(name);
WriteInterfaceList("extends", reflection, writer);
}
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", writer);
WriteAttributes(reflection, writer);
writer.WriteKeyword("type");
writer.WriteString(" ");
WriteVisibility(reflection, writer);
writer.WriteIdentifier(name);
}
// interface: done
public override void WriteInterfaceSyntax (XPathNavigator reflection, SyntaxWriter writer) {
string name = (string) reflection.Evaluate(apiNameExpression);
WriteAttributes(reflection, writer);
WriteVisibility(reflection, writer);
writer.WriteString(" ");
writer.WriteKeyword("Interface");
writer.WriteString(" ");
writer.WriteIdentifier(name);
WriteGenericTemplates(reflection, writer, true); // Need to write variance info for interfaces and delegates
WriteImplementedInterfaces(reflection, writer);
}
public override void WriteConstructorSyntax (XPathNavigator reflection, SyntaxWriter writer) {
bool isStatic = (bool)reflection.Evaluate(apiIsStaticExpression);
if (isStatic) {
writer.WriteMessage("UnsupportedStaticConstructor_" + Language);
} else {
if (IsUnsupportedUnsafe(reflection, writer)) return;
XPathNavigator declaringType = reflection.SelectSingleNode(apiContainingTypeExpression);
WriteAttributeList(reflection, writer);
WriteAccessModifier(reflection, writer);
writer.WriteKeyword("function");
writer.WriteString(" ");
WriteTypeReference(declaringType, writer);
WriteParameterList(reflection, writer);
}
}
public override void WriteInterfaceSyntax (XPathNavigator reflection, SyntaxWriter writer) {
string name = (string) reflection.Evaluate(apiNameExpression);
WriteAttributes(reflection, writer);
WriteGenericTemplates(reflection, writer);
WriteVisibility(reflection, writer);
writer.WriteString(" ");
writer.WriteKeyword("interface class");
writer.WriteString(" ");
writer.WriteIdentifier(name);
WriteImplementedInterfaces(reflection, writer);
}
// structure: done
public override void WriteStructureSyntax (XPathNavigator reflection, SyntaxWriter writer) {
string name = (string) reflection.Evaluate(apiNameExpression);
bool isSerializable = (bool) reflection.Evaluate(apiIsSerializableTypeExpression);
if (isSerializable) WriteAttribute("T:System.SerializableAttribute", writer);
WriteAttributes(reflection, writer);
WriteVisibility(reflection, writer);
writer.WriteString(" ");
writer.WriteKeyword("struct");
writer.WriteString(" ");
writer.WriteIdentifier(name);
WriteGenericTemplates(reflection, writer);
WriteImplementedInterfaces(reflection, writer);
WriteGenericTemplateConstraints(reflection, writer);
}
private void WriteXamlXmlnsUri(string assemblyName, string namespaceName, SyntaxWriter writer)
{
Dictionary<string, List<string>> clrNamespaces;
if (xamlAssemblies.TryGetValue(assemblyName.ToLower(), out clrNamespaces))
{
List<string> xmlnsUriList;
if (clrNamespaces.TryGetValue(namespaceName, out xmlnsUriList))
{
foreach (string xmlnsUri in xmlnsUriList)
{
// start the syntax block
writer.WriteStartSubBlock("xamlXmlnsUri");
writer.WriteString(xmlnsUri);
writer.WriteEndSubBlock();
}
}
}
}
/// <summary>
/// Determines whether the feature is unsupported by this language.
/// </summary>
/// <param name="reflection"></param>
/// <param name="writer"></param>
/// <returns></returns>
private bool IsUnsupported(XPathNavigator reflection, SyntaxWriter writer) {
if (IsUnsupportedGeneric(reflection, writer)) {
return true;
}
if (IsUnsupportedExplicit(reflection, writer)) {
return true;
}
if (IsUnsupportedUnsafe(reflection, writer)) {
return true;
}
if (HasAttribute(reflection, "System.NonScriptableAttribute")) {
writer.WriteMessage("UnsupportedType_ScriptSharp");
return true;
}
return false;
}
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);
WriteAttributeList(reflection, writer);
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);
}
private void TypeDeclaration (XPathNavigator reflection, SyntaxWriter writer, bool writeVariance) {
string name = (string)reflection.Evaluate(apiNameExpression);
XPathNavigator declaringType = reflection.SelectSingleNode(apiContainingTypeExpression);
writer.WriteKeyword("Dim");
writer.WriteString(" ");
writer.WriteParameter("instance");
writer.WriteString(" ");
writer.WriteKeyword("As");
writer.WriteString(" ");
if (declaringType != null) {
WriteTypeReference(declaringType, writer);
writer.WriteString(".");
}
if (reservedWords.ContainsKey(name)) {
writer.WriteString("[");
writer.WriteIdentifier(name);
writer.WriteString("]");
} else {
writer.WriteIdentifier(name);
}
WriteGenericTemplates(reflection, writer, writeVariance);
}
public override void WriteStructureSyntax (XPathNavigator reflection, SyntaxWriter writer) {
if (IsUnsupportedGeneric(reflection, writer)) return;
string name = (string) reflection.Evaluate(apiNameExpression);
bool isSerializable = (bool) reflection.Evaluate(apiIsSerializableTypeExpression);
if (isSerializable) WriteAttribute("T:System.SerializableAttribute", writer);
WriteAttributes(reflection, writer);
WriteVisibility(reflection, writer);
writer.WriteString(" ");
writer.WriteKeyword("final");
writer.WriteString(" ");
writer.WriteKeyword("class");
writer.WriteString(" ");
writer.WriteIdentifier(name);
writer.WriteString(" ");
writer.WriteKeyword("extends");
writer.WriteString(" ");
writer.WriteReferenceLink("T:System.ValueType");
WriteImplementedInterfaces(reflection, writer);
}
/// <inheritdoc />
public override void WriteEnumerationSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
WriteXamlBoilerplate(XamlBoilerplateID.enumerationOverviewXamlSyntax, writer);
}
/// <inheritdoc />
public override void WritePropertySyntax(XPathNavigator reflection, SyntaxWriter writer)
{
bool isSettable = (bool)reflection.Evaluate(apiIsWritePropertyExpression);
bool isSetterPublic = (bool)reflection.Evaluate(apiIsSetterPublicExpression);
bool isAbstract = (bool)reflection.Evaluate(apiIsAbstractProcedureExpression);
string propertyVisibility = (string)reflection.Evaluate(apiVisibilityExpression);
XPathNodeIterator parameters = reflection.Select(apiParametersExpression);
XPathNavigator returnType = reflection.SelectSingleNode(apiReturnTypeExpression);
bool notWriteableReturnType = (bool)returnType.Evaluate(noSettablePropertiesExpression);
string returnTypeId = returnType.GetAttribute("api", string.Empty);
string returnTypeSubgroup = (string)returnType.Evaluate(apiSubgroupExpression);
bool returnTypeIsAbstract = (bool)returnType.Evaluate(apiIsAbstractTypeExpression);
bool returnTypeIsReadonlyStruct = (returnTypeSubgroup == "structure" && notWriteableReturnType &&
!IsPrimitiveType(returnTypeId));
XPathNavigator containingType = reflection.SelectSingleNode(apiContainingTypeExpression);
string containingTypeSubgroup = (string)containingType.Evaluate(apiSubgroupExpression);
// an ordinary property, not an attached prop
if (containingTypeSubgroup == "interface")
{
WriteXamlBoilerplate(XamlBoilerplateID.propertyXamlSyntax_noXamlSyntaxForInterfaceMembers, writer);
}
else if ((bool)containingType.Evaluate(apiIsAbstractTypeExpression) &&
(bool)containingType.Evaluate(apiIsSealedTypeExpression))
{
// the property's containing type is static if it's abstract and sealed
// members of a static class cannot be used in XAML.
WriteXamlBoilerplate(XamlBoilerplateID.propertyXamlSyntax_nonXamlParent, writer);
}
else if (IsExcludedSubClass(containingType))
{
WriteXamlBoilerplate(XamlBoilerplateID.propertyXamlSyntax_parentIsExcludedSubClass, writer);
}
else if (!DoesParentSupportXaml(reflection))
{
WriteXamlBoilerplate(XamlBoilerplateID.propertyXamlSyntax_nonXamlParent, writer);
}
else if (propertyVisibility != "public")
{
WriteXamlBoilerplate(XamlBoilerplateID.propertyXamlSyntax_notPublic, writer);
}
else if (isAbstract)
{
WriteXamlBoilerplate(XamlBoilerplateID.propertyXamlSyntax_abstract, writer);
}
else if (parameters.Count > 0)
{
// per DDUERELTools bug 1373: indexer properties cannot be used in XAML
WriteXamlBoilerplate(XamlBoilerplateID.propertyXamlSyntax_nonXaml, writer);
}
else if (IsContentProperty(reflection) && !returnTypeIsReadonlyStruct)
{
PropertyContentElementUsageSimple(reflection, writer);
}
else if (!isSettable || !isSetterPublic)
{
WriteXamlBoilerplate(XamlBoilerplateID.propertyXamlSyntax_readOnly, writer);
}
else if (returnTypeIsAbstract && !HasTypeConverterAttribute(returnType)) // !EFW - Allow it if there's a type converter
{
WriteXamlBoilerplate(XamlBoilerplateID.propertyXamlSyntax_abstractType, returnType, writer);
}
else if (IsPrimitiveType(returnTypeId))
{
PropertyAttributeUsage(reflection, writer);
}
else if (returnTypeSubgroup == "enumeration")
{
PropertyAttributeUsage(reflection, writer);
}
else
{
bool hasDefaultConstructor = HasDefaultConstructor(returnType);
if (HasTypeConverterAttribute(returnType))
{
if (hasDefaultConstructor && !returnTypeIsReadonlyStruct)
{
PropertyElementUsageGrande(reflection, writer);
}
PropertyAttributeUsage(reflection, writer);
}
else if (hasDefaultConstructor && !returnTypeIsReadonlyStruct)
{
PropertyElementUsageGrande(reflection, writer);
}
else
{
WriteXamlBoilerplate(XamlBoilerplateID.propertyXamlSyntax_nonXaml, writer);
}
}
}
/// <inheritdoc />
public override void WriteFieldSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
WriteXamlBoilerplate(XamlBoilerplateID.fieldOverviewXamlSyntax, writer);
}
// operator: done
public override void WriteOperatorSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
string name = (string)reflection.Evaluate(apiNameExpression);
string identifier;
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 = "!";
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 = "~";
break;
case "LeftShift":
identifier = "<<";
break;
case "RightShift":
identifier = ">>";
break;
// unrecognized operator
default:
identifier = null;
break;
}
if (identifier == null)
{
writer.WriteMessage("UnsupportedOperator_" + Language);
}
else
{
WriteProcedureModifiers(reflection, writer);
WriteReturnValue(reflection, writer);
writer.WriteString(" ");
writer.WriteKeyword("operator");
writer.WriteString(" ");
writer.WriteIdentifier(identifier);
WriteMethodParameters(reflection, writer);
}
}
// Visibility
private void WriteVisibility(XPathNavigator reflection, SyntaxWriter writer)
{
string visibility = reflection.Evaluate(apiVisibilityExpression).ToString();
WriteVisibility(visibility, writer);
}
private void WriteGenericTemplateConstraints(XPathNavigator reflection, SyntaxWriter writer)
{
XPathNodeIterator templates = reflection.Select(apiTemplatesExpression);
if (templates.Count == 0)
{
return;
}
writer.WriteLine();
foreach (XPathNavigator template in templates)
{
bool constrained = (bool)template.Evaluate(templateIsConstrainedExpression);
if (constrained)
{
string name = (string)template.Evaluate(templateNameExpression);
writer.WriteKeyword("where");
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("class");
previous = true;
}
if (constructor)
{
if (previous)
{
writer.WriteString(", ");
}
writer.WriteKeyword("new");
writer.WriteString("()");
previous = true;
}
foreach (XPathNavigator constraint in constraints)
{
if (previous)
{
writer.WriteString(", ");
}
WriteTypeReference(constraint, writer);
previous = true;
}
writer.WriteLine();
}
}
/// <inheritdoc />
public override void WriteDelegateSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
WriteXamlBoilerplate(XamlBoilerplateID.delegateOverviewXamlSyntax, writer);
}
private void WriteTypeReference(XPathNavigator reference, SyntaxWriter writer)
{
switch (reference.LocalName)
{
case "arrayOf":
int rank = Convert.ToInt32(reference.GetAttribute("rank", String.Empty));
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);
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(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 WriteParameterList(XPathNavigator reflection, SyntaxWriter writer)
{
WriteParameterList(reflection, writer, true);
}
private void WriteInterfaceList(XPathNavigator reflection, SyntaxWriter writer)
{
WriteInterfaceList("implements", reflection, writer);
}
public override void WriteEventSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
writer.WriteMessage("UnsupportedEvent_" + Language);
}
public override void WritePropertySyntax(XPathNavigator reflection, SyntaxWriter 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)
{
WriteAttributeList(reflection, writer);
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);
writer.WriteString(" () : ");
WriteTypeReference(type, writer);
writer.WriteLine();
}
if (isSettable)
{
WriteAttributeList(reflection, writer);
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");
writer.WriteString(" : ");
WriteTypeReference(type, writer);
writer.WriteString(")");
}
}
// Generics
private void WriteGenericTemplates(XPathNavigator reflection, SyntaxWriter writer)
{
WriteGenericTemplates(reflection, writer, false);
}
private void WriteValue(XPathNavigator parent, SyntaxWriter writer)
{
XPathNavigator type = parent.SelectSingleNode(attributeTypeExpression);
XPathNavigator value = parent.SelectSingleNode(valueExpression);
if (value == null) Console.WriteLine("null value");
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":
bool bool_value = Convert.ToBoolean(text);
if (bool_value)
{
writer.WriteKeyword("true");
}
else
{
writer.WriteKeyword("false");
}
break;
case "T:System.Char":
writer.WriteString("'");
writer.WriteString(text);
writer.WriteString("'");
break;
}
break;
}
}
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 void WriteNormalTypeReference(string api, SyntaxWriter writer)
{
switch (api)
{
case "T:System.Boolean":
writer.WriteReferenceLink(api, "boolean");
break;
case "T:System.Byte":
writer.WriteReferenceLink(api, "byte");
break;
case "T:System.SByte":
writer.WriteReferenceLink(api, "sbyte");
break;
case "T:System.Char":
writer.WriteReferenceLink(api, "char");
break;
case "T:System.Int16":
writer.WriteReferenceLink(api, "short");
break;
case "T:System.Int32":
writer.WriteReferenceLink(api, "int");
break;
case "T:System.Int64":
writer.WriteReferenceLink(api, "long");
break;
case "T:System.UInt16":
writer.WriteReferenceLink(api, "ushort");
break;
case "T:System.UInt32":
writer.WriteReferenceLink(api, "uint");
break;
case "T:System.UInt64":
writer.WriteReferenceLink(api, "ulong");
break;
case "T:System.Single":
writer.WriteReferenceLink(api, "float");
break;
case "T:System.Double":
writer.WriteReferenceLink(api, "double");
break;
case "T:System.Decimal":
writer.WriteReferenceLink(api, "decimal");
break;
default:
writer.WriteReferenceLink(api);
break;
}
}
// Return Value
private void WriteReturnValue(XPathNavigator reflection, SyntaxWriter writer)
{
XPathNavigator type = reflection.SelectSingleNode(apiReturnTypeExpression);
if (type == null)
{
writer.WriteKeyword("unit");
}
else
{
WriteTypeReference(type, writer);
}
}
private void WriteAttributeList(XPathNavigator reflection, SyntaxWriter writer)
{
// fill in this logic
}
private void WriteAttributes(XPathNavigator reflection, SyntaxWriter writer)
{
XPathNodeIterator attributes = (XPathNodeIterator)reflection.Evaluate(apiAttributesExpression);
foreach (XPathNavigator attribute in attributes)
{
XPathNavigator type = attribute.SelectSingleNode(attributeTypeExpression);
if (type.GetAttribute("api", String.Empty) == "T:System.Runtime.CompilerServices.ExtensionAttribute")
{
continue;
}
writer.WriteString("[");
WriteTypeReference(type, writer);
XPathNodeIterator arguments = (XPathNodeIterator)attribute.Select(attributeArgumentsExpression);
XPathNodeIterator assignments = (XPathNodeIterator)attribute.Select(attributeAssignmentsExpression);
if ((arguments.Count > 0) || (assignments.Count > 0))
{
writer.WriteString("(");
while (arguments.MoveNext())
{
XPathNavigator argument = arguments.Current;
if (arguments.CurrentPosition > 1)
{
writer.WriteString(", ");
if (writer.Position > maxPosition)
{
writer.WriteLine();
writer.WriteString("\t");
}
}
WriteValue(argument, writer);
}
if ((arguments.Count > 0) && (assignments.Count > 0))
{
writer.WriteString(", ");
}
while (assignments.MoveNext())
{
XPathNavigator assignment = assignments.Current;
if (assignments.CurrentPosition > 1)
{
writer.WriteString(", ");
if (writer.Position > maxPosition)
{
writer.WriteLine();
writer.WriteString("\t");
}
}
writer.WriteString((string)assignment.Evaluate(assignmentNameExpression));
writer.WriteString(" = ");
WriteValue(assignment, writer);
}
writer.WriteString(")");
}
writer.WriteString("]");
writer.WriteLine();
}
}
// DONE
private void WriteNormalTypeReference(string api, SyntaxWriter writer)
{
switch (api)
{
case "T:System.Void":
writer.WriteReferenceLink(api, "unit");
break;
case "T:System.String":
writer.WriteReferenceLink(api, "string");
break;
case "T:System.Boolean":
writer.WriteReferenceLink(api, "bool");
break;
case "T:System.Byte":
writer.WriteReferenceLink(api, "byte");
break;
case "T:System.SByte":
writer.WriteReferenceLink(api, "sbyte");
break;
case "T:System.Char":
writer.WriteReferenceLink(api, "char");
break;
case "T:System.Int16":
writer.WriteReferenceLink(api, "int16");
break;
case "T:System.Int32":
writer.WriteReferenceLink(api, "int");
break;
case "T:System.Int64":
writer.WriteReferenceLink(api, "int64");
break;
case "T:System.UInt16":
writer.WriteReferenceLink(api, "uint16");
break;
case "T:System.UInt32":
writer.WriteReferenceLink(api, "uint32");
break;
case "T:System.UInt64":
writer.WriteReferenceLink(api, "uint64");
break;
case "T:System.Single":
writer.WriteReferenceLink(api, "float32");
break;
case "T:System.Double":
writer.WriteReferenceLink(api, "float");
break;
case "T:System.Decimal":
writer.WriteReferenceLink(api, "decimal");
break;
default:
writer.WriteReferenceLink(api);
break;
}
}
public override void WritePropertySyntax(XPathNavigator reflection, SyntaxWriter writer)
{
string name = (string)reflection.Evaluate(apiNameExpression);
bool isDefault = (bool)reflection.Evaluate(apiIsDefaultMemberExpression);
bool isGettable = (bool)reflection.Evaluate(apiIsReadPropertyExpression);
bool isSettable = (bool)reflection.Evaluate(apiIsWritePropertyExpression);
bool isExplicit = (bool)reflection.Evaluate(apiIsExplicitImplementationExpression);
XPathNodeIterator parameters = reflection.Select(apiParametersExpression);
WriteAttributes(reflection, writer);
if (!isExplicit)
{
WriteProcedureModifiers(reflection, writer);
}
WriteReturnValue(reflection, writer);
writer.WriteString(" ");
if (isExplicit)
{
XPathNavigator member = reflection.SelectSingleNode(apiImplementedMembersExpression);
XPathNavigator contract = member.SelectSingleNode(memberDeclaringTypeExpression);
WriteTypeReference(contract, writer);
writer.WriteString(".");
if (parameters.Count > 0)
{
// In C#, EII property with parameters is an indexer; use 'this' instead of the property's name
writer.WriteKeyword("this");
}
else
{
WriteMemberReference(member, writer);
}
}
else
{
// In C#, any property with parameters is an indexer, which is declared using 'this' instead of the property's name
if (isDefault || parameters.Count > 0)
{
writer.WriteKeyword("this");
}
else
{
writer.WriteIdentifier(name);
}
}
WritePropertyParameters(reflection, writer);
writer.WriteString(" {");
if (isGettable)
{
writer.WriteString(" ");
string getVisibility = (string)reflection.Evaluate(apiGetVisibilityExpression);
if (!String.IsNullOrEmpty(getVisibility))
{
WriteVisibility(getVisibility, writer);
writer.WriteString(" ");
}
writer.WriteKeyword("get");
writer.WriteString(";");
}
if (isSettable)
{
writer.WriteString(" ");
string setVisibility = (string)reflection.Evaluate(apiSetVisibilityExpression);
if (!String.IsNullOrEmpty(setVisibility))
{
WriteVisibility(setVisibility, writer);
writer.WriteString(" ");
}
writer.WriteKeyword("set");
writer.WriteString(";");
}
writer.WriteString(" }");
}
private void WriteBaseClassAndImplementedInterfaces(XPathNavigator reflection, SyntaxWriter writer)
{
XPathNavigator baseClass = reflection.SelectSingleNode(apiBaseClassExpression);
XPathNodeIterator implements = reflection.Select(apiImplementedInterfacesExpression);
bool hasBaseClass = (baseClass != null) && !((bool)baseClass.Evaluate(typeIsObjectExpression));
bool hasImplementedInterfaces = (implements.Count > 0);
if (hasBaseClass || hasImplementedInterfaces)
{
writer.WriteString(" : ");
if (hasBaseClass)
{
WriteTypeReference(baseClass, writer);
if (hasImplementedInterfaces)
{
writer.WriteString(", ");
if (writer.Position > maxPosition)
{
writer.WriteLine();
writer.WriteString("\t");
}
}
}
while (implements.MoveNext())
{
XPathNavigator implement = implements.Current;
WriteTypeReference(implement, writer);
if (implements.CurrentPosition < implements.Count)
{
writer.WriteString(", ");
if (writer.Position > maxPosition)
{
writer.WriteLine();
writer.WriteString("\t");
}
}
}
}
}
/// <inheritdoc />
public override void WriteEnumerationSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
TypeDeclaration(reflection, writer);
}
/// <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 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");
}
// A simple Property Element Usage block for a content property
// syntax looks like:
// <object>
// <linkToType .../>
// </object>
private void PropertyContentElementUsageSimple(XPathNavigator propertyReflection, SyntaxWriter writer)
{
string xamlBlockId = System.Enum.GetName(typeof(XamlHeadingID), XamlHeadingID.xamlContentElementUsageHeading);
XPathNavigator returnType = propertyReflection.SelectSingleNode(apiReturnTypeExpression);
// start the syntax block
writer.WriteStartSubBlock(xamlBlockId);
// <object>
writer.WriteString("<");
writer.WriteParameter("object");
writer.WriteString(">");
writer.WriteLine();
// <linkToType .../>
writer.WriteString(" <");
WriteTypeReference(returnType, writer);
writer.WriteString(" .../>");
writer.WriteLine();
// </object>
writer.WriteString("</");
writer.WriteParameter("object");
writer.WriteString(">");
writer.WriteEndSubBlock();
}
/// <inheritdoc />
public override void WriteOperatorSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
string name = (string)reflection.Evaluate(apiNameExpression);
XPathNavigator returnType = reflection.SelectSingleNode(apiReturnTypeExpression);
// Determine operator identifier and type
string identifier = null;
int type = 0;
if (!(bool)reflection.Evaluate(apiIsUdtReturnExpression))
{
switch (name)
{
// unary math operators
case "UnaryPlus":
identifier = "+";
type = -1;
break;
case "UnaryNegation":
identifier = "-";
type = -1;
break;
case "Increment":
identifier = "++";
type = +1;
break;
case "Decrement":
identifier = "--";
type = +1;
break;
// unary logical operators
case "LogicalNot":
identifier = "Not";
type = -1;
break;
case "True":
identifier = "IsTrue";
type = -1;
break;
case "False":
identifier = "IsFalse";
type = -1;
break;
// binary comparison operators
case "Equality":
identifier = "=";
type = 2;
break;
case "Inequality":
identifier = "<>";
type = 2;
break;
case "LessThan":
identifier = "<";
type = 2;
break;
case "GreaterThan":
identifier = ">";
type = 2;
break;
case "LessThanOrEqual":
identifier = "<=";
type = 2;
break;
case "GreaterThanOrEqual":
identifier = ">=";
type = 2;
break;
// binary math operators
case "Addition":
identifier = "+";
type = 2;
break;
case "Subtraction":
identifier = "-";
type = 2;
break;
case "Multiply":
identifier = "*";
type = 2;
break;
case "Division":
identifier = "/";
type = 2;
break;
case "Exponent":
identifier = "^";
type = 2;
break;
case "Modulus":
identifier = "Mod";
type = 2;
break;
case "IntegerDivision":
identifier = @"\";
type = 2;
break;
// binary logical operators
case "BitwiseAnd":
identifier = "And";
type = 2;
break;
case "BitwiseOr":
identifier = "Or";
type = 2;
break;
case "ExclusiveOr":
identifier = "Xor";
type = 2;
break;
// bit-array operators
case "OnesComplement":
identifier = "~";
type = -1;
break;
case "LeftShift":
identifier = "<<";
type = 2;
break;
case "RightShift":
identifier = ">>";
type = 2;
break;
// concatenation
case "Concatenate":
identifier = "&";
type = 2;
break;
case "Assign":
identifier = "=";
type = 2;
break;
// didn't recognize an operator
default:
identifier = null;
type = 0;
break;
}
}
if (identifier == null)
{
writer.WriteMessage("UnsupportedOperator_" + Language);
}
else
{
XPathNodeIterator parameters = reflection.Select(apiParametersExpression);
if (parameters.Count != Math.Abs(type))
{
writer.WriteMessage("UnsupportedOperator_" + Language);
return;
} //throw new InvalidOperationException("An operator has the wrong number of parameters.");
WriteParameterDeclarations(reflection, writer);
ParameterDeclaration("returnValue", returnType, writer);
writer.WriteLine();
writer.WriteParameter("returnValue");
writer.WriteString(" = ");
switch (type)
{
case -1:
writer.WriteIdentifier(identifier);
parameters.MoveNext();
writer.WriteParameter((string)parameters.Current.Evaluate(parameterNameExpression));
break;
case +1:
parameters.MoveNext();
writer.WriteParameter((string)parameters.Current.Evaluate(parameterNameExpression));
writer.WriteIdentifier(identifier);
break;
case 2:
writer.WriteString("(");
// parameter 1
parameters.MoveNext();
writer.WriteParameter((string)parameters.Current.Evaluate(parameterNameExpression));
writer.WriteString(" ");
writer.WriteIdentifier(identifier);
writer.WriteString(" ");
// parameter 2
parameters.MoveNext();
writer.WriteParameter((string)parameters.Current.Evaluate(parameterNameExpression));
writer.WriteString(")");
break;
}
}
}
/// <inheritdoc />
public override void WriteConstructorSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
WriteXamlBoilerplate(XamlBoilerplateID.constructorOverviewXamlSyntax, writer);
}
private void TypeDeclaration(XPathNavigator reflection, SyntaxWriter writer)
{
TypeDeclaration(reflection, writer, false);
}
// Initial version
private void WriteAttributes(XPathNavigator reflection, SyntaxWriter writer)
{
XPathNodeIterator attributes = (XPathNodeIterator)reflection.Evaluate(apiAttributesExpression);
foreach (XPathNavigator attribute in attributes)
{
XPathNavigator type = attribute.SelectSingleNode(attributeTypeExpression);
if (type.GetAttribute("api", String.Empty) == "T:System.Runtime.CompilerServices.ExtensionAttribute") continue;
writer.WriteString("[<");
WriteTypeReference(type, writer);
XPathNodeIterator arguments = (XPathNodeIterator)attribute.Select(attributeArgumentsExpression);
XPathNodeIterator assignments = (XPathNodeIterator)attribute.Select(attributeAssignmentsExpression);
if ((arguments.Count > 0) || (assignments.Count > 0))
{
writer.WriteString("(");
while (arguments.MoveNext())
{
XPathNavigator argument = arguments.Current;
if (arguments.CurrentPosition > 1)
{
writer.WriteString(", ");
if (writer.Position > maxPosition)
{
writer.WriteLine();
writer.WriteString(" ");
}
}
WriteValue(argument, writer);
}
if ((arguments.Count > 0) && (assignments.Count > 0)) writer.WriteString(", ");
while (assignments.MoveNext())
{
XPathNavigator assignment = assignments.Current;
if (assignments.CurrentPosition > 1)
{
writer.WriteString(", ");
if (writer.Position > maxPosition)
{
writer.WriteLine();
writer.WriteString(" ");
}
}
writer.WriteString((string)assignment.Evaluate(assignmentNameExpression));
writer.WriteString(" = ");
WriteValue(assignment, writer);
}
writer.WriteString(")");
}
writer.WriteString(">]");
writer.WriteLine();
}
}
/// <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);
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
{
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;
}
}
// Generics
private void WriteGenericTemplates(XPathNavigator reflection, SyntaxWriter writer)
{
XPathNodeIterator templates = (XPathNodeIterator)reflection.Evaluate(apiTemplatesExpression);
if (templates.Count == 0) return;
writer.WriteString("<");
while (templates.MoveNext())
{
XPathNavigator template = templates.Current;
string name = template.GetAttribute("name", String.Empty);
writer.WriteString("'");
writer.WriteString(name);
if (templates.CurrentPosition < templates.Count) writer.WriteString(", ");
}
WriteGenericTemplateConstraints(reflection, writer);
writer.WriteString(">");
}
private void WriteValue(XPathNavigator parent, SyntaxWriter writer)
{
XPathNavigator type = parent.SelectSingleNode(attributeTypeExpression);
XPathNavigator value = parent.SelectSingleNode(valueExpression);
if (value == null)
{
Console.WriteLine("null value");
}
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":
bool bool_value = Convert.ToBoolean(text);
if (bool_value)
{
writer.WriteKeyword("true");
}
else
{
writer.WriteKeyword("false");
}
break;
case "T:System.Char":
writer.WriteString("'");
writer.WriteString(text);
writer.WriteString("'");
break;
}
break;
}
}
// Parameters
private void WriteParameters(XPathNavigator reflection, SyntaxWriter writer)
{
XPathNodeIterator parameters = reflection.Select(apiParametersExpression);
if (parameters.Count > 0)
{
WriteParameters(parameters, reflection, writer);
}
else
{
writer.WriteKeyword("unit");
writer.WriteString(" ");
}
return;
}
/// <summary>
/// Write out property syntax
/// </summary>
/// <param name="reflection">An XPath navigator containing the member information</param>
/// <param name="writer">The syntax writer to which the information is written</param>
/// <param name="prefix">The web control prefix to use</param>
private static void WritePropertySyntax(XPathNavigator reflection, SyntaxWriter writer, string prefix)
{
bool set = (bool)reflection.Evaluate(propertyIsSettable);
if(!set)
return;
string name = (string)reflection.Evaluate(nameExpression);
string declaringType = (string)reflection.Evaluate(declaringTypeExpression);
string propertyType = (string)reflection.Evaluate(propertyTypeExpression);
bool isInnerProperty = (bool)reflection.Evaluate(propertyIsInnerProperty);
writer.WriteStartBlock(LanguageName, StyleIdName);
if(isInnerProperty)
{
// inner property logic
writer.WriteString("<");
writer.WriteString(prefix);
writer.WriteString(":");
writer.WriteReferenceLink(declaringType);
writer.WriteString(">");
writer.WriteLine();
writer.WriteString("\t");
writer.WriteString("<");
writer.WriteString(name);
writer.WriteString(">");
if(String.IsNullOrEmpty(propertyType))
writer.WriteParameter("value");
else
if(propertyType == "T:System.Boolean")
writer.WriteString("True|False");
else
writer.WriteReferenceLink(propertyType);
writer.WriteString("</");
writer.WriteString(name);
writer.WriteString(">");
writer.WriteLine();
writer.WriteString("</");
writer.WriteString(prefix);
writer.WriteString(":");
writer.WriteReferenceLink(declaringType);
writer.WriteString(">");
}
else
{
// normal property logic
writer.WriteString("<");
writer.WriteString(prefix);
writer.WriteString(":");
writer.WriteReferenceLink(declaringType);
writer.WriteString(" ");
writer.WriteString(name);
writer.WriteString("=\"");
if(String.IsNullOrEmpty(propertyType))
writer.WriteParameter("value");
else
if(propertyType == "T:System.Boolean")
writer.WriteString("True|False");
else
writer.WriteReferenceLink(propertyType);
writer.WriteString("\" />");
}
writer.WriteEndBlock();
}
private void WriteParameters(XPathNodeIterator parameters, XPathNavigator reflection, SyntaxWriter writer)
{
bool isExtension = (bool)reflection.Evaluate(apiIsExtensionMethod);
writer.WriteLine();
while (parameters.MoveNext())
{
XPathNavigator parameter = parameters.Current;
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(" ");
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(" ");
}
}
}
private static void WriteMemberReference(XPathNavigator member, SyntaxWriter writer)
{
string api = member.GetAttribute("api", String.Empty);
writer.WriteReferenceLink(api);
}
// References
private void WriteTypeReference(XPathNavigator reference, SyntaxWriter writer)
{
switch (reference.LocalName)
{
case "arrayOf":
int rank = Convert.ToInt32(reference.GetAttribute("rank", String.Empty));
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, XPathNavigator reflection, SyntaxWriter writer)
{
bool isExtension = (bool)reflection.Evaluate(apiIsExtensionMethod);
while (parameters.MoveNext())
{
XPathNavigator parameter = parameters.Current;
string name = (string)parameter.Evaluate(parameterNameExpression);
XPathNavigator type = parameter.SelectSingleNode(parameterTypeExpression);
bool isIn = (bool)parameter.Evaluate(parameterIsInExpression);
bool isOut = (bool)parameter.Evaluate(parameterIsOutExpression);
bool isRef = (bool)parameter.Evaluate(parameterIsRefExpression);
bool isParamArray = (bool)parameter.Evaluate(parameterIsParamArrayExpression);
writer.WriteString("\t");
if (isExtension && parameters.CurrentPosition == 1)
{
writer.WriteKeyword("this");
writer.WriteString(" ");
}
if (isRef)
{
if (isOut)
{
writer.WriteKeyword("out");
}
else
{
writer.WriteKeyword("ref");
}
writer.WriteString(" ");
}
if (isParamArray)
{
writer.WriteKeyword("params");
writer.WriteString(" ");
}
WriteTypeReference(type, writer);
writer.WriteString(" ");
writer.WriteParameter(name);
if (parameters.CurrentPosition < parameters.Count)
{
writer.WriteString(",");
}
writer.WriteLine();
}
}
public override void WriteConstructorSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
string name = (string)reflection.Evaluate(apiContainingTypeNameExpression);
bool isStatic = (bool)reflection.Evaluate(apiIsStaticExpression);
WriteAttributes(reflection, writer);
writer.WriteKeyword("new");
writer.WriteString(" : ");
WriteParameters(reflection, writer);
writer.WriteKeyword("->");
writer.WriteString(" ");
writer.WriteIdentifier(name);
}
/// <inheritdoc />
public override void WriteInterfaceSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
TypeDeclaration(reflection, writer, true); // Need to write variance info for interfaces and delegates
}