diff options
Diffstat (limited to 'tools/Sandcastle/Source/BuildAssembler/SyntaxComponents')
18 files changed, 7475 insertions, 0 deletions
diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/AspNetSyntax.cs b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/AspNetSyntax.cs new file mode 100644 index 0000000..50d7201 --- /dev/null +++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/AspNetSyntax.cs @@ -0,0 +1,207 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// +using System; +using System.Collections.Generic; +using System.Text; +using System.Xml.XPath; + +namespace Microsoft.Ddue.Tools { + + + public class AspNetSyntaxGenerator : SyntaxGenerator { + + public AspNetSyntaxGenerator (XPathNavigator configuration) : base(configuration) { + } + + protected static XPathExpression nameExpression = XPathExpression.Compile("string(apidata/@name)"); + protected static XPathExpression groupExpression = XPathExpression.Compile("string(apidata/@group)"); + protected static XPathExpression subgroupExpression = XPathExpression.Compile("string(apidata/@subgroup)"); + + protected static XPathExpression containingTypeExpression = XPathExpression.Compile("containers/type"); + protected static XPathExpression declaringTypeExpression = XPathExpression.Compile("string(containers/type/@api)"); + protected static XPathExpression propertyTypeExpression = XPathExpression.Compile("string(returns/type/@api)"); + protected static XPathExpression propertyIsSettable = XPathExpression.Compile("boolean(propertydata/@set='true')"); + protected static XPathExpression eventHandlerTypeExpression = XPathExpression.Compile("string(eventhandler/type/@api)"); + + protected static XPathExpression typeIsWebControl = XPathExpression.Compile("boolean(family/ancestors/type[@api='T:System.Web.UI.Control'])"); + + protected static XPathExpression propertyIsInnerProperty = XPathExpression.Compile("boolean(attributes/attribute[type/@api='T:System.Web.UI.PersistenceModeAttribute' and argument/enumValue/field/@name='InnerProperty'])"); + + protected static XPathExpression containingNamespaceExpression = XPathExpression.Compile("string(containers/namespace/@api)"); + + private string language = "AspNet"; + + public string Language { + get { + return (language); + } + } + + 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); + } + } + } + + + } + + private string WebControlPrefix (XPathNavigator reflection) { + if ((bool)reflection.Evaluate(typeIsWebControl)) { + string name = (string)reflection.Evaluate(nameExpression); + string space = (string)reflection.Evaluate(containingNamespaceExpression); + if ((space == "N:System.Web.UI") && ((name == "Page") || (name == "ScriptControl") || (name == "UserControl"))) { + return (null); + } else { + if (space == "N:System.Web.UI.MobileControls") { + return ("mobile"); + } else { + return ("asp"); + } + } + } else { + return (null); + } + } + + private void WriteClassSyntax (XPathNavigator reflection, SyntaxWriter writer, string prefix) { + + string name = (string)reflection.Evaluate(nameExpression); + + writer.WriteStartBlock(Language); + + writer.WriteString("<"); + writer.WriteString(prefix); + writer.WriteString(":"); + writer.WriteString(name); + writer.WriteString(" />"); + + writer.WriteEndBlock(); + + } + + private 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(Language); + + 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 WriteEventSyntax (XPathNavigator reflection, SyntaxWriter writer, string prefix) { + + string name = (string)reflection.Evaluate(nameExpression); + string declaringType = (string)reflection.Evaluate(declaringTypeExpression); + string handlerType = (string)reflection.Evaluate(eventHandlerTypeExpression); + + writer.WriteStartBlock(Language); + + writer.WriteString("<"); + writer.WriteString(prefix); + writer.WriteString(":"); + writer.WriteReferenceLink(declaringType); + writer.WriteString(" "); + writer.WriteString("On"); + writer.WriteString(name); + writer.WriteString("=\""); + writer.WriteReferenceLink(handlerType); + writer.WriteString("\" />"); + + writer.WriteEndBlock(); + + } + + } + +} diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/CPlusPlusDeclarationSyntax.cs b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/CPlusPlusDeclarationSyntax.cs new file mode 100644 index 0000000..ee6cff5 --- /dev/null +++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/CPlusPlusDeclarationSyntax.cs @@ -0,0 +1,1038 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// +using System; +using System.Collections.Generic; +using System.Xml.XPath; + +namespace Microsoft.Ddue.Tools { + + + public class CPlusPlusDeclarationSyntaxGenerator : SyntaxGeneratorTemplate { + + public CPlusPlusDeclarationSyntaxGenerator (XPathNavigator configuration) : base(configuration) { + if (String.IsNullOrEmpty(language)) language = "ManagedCPlusPlus"; + } + + // namespace: done + public override void WriteNamespaceSyntax (XPathNavigator reflection, SyntaxWriter writer) { + + string name = reflection.Evaluate(apiNameExpression).ToString(); + + writer.WriteKeyword("namespace"); + writer.WriteString(" "); + writer.WriteIdentifier(name); + + } + + 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", true, writer); + WriteAttributes(reflection, writer); + + WriteGenericTemplates(reflection, writer); + + WriteVisibility(reflection, writer); + writer.WriteString(" "); + writer.WriteKeyword("ref class"); + writer.WriteString(" "); + + writer.WriteIdentifier(name); + + if (isAbstract) { + writer.WriteString(" "); + writer.WriteKeyword("abstract"); + } + if (isSealed) { + writer.WriteString(" "); + writer.WriteKeyword("sealed"); + } + + WriteBaseClassAndImplementedInterfaces(reflection, writer); + + } + + // structure: add base type declaration + 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", true, writer); + WriteAttributes(reflection, writer); + + WriteGenericTemplates(reflection, writer); + + WriteVisibility(reflection, writer); + writer.WriteString(" "); + writer.WriteKeyword("value class"); + writer.WriteString(" "); + writer.WriteIdentifier(name); + WriteImplementedInterfaces(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); + + } + + // delegate: done + 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", true, writer); + WriteAttributes(reflection, writer); + + WriteGenericTemplates(reflection, writer); + + WriteVisibility(reflection, writer); + writer.WriteString(" "); + writer.WriteKeyword("delegate"); + writer.WriteString(" "); + WriteReturnValue(reflection, writer); + writer.WriteString(" "); + writer.WriteIdentifier(name); + WriteMethodParameters(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", true, writer); + WriteAttributes(reflection, writer); + WriteVisibility(reflection, writer); + writer.WriteString(" "); + writer.WriteKeyword("enum class"); + writer.WriteString(" "); + writer.WriteIdentifier(name); + + // *** ENUM BASE *** + + } + + public override void WriteConstructorSyntax (XPathNavigator reflection, SyntaxWriter writer) { + + string name = (string) reflection.Evaluate(apiContainingTypeNameExpression); + bool isStatic = (bool) reflection.Evaluate(apiIsStaticExpression); + + WriteAttributes(reflection, writer); + + WriteVisibility(reflection, writer); + writer.WriteString(":"); + writer.WriteLine(); + + if (isStatic) { + writer.WriteKeyword("static"); + writer.WriteString(" "); + } + + writer.WriteIdentifier(name); + + WriteMethodParameters(reflection, writer); + + } + + + public override void WriteNormalMethodSyntax (XPathNavigator reflection, SyntaxWriter writer) { + string name = (string) reflection.Evaluate(apiNameExpression); + string typeSubgroup = (string) reflection.Evaluate(apiContainingTypeSubgroupExpression); + bool isExplicit = (bool) reflection.Evaluate(apiIsExplicitImplementationExpression); + + WriteAttributes(reflection, writer); + + if (typeSubgroup == "interface") { + WriteGenericTemplates(reflection, writer); + WriteReturnValue(reflection, writer); + writer.WriteString(" "); + writer.WriteIdentifier(name); + WriteMethodParameters(reflection, writer); + } else { + WriteProcedureVisibility(reflection, writer); + WriteGenericTemplates(reflection, writer); + WritePrefixProcedureModifiers(reflection, writer); + WriteReturnValue(reflection, writer); + writer.WriteString(" "); + writer.WriteIdentifier(name); + WriteMethodParameters(reflection, writer); + WritePostfixProcedureModifiers(reflection, writer); + } + WriteExplicitImplementations(reflection, writer); + + } + + private void WriteExplicitImplementations (XPathNavigator reflection, SyntaxWriter writer) { + bool isExplicit = (bool)reflection.Evaluate(apiIsExplicitImplementationExpression); + if (isExplicit) { + writer.WriteString(" = "); + + XPathNodeIterator implements = reflection.Select(apiImplementedMembersExpression); + while (implements.MoveNext()) { + XPathNavigator implement = implements.Current; + //string id = (string)implement.GetAttribute("api", String.Empty); + XPathNavigator contract = implement.SelectSingleNode(memberDeclaringTypeExpression); + + if (implements.CurrentPosition > 1) writer.WriteString(", "); + WriteTypeReference(contract, false, writer); + writer.WriteString("::"); + WriteMemberReference(implement, writer); + // writer.WriteReferenceLink(id); + } + } + } + + public override void WriteOperatorSyntax (XPathNavigator reflection, SyntaxWriter writer) { + string name = (string) reflection.Evaluate(apiNameExpression); + + string identifier; + switch (name) { + case "UnaryPlus": + identifier = "+"; + break; + case "UnaryNegation": + identifier = "-"; + break; + case "Increment": + identifier = "++"; + break; + case "Decrement": + identifier = "--"; + break; + // unary logical operators + case "LogicalNot": + identifier = "!"; + 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; + // others + case "Comma": + identifier = ","; + break; + case "MemberSelection": + identifier = "->"; + break; + case "AddressOf": + identifier = "&"; + break; + case "PointerDereference": + identifier = "*"; + break; + case "Assign": + identifier = "="; + break; + // unrecognized operator + default: + identifier = null; + break; + } + + if (identifier == null) { + writer.WriteMessage("UnsupportedOperator_" + Language); + } else { + + WriteProcedureVisibility(reflection, writer); + WritePrefixProcedureModifiers(reflection, writer); + WriteReturnValue(reflection, writer); + writer.WriteString(" "); + writer.WriteKeyword("operator"); + writer.WriteString(" "); + writer.WriteIdentifier(identifier); + WriteMethodParameters(reflection, writer); + } + + } + + public override void WriteCastSyntax (XPathNavigator reflection, SyntaxWriter writer) { + string name = (string)reflection.Evaluate(apiNameExpression); + + WritePrefixProcedureModifiers(reflection, writer); + if (name == "Implicit") { + writer.WriteKeyword("implicit operator"); + } else if (name == "Explicit") { + writer.WriteKeyword("explicit operator"); + } else { + throw new Exception(); + } + writer.WriteString(" "); + WriteReturnValue(reflection, writer); + writer.WriteString(" "); + WriteMethodParameters(reflection, writer); + + } + + public override void WritePropertySyntax (XPathNavigator reflection, SyntaxWriter writer) { + string name = (string) reflection.Evaluate(apiNameExpression); + string typeSubgroup = (string) reflection.Evaluate(apiContainingTypeSubgroupExpression); + bool isDefault = (bool)reflection.Evaluate(apiIsDefaultMemberExpression); + bool hasGetter = (bool) reflection.Evaluate(apiIsReadPropertyExpression); + bool hasSetter = (bool) reflection.Evaluate(apiIsWritePropertyExpression); + bool isExplicit = (bool) reflection.Evaluate(apiIsExplicitImplementationExpression); + XPathNodeIterator parameters = reflection.Select(apiParametersExpression); + + WriteAttributes(reflection, writer); + WriteProcedureVisibility(reflection, writer); + WritePrefixProcedureModifiers(reflection, writer); + writer.WriteKeyword("property"); + writer.WriteString(" "); + WriteReturnValue(reflection, writer); + writer.WriteString(" "); + + // if is default member, write default, otherwise write name + if (isDefault) { + writer.WriteKeyword("default"); + } else { + writer.WriteIdentifier(name); + } + + if (parameters.Count > 0) { + writer.WriteString("["); + WriteParameters(parameters.Clone(), false, writer); + writer.WriteString("]"); + } + + writer.WriteString(" {"); + writer.WriteLine(); + + if (hasGetter) { + writer.WriteString("\t"); + WriteReturnValue(reflection, writer); + writer.WriteString(" "); + writer.WriteKeyword("get"); + writer.WriteString(" "); + + writer.WriteString("("); + WriteParameters(parameters.Clone(), false, writer); + writer.WriteString(")"); + + WritePostfixProcedureModifiers(reflection, writer); + if (isExplicit) { + XPathNavigator implement = reflection.SelectSingleNode(apiImplementedMembersExpression); + XPathNavigator contract = implement.SelectSingleNode(memberDeclaringTypeExpression); + //string id = (string) implement.GetAttribute("api", String.Empty); + + writer.WriteString(" = "); + WriteTypeReference(contract, false, writer); + writer.WriteString("::"); + WriteMemberReference(implement, writer); + //writer.WriteReferenceLink(id); + writer.WriteString("::"); + writer.WriteKeyword("get"); + } + writer.WriteString(";"); + writer.WriteLine(); + } + + if (hasSetter) { + writer.WriteString("\t"); + writer.WriteKeyword("void"); + writer.WriteString(" "); + writer.WriteKeyword("set"); + writer.WriteString(" "); + + writer.WriteString("("); + if (parameters.Count > 0) { + WriteParameters(parameters.Clone(), false, writer); + writer.WriteString(", "); + } + WriteReturnValue(reflection, writer); + writer.WriteString(" "); + writer.WriteParameter("value"); + writer.WriteString(")"); + + WritePostfixProcedureModifiers(reflection, writer); + if (isExplicit) { + XPathNavigator implement = reflection.SelectSingleNode(apiImplementedMembersExpression); + XPathNavigator contract = implement.SelectSingleNode(memberDeclaringTypeExpression); + //string id = (string) implement.GetAttribute("api", String.Empty); + + writer.WriteString(" = "); + WriteTypeReference(contract, false, writer); + writer.WriteString("::"); + WriteMemberReference(implement, writer); + //writer.WriteReferenceLink(id); + writer.WriteString("::"); + writer.WriteKeyword("set"); + } + writer.WriteString(";"); + writer.WriteLine(); + } + + + writer.WriteString("}"); + } + + public override void WriteEventSyntax (XPathNavigator reflection, SyntaxWriter writer) { + string name = (string) reflection.Evaluate(apiNameExpression); + XPathNavigator handler = reflection.SelectSingleNode(apiHandlerOfEventExpression); + + WriteAttributes(reflection, writer); + WriteProcedureVisibility(reflection, writer); + WritePrefixProcedureModifiers(reflection, writer); + writer.WriteString(" "); + writer.WriteKeyword("event"); + writer.WriteString(" "); + WriteTypeReference(handler, writer); + writer.WriteString(" "); + writer.WriteIdentifier(name); + writer.WriteString(" {"); + writer.WriteLine(); + + writer.WriteString("\t"); + writer.WriteKeyword("void"); + writer.WriteString(" "); + writer.WriteKeyword("add"); + writer.WriteString(" ("); + WriteTypeReference(handler, writer); + writer.WriteString(" "); + writer.WriteParameter("value"); + writer.WriteString(")"); + writer.WriteString(";"); + writer.WriteLine(); + + writer.WriteString("\t"); + writer.WriteKeyword("void"); + writer.WriteString(" "); + writer.WriteKeyword("remove"); + writer.WriteString(" ("); + WriteTypeReference(handler, writer); + writer.WriteString(" "); + writer.WriteParameter("value"); + writer.WriteString(")"); + writer.WriteString(";"); + writer.WriteLine(); + + + writer.WriteString("}"); + + } + + public override void WriteFieldSyntax (XPathNavigator reflection, SyntaxWriter writer) { + + 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); + + if (!isSerialized) WriteAttribute("T:System.NonSerializedAttribute", true, writer); + WriteAttributes(reflection, writer); + + WriteVisibility(reflection, writer); + writer.WriteString(":"); + writer.WriteLine(); + if (isStatic) { + if (isLiteral) { + writer.WriteKeyword("literal"); + } else { + writer.WriteKeyword("static"); + } + writer.WriteString(" "); + } + if (isInitOnly) { + writer.WriteKeyword("initonly"); + writer.WriteString(" "); + } + WriteReturnValue(reflection, writer); + writer.WriteString(" "); + writer.WriteIdentifier(name); + + } + + private void WritePrefixProcedureModifiers (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); + + if (isStatic) { + writer.WriteKeyword("static"); + writer.WriteString(" "); + } else if (isVirtual) { + writer.WriteKeyword("virtual"); + writer.WriteString(" "); + } + + } + + private void WritePostfixProcedureModifiers (XPathNavigator reflection, SyntaxWriter writer) { + + // interface members don't get modified + string typeSubgroup = (string) reflection.Evaluate(apiContainingTypeSubgroupExpression); + if (typeSubgroup == "interface") return; + + bool isVirtual = (bool) reflection.Evaluate(apiIsVirtualExpression); + bool isAbstract = (bool) reflection.Evaluate(apiIsAbstractProcedureExpression); + bool isFinal = (bool) reflection.Evaluate(apiIsFinalExpression); + bool isOverride = (bool) reflection.Evaluate(apiIsOverrideExpression); + + if (isVirtual) { + if (isAbstract) { + writer.WriteString(" "); + writer.WriteKeyword("abstract"); + } + if (isOverride) { + writer.WriteString(" "); + writer.WriteKeyword("override"); + } + if (isFinal) { + writer.WriteString(" "); + writer.WriteKeyword("sealed"); + } + } + } + + // Visibility + + private void WriteProcedureVisibility (XPathNavigator reflection, SyntaxWriter writer) { + string typeSubgroup = (string) reflection.Evaluate(apiContainingTypeSubgroupExpression); + if (typeSubgroup != "interface") { + WriteVisibility(reflection, writer); + writer.WriteString(":"); + writer.WriteLine(); + } + + } + + private void WriteVisibility (XPathNavigator reflection, SyntaxWriter writer) { + + string visibility = reflection.Evaluate(apiVisibilityExpression).ToString(); + + switch (visibility) { + case "public": + writer.WriteKeyword("public"); + break; + case "family": + writer.WriteKeyword("protected"); + break; + case "family or assembly": + writer.WriteKeyword("protected public"); + break; + case "family and assembly": + writer.WriteKeyword("protected private"); + break; + case "assembly": + writer.WriteKeyword("internal"); + break; + case "private": + writer.WriteKeyword("private"); + break; + } + + } + + // Generics + + private void WriteGenericTemplates (XPathNavigator reflection, SyntaxWriter writer) { + + XPathNodeIterator templateNodes = (XPathNodeIterator) reflection.Evaluate(apiTemplatesExpression); + if (templateNodes.Count == 0) return; + XPathNavigator[] templates = ConvertIteratorToArray(templateNodes); + if (templates.Length == 0) return; + + // generic declaration + writer.WriteKeyword("generic"); + writer.WriteString("<"); + for (int i=0; i<templates.Length; i++) { + XPathNavigator template = templates[i]; + string name = (string) template.Evaluate(templateNameExpression); + if (i> 0) writer.WriteString(", "); + writer.WriteKeyword("typename"); + writer.WriteString(" "); + writer.WriteString(name); + } + writer.WriteString(">"); + writer.WriteLine(); + + // generic constraints + foreach (XPathNavigator template in templates) { + bool constrained = (bool) template.Evaluate(templateIsConstrainedExpression); + if (!constrained) continue; + + string name = (string) template.Evaluate(templateNameExpression); + + writer.WriteKeyword("where"); + writer.WriteString(" "); + writer.WriteString(name); + writer.WriteString(" : "); + + 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("value class"); + previous = true; + } + + if (reference) { + if (previous) writer.WriteString(", "); + writer.WriteKeyword("ref class"); + previous = true; + } + + if (constructor) { + if (previous) writer.WriteString(", "); + writer.WriteKeyword("gcnew"); + writer.WriteString("()"); + previous = true; + } + + foreach (XPathNavigator constraint in constraints) { + if (previous) writer.WriteString(", "); + WriteTypeReference(constraint, false, writer); + previous = true; + } + + writer.WriteLine(); + + } + + } + + // Interfaces + + private void WriteImplementedInterfaces (XPathNavigator reflection, SyntaxWriter writer) { + + XPathNodeIterator implements = reflection.Select(apiImplementedInterfacesExpression); + + if (implements.Count == 0) return; + writer.WriteString(" : "); + while (implements.MoveNext()) { + XPathNavigator implement = implements.Current; + WriteTypeReference(implement, false, writer); + if (implements.CurrentPosition < implements.Count) { + writer.WriteString(", "); + if (writer.Position > maxPosition) { + writer.WriteLine(); + writer.WriteString("\t"); + } + } + } + + } + + 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) { + writer.WriteKeyword("public"); + writer.WriteString(" "); + WriteTypeReference(baseClass, false, writer); + if (hasImplementedInterfaces) { + writer.WriteString(", "); + if (writer.Position > maxPosition) { + writer.WriteLine(); + writer.WriteString("\t"); + } + } + } + + while (implements.MoveNext()) { + XPathNavigator implement = implements.Current; + WriteTypeReference(implement, false, writer); + if (implements.CurrentPosition < implements.Count) { + writer.WriteString(", "); + if (writer.Position > maxPosition) { + writer.WriteLine(); + writer.WriteString("\t"); + } + } + } + + } + + } + + // Return Value + + private void WriteReturnValue (XPathNavigator reflection, SyntaxWriter writer) { + + XPathNavigator type = reflection.SelectSingleNode(apiReturnTypeExpression); + + if (type == null) { + writer.WriteKeyword("void"); + } else { + WriteTypeReference(type, writer); + } + } + + + private void WriteMethodParameters (XPathNavigator reflection, SyntaxWriter writer) { + + XPathNodeIterator parameters = reflection.Select(apiParametersExpression); + + writer.WriteString("("); + if (parameters.Count > 0) { + writer.WriteLine(); + WriteParameters(parameters, true, writer); + } + writer.WriteString(")"); + + } + + private void WriteParameters (XPathNodeIterator parameters, bool multiline, SyntaxWriter writer) { + + while (parameters.MoveNext()) { + XPathNavigator parameter = parameters.Current; + + XPathNavigator type = parameter.SelectSingleNode(parameterTypeExpression); + string name = (string) parameter.Evaluate(parameterNameExpression); + bool isIn = (bool) parameter.Evaluate(parameterIsInExpression); + bool isOut = (bool) parameter.Evaluate(parameterIsOutExpression); + bool isParamArray = (bool) parameter.Evaluate(parameterIsParamArrayExpression); + + if (multiline) { + writer.WriteString("\t"); + } + if (isIn) { + WriteAttribute("T:System.Runtime.InteropServices.InAttribute", false, writer); + writer.WriteString(" "); + } + if (isOut) { + WriteAttribute("T:System.Runtime.InteropServices.OutAttribute", false, writer); + writer.WriteString(" "); + } + if (isParamArray) writer.WriteString("... "); + WriteTypeReference(type, writer); + writer.WriteString(" "); + writer.WriteParameter(name); + + if (parameters.CurrentPosition < parameters.Count) writer.WriteString(", "); + if (multiline) writer.WriteLine(); + } + + } + + // Type references + + private void WriteTypeReference (XPathNavigator reference, SyntaxWriter writer) { + WriteTypeReference(reference, true, writer); + } + + private void WriteTypeReference (XPathNavigator reference, bool handle, SyntaxWriter writer) { + switch (reference.LocalName) { + case "arrayOf": + XPathNavigator element = reference.SelectSingleNode(typeExpression); + int rank = Convert.ToInt32( reference.GetAttribute("rank",String.Empty) ); + writer.WriteKeyword("array"); + writer.WriteString("<"); + WriteTypeReference(element, writer); + if (rank > 1) { + writer.WriteString(","); + writer.WriteString(rank.ToString()); + } + writer.WriteString(">"); + if (handle) 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); + writer.WriteString("%"); + break; + case "type": + string id = reference.GetAttribute("api", String.Empty); + bool isRef = (reference.GetAttribute("ref", String.Empty) == "true"); + WriteNormalTypeReference(id, writer); + XPathNodeIterator typeModifiers = reference.Select(typeModifiersExpression); + while (typeModifiers.MoveNext()) { + WriteTypeReference(typeModifiers.Current, writer); + } + if (handle && isRef) writer.WriteString("^"); + + 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 WriteNormalTypeReference (string reference, SyntaxWriter writer) { + switch (reference) { + case "T:System.Void": + writer.WriteReferenceLink(reference, "void"); + break; + case "T:System.Boolean": + writer.WriteReferenceLink(reference, "bool"); + break; + case "T:System.Byte": + writer.WriteReferenceLink(reference, "unsigned char"); + break; + case "T:System.SByte": + writer.WriteReferenceLink(reference, "signed char"); + break; + case "T:System.Char": + writer.WriteReferenceLink(reference, "wchar_t"); + break; + case "T:System.Int16": + writer.WriteReferenceLink(reference, "short"); + break; + case "T:System.Int32": + writer.WriteReferenceLink(reference, "int"); + break; + case "T:System.Int64": + writer.WriteReferenceLink(reference, "long long"); + break; + case "T:System.UInt16": + writer.WriteReferenceLink(reference, "unsigned short"); + break; + case "T:System.UInt32": + writer.WriteReferenceLink(reference, "unsigned int"); + break; + case "T:System.UInt64": + writer.WriteReferenceLink(reference, "unsigned long long"); + break; + case "T:System.Single": + writer.WriteReferenceLink(reference, "float"); + break; + case "T:System.Double": + writer.WriteReferenceLink(reference, "double"); + break; + default: + writer.WriteReferenceLink(reference); + break; + } + } + + // Attributes + + private void WriteAttribute (string reference, bool newline, SyntaxWriter writer) { + writer.WriteString("["); + writer.WriteReferenceLink(reference); + writer.WriteString("]"); + if (newline) writer.WriteLine(); + } + + private void WriteAttributes (XPathNavigator reflection, SyntaxWriter writer) { + + XPathNodeIterator attributes = (XPathNodeIterator) reflection.Evaluate(apiAttributesExpression); + + foreach (XPathNavigator attribute in attributes) { + + XPathNavigator type = attribute.SelectSingleNode(typeExpression); + + writer.WriteString("["); + WriteTypeReference(type, false, 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(); + } + + } + + 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("nullptr"); + break; + case "typeValue": + writer.WriteKeyword("typeof"); + writer.WriteString("("); + WriteTypeReference(value.SelectSingleNode(typeExpression), false, 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("L\""); + 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(@"L'"); + writer.WriteString(text); + writer.WriteString(@"'"); + break; + } + break; + } + + } + + private void WriteMemberReference (XPathNavigator member, SyntaxWriter writer) { + string api = member.GetAttribute("api", String.Empty); + writer.WriteReferenceLink(api); + } + + private static XPathNavigator[] ConvertIteratorToArray (XPathNodeIterator iterator) { + XPathNavigator[] result = new XPathNavigator[iterator.Count]; + for (int i=0; i<result.Length; i++) { + iterator.MoveNext(); + result[i] = iterator.Current.Clone(); + } + return(result); + } + + + } + +}
\ No newline at end of file diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/CSharpDeclarationSyntax.cs b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/CSharpDeclarationSyntax.cs new file mode 100644 index 0000000..747d53f --- /dev/null +++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/CSharpDeclarationSyntax.cs @@ -0,0 +1,940 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// +using System; +using System.Collections.Generic; +using System.Xml.XPath; + +namespace Microsoft.Ddue.Tools { + + + public class CSharpDeclarationSyntaxGenerator : SyntaxGeneratorTemplate { + + public CSharpDeclarationSyntaxGenerator (XPathNavigator configuration) : base(configuration) { + if (String.IsNullOrEmpty(language)) language = "CSharp"; + } + + // namespace: done + public override void WriteNamespaceSyntax (XPathNavigator reflection, SyntaxWriter writer) { + + string name = reflection.Evaluate(apiNameExpression).ToString(); + + writer.WriteKeyword("namespace"); + writer.WriteString(" "); + writer.WriteIdentifier(name); + } + + // 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); + + } + + + // 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); + + } + + // 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); + WriteImplementedInterfaces(reflection, writer); + WriteGenericTemplateConstraints(reflection, writer); + + } + + // delegate: done + 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); + WriteVisibility(reflection, writer); + writer.WriteString(" "); + writer.WriteKeyword("delegate"); + writer.WriteString(" "); + WriteReturnValue(reflection, writer); + writer.WriteString(" "); + writer.WriteIdentifier(name); + WriteGenericTemplates(reflection, writer); + WriteMethodParameters(reflection, writer); + WriteGenericTemplateConstraints(reflection, writer); + + } + + // enumeration: still need to handle non-standard base + 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); + WriteVisibility(reflection, writer); + writer.WriteString(" "); + writer.WriteKeyword("enum"); + writer.WriteString(" "); + writer.WriteIdentifier(name); + } + + // constructor: done + public override void WriteConstructorSyntax (XPathNavigator reflection, SyntaxWriter writer) { + + string name = (string) reflection.Evaluate(apiContainingTypeNameExpression); + bool isStatic = (bool) reflection.Evaluate(apiIsStaticExpression); + + WriteAttributes(reflection, writer); + if (isStatic) { + writer.WriteKeyword("static"); + } else { + WriteVisibility(reflection, writer); + } + writer.WriteString(" "); + writer.WriteIdentifier(name); + WriteMethodParameters(reflection, writer); + + } + + // normal method: done + public override void WriteNormalMethodSyntax (XPathNavigator reflection, SyntaxWriter writer) { + + string name = (string) reflection.Evaluate(apiNameExpression); + + bool isExplicit = (bool) reflection.Evaluate(apiIsExplicitImplementationExpression); + + WriteAttributes(reflection, writer); + if (!isExplicit) WriteProcedureModifiers(reflection, writer); + WriteReturnValue(reflection, writer); + writer.WriteString(" "); + + if (isExplicit) { + XPathNavigator member = reflection.SelectSingleNode(apiImplementedMembersExpression); + //string memberName = (string) member.Evaluate(nameExpression); + //string id = member.GetAttribute("api", String.Empty); + XPathNavigator contract = member.SelectSingleNode(memberDeclaringTypeExpression); + WriteTypeReference(contract, writer); + writer.WriteString("."); + WriteMemberReference(member, writer); + //writer.WriteReferenceLink(id); + } else { + writer.WriteIdentifier(name); + } + WriteGenericTemplates(reflection, writer); + WriteMethodParameters(reflection, writer); + WriteGenericTemplateConstraints(reflection, 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); + } + } + + // cast: done + public override void WriteCastSyntax (XPathNavigator reflection, SyntaxWriter writer) { + + string name = (string) reflection.Evaluate(apiNameExpression); + + WriteProcedureModifiers(reflection, writer); + if (name == "Implicit") { + writer.WriteKeyword("implicit operator"); + } else if (name == "Explicit") { + writer.WriteKeyword("explicit operator"); + } else { + throw new Exception(); + } + writer.WriteString(" "); + WriteReturnValue(reflection, writer); + writer.WriteString(" "); + WriteMethodParameters(reflection, writer); + + } + + 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); + + WriteAttributes(reflection, writer); + if (!isExplicit) WriteProcedureModifiers(reflection, writer); + WriteReturnValue(reflection, writer); + writer.WriteString(" "); + + if (isExplicit) { + XPathNavigator member = reflection.SelectSingleNode(apiImplementedMembersExpression); + //string id = (string) member.GetAttribute("api", String.Empty); + XPathNavigator contract = member.SelectSingleNode(memberDeclaringTypeExpression); + WriteTypeReference(contract, writer); + writer.WriteString("."); + WriteMemberReference(member, writer); + //writer.WriteReferenceLink(id); + // writer.WriteIdentifier(memberName); + } else { + if (isDefault) { + 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(" }"); + + } + + public override void WriteEventSyntax (XPathNavigator reflection, SyntaxWriter writer) { + string name = (string) reflection.Evaluate(apiNameExpression); + XPathNavigator handler = reflection.SelectSingleNode(apiHandlerOfEventExpression); + bool isExplicit = (bool) reflection.Evaluate(apiIsExplicitImplementationExpression); + + WriteAttributes(reflection, writer); + if (!isExplicit) WriteProcedureModifiers(reflection, writer); + writer.WriteString("event"); + writer.WriteString(" "); + WriteTypeReference(handler, writer); + writer.WriteString(" "); + + if (isExplicit) { + XPathNavigator member = reflection.SelectSingleNode(apiImplementedMembersExpression); + //string id = (string) member.GetAttribute("api", String.Empty); + XPathNavigator contract = member.SelectSingleNode(memberDeclaringTypeExpression); + WriteTypeReference(contract, writer); + writer.WriteString("."); + WriteMemberReference(member, writer); + //writer.WriteReferenceLink(id); + // writer.WriteIdentifier(memberName); + } else { + writer.WriteIdentifier(name); + } + } + + private 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("static"); + writer.WriteString(" "); + } else { + if (isVirtual) { + if (isAbstract) { + writer.WriteKeyword("abstract"); + writer.WriteString(" "); + } else if (isOverride) { + writer.WriteKeyword("override"); + writer.WriteString(" "); + if (isFinal) { + writer.WriteKeyword("sealed"); + writer.WriteString(" "); + } + } else { + if (!isFinal) { + writer.WriteKeyword("virtual"); + writer.WriteString(" "); + } + } + } + } + + + } + + public override void WriteFieldSyntax (XPathNavigator reflection, SyntaxWriter writer) { + + 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); + + 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("static"); + } + writer.WriteString(" "); + } + if (isInitOnly) { + writer.WriteKeyword("readonly"); + writer.WriteString(" "); + } + WriteReturnValue(reflection, writer); + writer.WriteString(" "); + writer.WriteIdentifier(name); + + } + + // Visibility + + private void WriteVisibility (XPathNavigator reflection, SyntaxWriter writer) { + + string visibility = reflection.Evaluate(apiVisibilityExpression).ToString(); + WriteVisibility(visibility, writer); + } + + private 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 internal"); + break; + case "assembly": + writer.WriteKeyword("internal"); + break; + case "private": + writer.WriteKeyword("private"); + break; + case "family and assembly": + // this isn't handled in C# + break; + } + + } + + + // Attributes + + private void WriteAttribute (string reference, SyntaxWriter writer) { + writer.WriteString("["); + writer.WriteReferenceLink(reference); + writer.WriteString("]"); + writer.WriteLine(); + } + + + 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(); + } + + } + + 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; + } + + } + + // Interfaces + + private void WriteImplementedInterfaces (XPathNavigator reflection, SyntaxWriter writer) { + + XPathNodeIterator implements = reflection.Select(apiImplementedInterfacesExpression); + + if (implements.Count == 0) return; + writer.WriteString(" : "); + 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"); + } + } + } + + } + + 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"); + } + } + } + + } + + } + + // 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(name); + if (templates.CurrentPosition < templates.Count) writer.WriteString(", "); + } + writer.WriteString(">"); + } + + 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(); + } + + } + + // Parameters + + private void WriteMethodParameters (XPathNavigator reflection, SyntaxWriter writer) { + + XPathNodeIterator parameters = reflection.Select(apiParametersExpression); + + writer.WriteString("("); + if (parameters.Count > 0) { + writer.WriteLine(); + WriteParameters(parameters, reflection, writer); + } + writer.WriteString(")"); + + } + + private void WritePropertyParameters (XPathNavigator reflection, SyntaxWriter writer) { + + XPathNodeIterator parameters = reflection.Select(apiParametersExpression); + + if (parameters.Count == 0) return; + + writer.WriteString("["); + writer.WriteLine(); + WriteParameters(parameters, reflection, writer); + writer.WriteString("]"); + + } + + + 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(); + } + + } + + // Return Value + + private void WriteReturnValue (XPathNavigator reflection, SyntaxWriter writer) { + + XPathNavigator type = reflection.SelectSingleNode(apiReturnTypeExpression); + + if (type == null) { + writer.WriteKeyword("void"); + } else { + WriteTypeReference(type, writer); + } + } + + // 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); + 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 WriteNormalTypeReference (string api, SyntaxWriter writer) { + switch (api) { + case "T:System.Void": + writer.WriteReferenceLink(api, "void"); + 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, "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; + } + } + + private void WriteMemberReference (XPathNavigator member, SyntaxWriter writer) { + string api = member.GetAttribute("api", String.Empty); + writer.WriteReferenceLink(api); + } + + } + +} diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/JScriptDeclarationSyntax.cs b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/JScriptDeclarationSyntax.cs new file mode 100644 index 0000000..543936c --- /dev/null +++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/JScriptDeclarationSyntax.cs @@ -0,0 +1,428 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// +using System; +using System.Xml.XPath; + + +namespace Microsoft.Ddue.Tools { + + public class JScriptDeclarationSyntaxGenerator : SyntaxGeneratorTemplate { + + public JScriptDeclarationSyntaxGenerator (XPathNavigator configuration) : base(configuration) { + if (String.IsNullOrEmpty(language)) language = "JScript"; + } + + 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 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); + } + + public override void WriteStructureSyntax (XPathNavigator reflection, SyntaxWriter writer) { + if (IsUnsupportedGeneric(reflection, writer)) return; + writer.WriteMessage("UnsupportedStructure_" + Language); + } + + 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 WriteDelegateSyntax (XPathNavigator reflection, SyntaxWriter writer) { + if (IsUnsupportedGeneric(reflection, writer)) return; + writer.WriteMessage("UnsupportedDelegate_" + Language); + } + + 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 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 WriteNormalMethodSyntax (XPathNavigator reflection, SyntaxWriter writer) { + if (IsUnsupportedUnsafe(reflection, writer)) return; + if (IsUnsupportedGeneric(reflection, writer)) return; + if (IsUnsupportedExplicit(reflection, writer)) return; + + string name = (string)reflection.Evaluate(apiNameExpression); + XPathNavigator returnType = reflection.SelectSingleNode(apiReturnTypeExpression); + + WriteAttributeList(reflection, writer); + WriteProcedureModifiers(reflection, writer); + writer.WriteKeyword("function"); + writer.WriteString(" "); + writer.WriteIdentifier(name); + WriteParameterList(reflection, writer); + if (returnType != null) { + writer.WriteString(" : "); + WriteTypeReference(returnType, writer); + } + } + + 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); + WriteProcedureModifiers(reflection, writer); + writer.WriteKeyword("function get"); + writer.WriteString(" "); + writer.WriteIdentifier(name); + writer.WriteString(" () : "); + WriteTypeReference(type, writer); + writer.WriteLine(); + } + + if (isSettable) { + WriteAttributeList(reflection, writer); + WriteProcedureModifiers(reflection, writer); + writer.WriteKeyword("function set"); + writer.WriteString(" "); + writer.WriteIdentifier(name); + writer.WriteString(" ("); + writer.WriteParameter("value"); + writer.WriteString(" : "); + WriteTypeReference(type, writer); + writer.WriteString(")"); + } + + } + + 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); + + WriteAttributeList(reflection, writer); + WriteAccessModifier(reflection, writer); + if (isStatic) { + if (isLiteral) { + writer.WriteKeyword("const"); + } else { + writer.WriteKeyword("static"); + } + writer.WriteString(" "); + } + if (isInitOnly) { + writer.WriteKeyword("final"); + writer.WriteString(" "); + } + writer.WriteKeyword("var"); + writer.WriteString(" "); + writer.WriteIdentifier(name); + writer.WriteString(" : "); + WriteTypeReference(type, writer); + } + + public override void WriteOperatorSyntax (XPathNavigator reflection, SyntaxWriter writer) { + writer.WriteMessage("UnsupportedOperator_" + Language); + } + + public override void WriteCastSyntax (XPathNavigator reflection, SyntaxWriter writer) { + writer.WriteMessage("UnsupportedCast_" + Language); + } + + public override void WriteEventSyntax (XPathNavigator reflection, SyntaxWriter writer) { + writer.WriteMessage("UnsupportedEvent_" + Language); + } + + private void WriteBaseClass (XPathNavigator reflection, SyntaxWriter writer) { + XPathNavigator baseClass = reflection.SelectSingleNode(apiBaseClassExpression); + + if ((baseClass != null) && !((bool)baseClass.Evaluate(typeIsObjectExpression))) { + writer.WriteString(" "); + writer.WriteKeyword("extends"); + writer.WriteString(" "); + WriteTypeReference(baseClass, writer); + } + } + + private void WriteInterfaceList (XPathNavigator reflection, SyntaxWriter writer) { + WriteInterfaceList("implements", reflection, writer); + } + + 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(", "); + } + } + + private void WriteProcedureModifiers (XPathNavigator reflection, SyntaxWriter writer) { + + // interface members don't get modified + string typeSubgroup = (string)reflection.Evaluate(apiContainingTypeSubgroupExpression); + if (typeSubgroup == "interface") return; + + WriteAccessModifier(reflection, writer); + + // instance or virtual, static or abstract, etc. + 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); + if (isStatic) { + writer.WriteKeyword("static"); + writer.WriteString(" "); + } else { + // all members are virtual in JScript, so no virtual keyword is required + if (isVirtual) { + if (isAbstract) { + writer.WriteKeyword("abstract"); + writer.WriteString(" "); + } else { + if (isOverride) { + writer.WriteKeyword("override"); + writer.WriteString(" "); + } + if (isFinal) { + writer.WriteKeyword("final"); + writer.WriteString(" "); + } + } + } + } + } + + private void WriteParameterList (XPathNavigator reflection, SyntaxWriter writer) { + WriteParameterList(reflection, writer, true); + } + + private void WriteParameterList (XPathNavigator reflection, SyntaxWriter writer, bool newlines) { + XPathNodeIterator parameters = reflection.Select(apiParametersExpression); + + writer.WriteString("("); + if (newlines && (parameters.Count > 0)) writer.WriteLine(); + while (parameters.MoveNext()) { + XPathNavigator parameter = parameters.Current; + if (newlines) writer.WriteString("\t"); + WriteParameter(parameter, writer); + if (parameters.CurrentPosition < parameters.Count) writer.WriteString(", "); + if (newlines) writer.WriteLine(); + } + writer.WriteString(")"); + } + + // JScript has no in, out, optional, or reference parameters + private void WriteParameter (XPathNavigator parameter, SyntaxWriter writer) { + string name = (string)parameter.Evaluate(parameterNameExpression); + XPathNavigator type = parameter.SelectSingleNode(parameterTypeExpression); + bool isParamArray = (bool)parameter.Evaluate(parameterIsParamArrayExpression); + + if (isParamArray) { + writer.WriteString("... "); + } + + writer.WriteParameter(name); + writer.WriteString(" : "); + WriteTypeReference(type, writer); + } + + private void WriteAccessModifier (XPathNavigator reflection, SyntaxWriter writer) { + + string visibility = reflection.Evaluate(apiVisibilityExpression).ToString(); + + switch (visibility) { + case "public": + writer.WriteKeyword("public"); + break; + case "family": + writer.WriteKeyword("protected"); + break; + case "family or assembly": + writer.WriteKeyword("protected internal"); + break; + case "assembly": + writer.WriteKeyword("internal"); + break; + case "private": + writer.WriteKeyword("private"); + break; + case "family and assembly": + // this isn't handled in JScript + break; + } + + writer.WriteString(" "); + + } + + 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 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; + } + } + + private void WriteAttributeList (XPathNavigator reflection, SyntaxWriter writer) { + // fill in this logic + } + + } +} diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/JSharpDeclarationSyntax.cs b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/JSharpDeclarationSyntax.cs new file mode 100644 index 0000000..d1f3aa1 --- /dev/null +++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/JSharpDeclarationSyntax.cs @@ -0,0 +1,645 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// +using System; +using System.Collections.Generic; +using System.Xml.XPath; + +namespace Microsoft.Ddue.Tools { + + + public class JSharpDeclarationSyntaxGenerator : DeclarationSyntaxGeneratorTemplate { + + public JSharpDeclarationSyntaxGenerator (XPathNavigator configuration) : base(configuration) { + if (String.IsNullOrEmpty(language)) language = "JSharp"; + } + + // private static string unsupportedGeneric = "UnsupportedGeneric_JSharp"; + + public override void WriteNamespaceSyntax (XPathNavigator reflection, SyntaxWriter writer) { + + string name = reflection.Evaluate(apiNameExpression).ToString(); + + writer.WriteKeyword("package"); + writer.WriteString(" "); + writer.WriteIdentifier(name); + } + + + 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 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); + } + + public override void WriteInterfaceSyntax (XPathNavigator reflection, SyntaxWriter writer) { + + if (IsUnsupportedGeneric(reflection, writer)) return; + + string name = (string) reflection.Evaluate(apiNameExpression); + + WriteAttributes(reflection, writer); + WriteVisibility(reflection, writer); + writer.WriteString(" "); + writer.WriteKeyword("interface"); + writer.WriteString(" "); + writer.WriteIdentifier(name); + WriteImplementedInterfaces("extends", reflection, writer); + } + + public override void WriteDelegateSyntax (XPathNavigator reflection, SyntaxWriter 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); + + } + + 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); + WriteVisibility(reflection, writer); + writer.WriteString(" "); + writer.WriteKeyword("enum"); + writer.WriteString(" "); + writer.WriteIdentifier(name); + } + + public override void WriteConstructorSyntax (XPathNavigator reflection, SyntaxWriter writer) { + + if (IsUnsupportedUnsafe(reflection, writer)) return; + + string name = (string) reflection.Evaluate(apiContainingTypeNameExpression); + bool isStatic = (bool) reflection.Evaluate(apiIsStaticExpression); + + if (isStatic) { + // no static constructors in Java + writer.WriteMessage("UnsupportedStaticConstructor_" + Language); + return; + } + + WriteAttributes(reflection, writer); + WriteVisibility(reflection, writer); + writer.WriteString(" "); + writer.WriteIdentifier(name); + WriteMethodParameters(reflection, writer); + + } + + public override void WriteMethodSyntax (XPathNavigator reflection, SyntaxWriter writer) { + bool isSpecialName = (bool) reflection.Evaluate(apiIsSpecialExpression); + + if (isSpecialName) { + writer.WriteMessage("UnsupportedOperator_" + Language); + } else { + WriteNormalMethodSyntax(reflection, writer); + } + } + + private void WriteNormalMethodSyntax (XPathNavigator reflection, SyntaxWriter writer) { + + if (IsUnsupportedUnsafe(reflection, writer)) return; + if (IsUnsupportedGeneric(reflection, writer)) return; + if (IsUnsupportedExplicit(reflection, writer)) return; + + string name = (string) reflection.Evaluate(apiNameExpression); + + WriteAttributes(reflection, writer); + WriteProcedureModifiers(reflection, writer); + WriteReturnValue(reflection, writer); + writer.WriteString(" "); + writer.WriteIdentifier(name); + WriteMethodParameters(reflection, writer); + } + + private void WriteNamedNormalMethodSyntax (string name, XPathNavigator reflection, SyntaxWriter writer) { + + + } + + public override void WritePropertySyntax (XPathNavigator reflection, SyntaxWriter 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(); + // 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(); + // write setter method + WriteAttributes(reflection, writer); + WriteProcedureModifiers(reflection, writer); + writer.WriteString(" "); + 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(); + } + + } + + public override void WriteEventSyntax (XPathNavigator reflection, SyntaxWriter writer) { + + if (IsUnsupportedUnsafe(reflection, writer)) return; + + string name = (string) reflection.Evaluate(apiNameExpression); + XPathNavigator handler = reflection.SelectSingleNode(apiHandlerOfEventExpression); + + writer.WriteString("/** @event */"); + writer.WriteLine(); + // add_ method declaration + WriteAttributes(reflection, writer); + WriteProcedureModifiers(reflection, writer); + WriteReturnValue(reflection, writer); + writer.WriteString(" "); + writer.WriteIdentifier("add_" + name); + writer.WriteString(" ("); + WriteTypeReference(handler, writer); + writer.WriteString(" "); + writer.WriteParameter("value"); + writer.WriteString(")"); + writer.WriteLine(); + + writer.WriteString("/** @event */"); + writer.WriteLine(); + // remove_ method declaration + WriteAttributes(reflection, writer); + WriteProcedureModifiers(reflection, writer); + WriteReturnValue(reflection, writer); + writer.WriteString(" "); + writer.WriteIdentifier("remove_" + name); + writer.WriteString(" ("); + WriteTypeReference(handler, writer); + writer.WriteString(" "); + writer.WriteParameter("value"); + writer.WriteString(")"); + writer.WriteLine(); + + } + + private 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("static"); + writer.WriteString(" "); + } else { + if (isVirtual) { + if (isAbstract) { + writer.WriteKeyword("abstract"); + writer.WriteString(" "); + } else if (isFinal) { + writer.WriteKeyword("final"); + writer.WriteString(" "); + } + } + } + + } + + public override void WriteFieldSyntax (XPathNavigator reflection, SyntaxWriter writer) { + + 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); + + if (!isSerialized) WriteAttribute("T:System.NonSerializedAttribute", writer); + WriteAttributes(reflection, writer); + WriteVisibility(reflection, writer); + writer.WriteString(" "); + // Java doesn't support literals as distinct from static initonly + if (isStatic) { + writer.WriteKeyword("static"); + writer.WriteString(" "); + } + if (isLiteral || isInitOnly) { + writer.WriteKeyword("final"); + writer.WriteString(" "); + } + WriteReturnValue(reflection, writer); + writer.WriteString(" "); + writer.WriteIdentifier(name); + + } + + // Visibility + + protected override void WriteVisibility (XPathNavigator reflection, SyntaxWriter writer) { + + string visibility = reflection.Evaluate(apiVisibilityExpression).ToString(); + + switch (visibility) { + case "public": + writer.WriteKeyword("public"); + break; + case "family": + // in Java, protected = family or assembly + writer.WriteKeyword("protected"); + break; + case "family or assembly": + writer.WriteKeyword("protected"); + break; + case "assembly": + // no assembly-only access in Java + break; + case "private": + writer.WriteKeyword("private"); + break; + } + + } + + // Attributes + + private void WriteAttribute (string reference, SyntaxWriter writer) { + WriteAttribute(reference, writer, true); + } + + private void WriteAttribute (string reference, SyntaxWriter writer, bool newline) { + writer.WriteString("/** @attribute "); + writer.WriteReferenceLink(reference); + writer.WriteString(" */ "); + if (newline) writer.WriteLine(); + } + + + private void WriteAttributes (XPathNavigator reflection, SyntaxWriter writer) { + + XPathNodeIterator attributes = (XPathNodeIterator) reflection.Evaluate(apiAttributesExpression); + + foreach (XPathNavigator attribute in attributes) { + + XPathNavigator type = attribute.SelectSingleNode(attributeTypeExpression); + + writer.WriteString("/** @attribute "); + 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(", "); + 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(", "); + writer.WriteString((string) assignment.Evaluate(assignmentNameExpression)); + writer.WriteString(" = "); + WriteValue(assignment, writer); + } + writer.WriteString(")"); + } + + writer.WriteString(" */"); + writer.WriteLine(); + } + + } + + 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": + // 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": + 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; + } + + } + + // Interfaces + + private void WriteImplementedInterfaces (XPathNavigator reflection, SyntaxWriter writer) { + WriteImplementedInterfaces("implements", reflection, writer); + } + + private void WriteImplementedInterfaces (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(", "); + if (writer.Position > maxPosition) { + writer.WriteLine(); + writer.WriteString("\t"); + } + } + } + + } + // Parameters + + private void WriteMethodParameters (XPathNavigator reflection, SyntaxWriter writer) { + + XPathNodeIterator parameters = reflection.Select(apiParametersExpression); + + writer.WriteString("("); + if (parameters.Count > 0) { + writer.WriteLine(); + WriteParameters(parameters, reflection, writer); + } + writer.WriteString(")"); + + } + + + private void WriteParameters (XPathNodeIterator parameters, XPathNavigator reflection, SyntaxWriter writer) { + + 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 (isIn) WriteAttribute("T:System.Runtime.InteropServices.InAttribute", writer, false); + if (isOut) WriteAttribute("T:System.Runtime.InteropServices.OutAttribute", writer, false); + if (isRef) { + writer.WriteString("/** @ref */"); + } + + WriteTypeReference(type, writer); + writer.WriteString(" "); + writer.WriteParameter(name); + + if (parameters.CurrentPosition < parameters.Count) writer.WriteString(","); + writer.WriteLine(); + } + + } + + // Return Value + + private void WriteReturnValue (XPathNavigator reflection, SyntaxWriter writer) { + + XPathNavigator type = reflection.SelectSingleNode(apiReturnTypeExpression); + + if (type == null) { + writer.WriteKeyword("void"); + } else { + WriteTypeReference(type, writer); + } + } + + // 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); + 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 WriteNormalTypeReference (string reference, SyntaxWriter writer) { + switch (reference) { + case "T:System.Void": + writer.WriteReferenceLink(reference, "void"); + break; + case "T:System.Boolean": + writer.WriteReferenceLink(reference, "boolean"); + break; + case "T:System.Byte": + writer.WriteReferenceLink(reference, "byte"); + break; + case "T:System.Char": + writer.WriteReferenceLink(reference, "char"); + break; + case "T:System.Int16": + writer.WriteReferenceLink(reference, "short"); + break; + case "T:System.Int32": + writer.WriteReferenceLink(reference, "int"); + break; + case "T:System.Int64": + writer.WriteReferenceLink(reference, "long"); + break; + case "T:System.Single": + writer.WriteReferenceLink(reference, "float"); + break; + case "T:System.Double": + writer.WriteReferenceLink(reference, "double"); + break; + default: + writer.WriteReferenceLink(reference); + break; + } + } + + + } + +} diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/Microsoft.Ddue.Tools.BuildComponents.SyntaxGenerators.asmmeta b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/Microsoft.Ddue.Tools.BuildComponents.SyntaxGenerators.asmmeta new file mode 100644 index 0000000..f738af6 --- /dev/null +++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/Microsoft.Ddue.Tools.BuildComponents.SyntaxGenerators.asmmeta @@ -0,0 +1,421 @@ +.assembly extern Microsoft.Ddue.Tools.BuildComponents +{ + .publickeytoken = (4D DC 2B E8 53 17 C2 74) +} +.assembly extern System.Xml +{ + .publickeytoken = (B7 7A 5C 56 19 34 E0 89) +} +.assembly Microsoft.Ddue.Tools.BuildComponents.SyntaxGenerators +{ + .publickey = (00 24 00 00 04 80 00 00 94 00 00 00 06 02 00 00 00 24 00 00 52 53 41 31 00 04 00 00 01 00 01 00 EF 09 EE D7 93 0B 34 BA 88 83 E7 DB 9F 08 F5 DF A0 D9 F1 7A 97 8E 98 F3 99 03 36 B2 2A 75 D6 BB 2C 25 90 6C 4F 4E 5D 42 60 00 A9 22 00 A9 CE FE 3F 5E C4 22 BA 1E FF 47 7D C4 14 E7 52 C3 30 07 1C 66 1C 58 3F 28 48 0C 03 35 94 CE 5F A5 FC 44 94 D2 A4 42 95 E5 A3 3E AD B2 FD FF 45 13 77 FD BE 62 48 38 EF 02 BF 22 54 00 56 5D DB DA 10 D8 7E 77 F9 7F 9F 20 60 11 4B 49 3A 4D 62 FE C3 C3) + .hash algorithm 0x00008004 +} +.namespace Microsoft.Ddue.Tools +{ + .class public CPlusPlusDeclarationSyntaxGenerator + extends Microsoft.Ddue.Tools.DeclarationSyntaxGeneratorTemplate + { + .method public virtual hidebysig specialname + instance string get_Language() + { + ret + } + .method public virtual hidebysig + instance void WriteNamespaceSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteClassSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteStructureSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteInterfaceSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteDelegateSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteEnumerationSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteConstructorSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteMethodSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WritePropertySyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteEventSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteFieldSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method family virtual hidebysig + instance void WriteVisibility(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method family virtual hidebysig + instance void WriteGenericTemplates(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public hidebysig specialname + instance void .ctor() + { + ret + } + .property instance string Language() + { + .get instance string Microsoft.Ddue.Tools.CPlusPlusDeclarationSyntaxGenerator::get_Language() + } + } + .class public CSharpDeclarationSyntaxGenerator + extends Microsoft.Ddue.Tools.DeclarationSyntaxGeneratorTemplate + { + .method public virtual hidebysig specialname + instance string get_Language() + { + ret + } + .method public virtual hidebysig + instance void WriteNamespaceSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteClassSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteStructureSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteInterfaceSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteDelegateSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteEnumerationSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteConstructorSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteMethodSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WritePropertySyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteEventSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteFieldSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method family virtual hidebysig + instance void WriteVisibility(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method family virtual hidebysig + instance void WriteGenericTemplates(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public hidebysig specialname + instance void .ctor() + { + ret + } + .property instance string Language() + { + .get instance string Microsoft.Ddue.Tools.CSharpDeclarationSyntaxGenerator::get_Language() + } + } + .class public abstract DeclarationSyntaxGeneratorTemplate + extends Microsoft.Ddue.Tools.SyntaxGeneratorTemplate + { + .method family virtual hidebysig newslot abstract + instance void WriteVisibility(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + } + .method family virtual hidebysig newslot abstract + instance void WriteGenericTemplates(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + } + .method family static hidebysig + string[] SeperateTypes(string typelist) + { + ret + } + .method family static hidebysig + string GetTemplateParameterName(string reference, class [System.Xml]System.Xml.XPath.XPathNavigator reflection) + { + ret + } + .method family hidebysig specialname + instance void .ctor() + { + ret + } + } + .class public abstract SyntaxGeneratorTemplate + extends [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxGenerator + { + .method public virtual hidebysig newslot abstract specialname + instance string get_Language() + { + } + .method public virtual hidebysig + instance void WriteSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig newslot + instance void WriteTypeSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig newslot + instance void WriteMemberSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig newslot abstract + instance void WriteNamespaceSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + } + .method public virtual hidebysig newslot abstract + instance void WriteClassSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + } + .method public virtual hidebysig newslot abstract + instance void WriteStructureSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + } + .method public virtual hidebysig newslot abstract + instance void WriteInterfaceSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + } + .method public virtual hidebysig newslot abstract + instance void WriteDelegateSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + } + .method public virtual hidebysig newslot abstract + instance void WriteEnumerationSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + } + .method public virtual hidebysig newslot abstract + instance void WriteConstructorSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + } + .method public virtual hidebysig newslot abstract + instance void WriteMethodSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + } + .method public virtual hidebysig newslot abstract + instance void WritePropertySyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + } + .method public virtual hidebysig newslot abstract + instance void WriteFieldSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + } + .method public virtual hidebysig newslot abstract + instance void WriteEventSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + } + .method family hidebysig specialname + instance void .ctor() + { + ret + } + .field static family class [System.Xml]System.Xml.XPath.XPathExpression abstract_procedure_expression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiAttributesExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiBaseClassExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiContainingTypeNameExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiContainingTypeSubgroupExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiGroupExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiHandlerOfEventExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiImplementedInterfacesExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiImplementedMembersExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiIsAbstractTypeExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiIsExplicitImplementationExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiIsInitOnlyFieldExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiIsLiteralFieldExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiIsOverrideExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiIsReadPropertyExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiIsSealedTypeExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiIsSerializableTypeExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiIsSerializedFieldExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiIsSpecialExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiIsStaticExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiIsVolatileFieldExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiIsWritePropertyExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiNameExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiOverridesMemberExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiParametersExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiReturnTypeExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiSubgroupExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiTemplatesExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiVisibilityExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiVisibilityOfMemberExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression apiVisibilityOfTypeExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression assignmentNameExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression attributeArgumentsExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression attributeAssignmentsExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression attributeTypeExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression final_expression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression memberDeclaringTypeExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression nameExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression parameterIsInExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression parameterIsOutExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression parameterIsParamArrayExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression parameterIsRefExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression parameterNameExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression parameterTypeExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression templateNameExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression typeExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression typeIdExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression typeIsObjectExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression typeModifiersExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression typeOuterTypeExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression valueExpression + .field static family class [System.Xml]System.Xml.XPath.XPathExpression virtual_expression + .property instance string Language() + { + .get instance string Microsoft.Ddue.Tools.SyntaxGeneratorTemplate::get_Language() + } + } + .class public VisualBasicDeclarationSyntaxGenerator + extends Microsoft.Ddue.Tools.DeclarationSyntaxGeneratorTemplate + { + .method public virtual hidebysig specialname + instance string get_Language() + { + ret + } + .method public virtual hidebysig + instance void WriteNamespaceSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteClassSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteStructureSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteInterfaceSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteDelegateSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteEnumerationSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteConstructorSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteMethodSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WritePropertySyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteEventSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public virtual hidebysig + instance void WriteFieldSyntax(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method family virtual hidebysig + instance void WriteVisibility(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method family virtual hidebysig + instance void WriteGenericTemplates(class [System.Xml]System.Xml.XPath.XPathNavigator reflection, class [Microsoft.Ddue.Tools.BuildComponents]Microsoft.Ddue.Tools.SyntaxWriter writer) + { + ret + } + .method public hidebysig specialname + instance void .ctor() + { + ret + } + .property instance string Language() + { + .get instance string Microsoft.Ddue.Tools.VisualBasicDeclarationSyntaxGenerator::get_Language() + } + } +} + diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/Properties/AssemblyInfo.cs b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..dc43d72 --- /dev/null +++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/Properties/AssemblyInfo.cs @@ -0,0 +1,37 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("SyntaxComponents")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("Microsoft")] +[assembly: AssemblyProduct("SyntaxComponents")] +[assembly: AssemblyCopyright("Copyright © Microsoft 2006")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("52404499-7bf9-4908-88db-44f8de788cf0")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Revision and Build Numbers +// by using the '*' as shown below: +[assembly: AssemblyVersion("2.4.10522.00")] +[assembly: AssemblyFileVersion("2.4.10522.00")] diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/ScriptSharpDeclarationSyntax.cs b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/ScriptSharpDeclarationSyntax.cs new file mode 100644 index 0000000..e0f3c07 --- /dev/null +++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/ScriptSharpDeclarationSyntax.cs @@ -0,0 +1,611 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// +using System; +using System.Xml.XPath; +using System.Globalization; + +namespace Microsoft.Ddue.Tools { + /// <summary> + /// Generates syntax that corresponds to JavaScript that Script# generates. + /// </summary> + public class ScriptSharpDeclarationSyntaxGenerator : SyntaxGeneratorTemplate { + private static readonly XPathExpression typeIsRecordExpression = XPathExpression.Compile("boolean(apidata/@record)"); + + private static readonly XPathExpression memberIsGlobalExpression = XPathExpression.Compile("boolean(apidata/@global)"); + + /// <summary> + /// Initializes a new instance of the <c>ScriptSharpDeclarationSyntaxGenerator</c> class. + /// </summary> + /// <param name="configuration"></param> + public ScriptSharpDeclarationSyntaxGenerator(XPathNavigator configuration) : base(configuration) { + if (String.IsNullOrEmpty(language)) language = "JavaScript"; + } + + /// <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; + } + + private string ReadNamespaceName(XPathNavigator reflection) { + return (string)reflection.Evaluate(apiContainingNamespaceNameExpression); + } + + private string ReadTypeName(XPathNavigator reflection) { + return (string)reflection.Evaluate(apiNameExpression); + } + + private string ReadContainingTypeName(XPathNavigator reflection) { + return (string)reflection.Evaluate(apiContainingTypeNameExpression); + } + + private string ReadFullTypeName(XPathNavigator reflection) { + string namespaceName = ReadNamespaceName(reflection); + + string typeName = ReadTypeName(reflection); + + if (String.IsNullOrEmpty(namespaceName) || HasAttribute(reflection, "System.IgnoreNamespaceAttribute")) { + return typeName; + } + else { + return String.Format("{0}.{1}", namespaceName, typeName); + } + } + + private string ReadFullContainingTypeName(XPathNavigator reflection) { + string namespaceName = ReadNamespaceName(reflection); + + string typeName = ReadContainingTypeName(reflection); + + if (String.IsNullOrEmpty(namespaceName) || HasAttribute(reflection, "System.IgnoreNamespaceAttribute")) { + return typeName; + } + else { + return String.Format("{0}.{1}", namespaceName, typeName); + } + } + + private string ReadMemberName(XPathNavigator reflection) { + string identifier = (string)reflection.Evaluate(apiNameExpression); + + if (!HasAttribute(reflection, "System.PreserveCaseAttribute")) { + identifier = CreateCamelCaseName(identifier); + } + + return identifier; + } + + private bool HasAttribute(XPathNavigator reflection, string attributeName) { + attributeName = "T:" + attributeName; + + XPathNodeIterator iterator = (XPathNodeIterator)reflection.Evaluate(apiAttributesExpression); + foreach (XPathNavigator navigator in iterator) { + XPathNavigator reference = navigator.SelectSingleNode(attributeTypeExpression); + if (reference.GetAttribute("api", string.Empty) == attributeName) { + return true; + } + } + + return false; + } + + public static string CreateCamelCaseName(string name) { + + if (String.IsNullOrEmpty(name)) { + return name; + } + + // Some exceptions that simply need to be special cased + if (name.Equals("ID", StringComparison.Ordinal)) { + return "id"; + } + + bool hasLowerCase = false; + int conversionLength = 0; + + for (int i = 0; i < name.Length; i++) { + if (Char.IsUpper(name, i)) { + conversionLength++; + } else { + hasLowerCase = true; + break; + } + } + + if (((hasLowerCase == false) && (name.Length != 1)) || (conversionLength == 0)) { + // Name is all upper case, or all lower case; leave it as-is. + return name; + } + + if (conversionLength > 1) { + // Convert the leading uppercase segment, except the last character + // which is assumed to be the first letter of the next word + return name.Substring(0, conversionLength - 1).ToLower(CultureInfo.InvariantCulture) + name.Substring(conversionLength - 1); + } + + else if (name.Length == 1) { + return name.ToLower(CultureInfo.InvariantCulture); + } + + else { + // Convert the leading upper case character to lower case + return Char.ToLower(name[0], CultureInfo.InvariantCulture) + name.Substring(1); + } + } + + private void WriteIndentedNewLine(SyntaxWriter writer) { + writer.WriteString(","); + writer.WriteLine(); + writer.WriteString("\t"); + } + + private void WriteParameterList(XPathNavigator reflection, SyntaxWriter writer) { + XPathNodeIterator parameters = reflection.Select(apiParametersExpression); + writer.WriteString("("); + + while (parameters.MoveNext()) { + XPathNavigator parameter = parameters.Current; + + WriteParameter(parameter, writer); + if (parameters.CurrentPosition < parameters.Count) { + writer.WriteString(", "); + } + } + writer.WriteString(")"); + } + + private void WriteParameter(XPathNavigator parameter, SyntaxWriter writer) { + string text = (string)parameter.Evaluate(parameterNameExpression); + XPathNavigator reference = parameter.SelectSingleNode(parameterTypeExpression); + if ((bool)parameter.Evaluate(parameterIsParamArrayExpression)) { + writer.WriteString("... "); + } + writer.WriteParameter(text); + } + + private void WriteTypeReference(XPathNavigator reference, SyntaxWriter writer) + { + switch (reference.LocalName) + { + case "arrayOf": + int rank = Convert.ToInt32(reference.GetAttribute("rank", string.Empty)); + XPathNavigator navigator = reference.SelectSingleNode(typeExpression); + WriteTypeReference(navigator, writer); + writer.WriteString("["); + for (int i = 1; i < rank; i++) { writer.WriteString(","); } + writer.WriteString("]"); + break; + case "type": + string id = reference.GetAttribute("api", string.Empty); + WriteNormalTypeReference(id, writer); + break; + case "pointerTo": + case "referenceTo": + case "template": + case "specialization": + // Not supported + break; + } + } + + private void WriteNormalTypeReference(string api, SyntaxWriter writer) { + switch (api) { + case "T:System.Byte": + writer.WriteReferenceLink(api, "Byte"); + return; + + case "T:System.SByte": + writer.WriteReferenceLink(api, "SByte"); + return; + + case "T:System.Char": + writer.WriteReferenceLink(api, "Char"); + return; + + case "T:System.Int16": + writer.WriteReferenceLink(api, "Int16"); + return; + + case "T:System.Int32": + writer.WriteReferenceLink(api, "Int32"); + return; + + case "T:System.Int64": + writer.WriteReferenceLink(api, "Int64"); + return; + + case "T:System.UInt16": + writer.WriteReferenceLink(api, "UInt16"); + return; + + case "T:System.UInt32": + writer.WriteReferenceLink(api, "UInt32"); + return; + + case "T:System.UInt64": + writer.WriteReferenceLink(api, "UInt64"); + return; + + case "T:System.Single": + writer.WriteReferenceLink(api, "Single"); + return; + + case "T:System.Double": + writer.WriteReferenceLink(api, "Double"); + return; + + case "T:System.Decimal": + writer.WriteReferenceLink(api, "Decimal"); + return; + + case "T:System.Boolean": + writer.WriteReferenceLink(api, "Boolean"); + return; + } + + // Remove 'T:' + string name = api.Substring(2); + + // Strip System namespaces + if (name.StartsWith("System.")) { + int idx = name.LastIndexOf('.'); + name = name.Substring(idx + 1); + } + + writer.WriteReferenceLink(api, name); + } + + private void WriteRecordSyntax(XPathNavigator reflection, SyntaxWriter writer) { + string namespaceName = ReadNamespaceName(reflection); + + string typeName = ReadTypeName(reflection); + + writer.WriteString(namespaceName); + writer.WriteString(".$create_"); + writer.WriteString(typeName); + writer.WriteString(" = "); + writer.WriteKeyword("function"); + writer.WriteString("();"); + } + + private void WriteRecordConstructorSyntax(XPathNavigator reflection, SyntaxWriter writer) { + string namespaceName = ReadNamespaceName(reflection); + + string typeName = ReadContainingTypeName(reflection); + + writer.WriteString(namespaceName); + writer.WriteString(".$create_"); + writer.WriteString(typeName); + writer.WriteString(" = "); + writer.WriteKeyword("function"); + WriteParameterList(reflection, writer); + writer.WriteString(";"); + } + + public override void WriteClassSyntax(XPathNavigator reflection, SyntaxWriter writer) { + if (IsUnsupported(reflection, writer)) return; + + if (HasAttribute(reflection, "System.RecordAttribute")) { + WriteRecordSyntax(reflection, writer); + return; + } + + string typeName = ReadFullTypeName(reflection); + + writer.WriteIdentifier(typeName); + writer.WriteString(" = "); + writer.WriteKeyword("function"); + writer.WriteString("();"); + + writer.WriteLine(); + writer.WriteLine(); + + writer.WriteIdentifier("Type"); + writer.WriteString(".createClass("); + writer.WriteLine(); + writer.WriteString("\t'"); + writer.WriteString(typeName); + writer.WriteString("'"); + + bool hasBaseClass = false; + + // Write the base class. + XPathNavigator reference = reflection.SelectSingleNode(apiBaseClassExpression); + if (!((reference == null) || ((bool)reference.Evaluate(typeIsObjectExpression)))) { + WriteIndentedNewLine(writer); + WriteTypeReference(reference, writer); + hasBaseClass = true; + } + + // Write the interfaces. + XPathNodeIterator iterator = reflection.Select(apiImplementedInterfacesExpression); + if (iterator.Count != 0) { + if (!hasBaseClass) { + WriteIndentedNewLine(writer); + writer.WriteString("null"); + } + + WriteIndentedNewLine(writer); + + while (iterator.MoveNext()) { + XPathNavigator interfaceRef = iterator.Current; + WriteTypeReference(interfaceRef, writer); + if (iterator.CurrentPosition < iterator.Count) { + WriteIndentedNewLine(writer); + } + } + } + + writer.WriteString(");"); + } + + public override void WriteConstructorSyntax(XPathNavigator reflection, SyntaxWriter writer) { + if (IsUnsupported(reflection, writer)) { + return; + } + + bool isRecord = (bool)reflection.Evaluate(typeIsRecordExpression); + + if (isRecord) { + WriteRecordConstructorSyntax(reflection, writer); + return; + } + + string typeName = ReadFullContainingTypeName(reflection); + + writer.WriteIdentifier(typeName); + writer.WriteString(" = "); + writer.WriteKeyword("function"); + WriteParameterList(reflection, writer); + writer.WriteString(";"); + } + + public override void WriteNormalMethodSyntax(XPathNavigator reflection, SyntaxWriter writer) { + if (IsUnsupported(reflection, writer)) return; + + if (HasAttribute(reflection, "System.AttachedPropertyAttribute")) { + WriteAttachedPropertySyntax(reflection, writer); + return; + } + + string memberName = ReadMemberName(reflection); + + bool isStatic = (bool)reflection.Evaluate(apiIsStaticExpression); + bool isGlobal = (bool)reflection.Evaluate(memberIsGlobalExpression); + + if (isStatic && !isGlobal) { + writer.WriteIdentifier(ReadFullContainingTypeName(reflection)); + writer.WriteString("."); + writer.WriteIdentifier(memberName); + writer.WriteString(" = "); + writer.WriteKeyword("function"); + } + else { + writer.WriteKeyword("function"); + writer.WriteString(" "); + writer.WriteIdentifier(memberName); + } + + WriteParameterList(reflection, writer); + writer.WriteString(";"); + } + + public override void WriteDelegateSyntax(XPathNavigator reflection, SyntaxWriter writer) { + writer.WriteKeyword("function"); + WriteParameterList(reflection, writer); + writer.WriteString(";"); + } + + public override void WriteEnumerationSyntax(XPathNavigator reflection, SyntaxWriter writer) { + string typeName = ReadFullTypeName(reflection); + + writer.WriteIdentifier(typeName); + writer.WriteString(" = "); + writer.WriteKeyword("function"); + writer.WriteString("();"); + + writer.WriteLine(); + + writer.WriteIdentifier(typeName); + writer.WriteString(".createEnum('"); + writer.WriteIdentifier(typeName); + writer.WriteString("', "); + writer.WriteString(HasAttribute(reflection, "System.FlagsAttribute") ? "true" : "false"); + writer.WriteString(");"); + } + + public override void WriteEventSyntax(XPathNavigator reflection, SyntaxWriter writer) { + if (IsUnsupported(reflection, writer)) return; + + if (reflection.Select(apiParametersExpression).Count > 0) { + writer.WriteMessage("UnsupportedIndex_" + Language); + return; + } + + string memberName = ReadMemberName(reflection); + + writer.WriteKeyword("function"); + writer.WriteString(" add_"); + writer.WriteIdentifier(memberName); + writer.WriteString("("); + writer.WriteParameter("value"); + writer.WriteString(");"); + + writer.WriteLine(); + + writer.WriteKeyword("function"); + writer.WriteString(" remove_"); + writer.WriteIdentifier(memberName); + writer.WriteString("("); + writer.WriteParameter("value"); + writer.WriteString(");"); + } + + public override void WriteFieldSyntax(XPathNavigator reflection, SyntaxWriter writer) + { + if (IsUnsupported(reflection, writer)) { + return; + } + + string memberName = ReadMemberName(reflection); + + bool isStatic = (bool)reflection.Evaluate(apiIsStaticExpression); + if (isStatic) { + string typeName = ReadFullContainingTypeName(reflection); + + writer.WriteIdentifier(typeName); + writer.WriteString("."); + } + + writer.WriteIdentifier(memberName); + } + + public override void WriteInterfaceSyntax(XPathNavigator reflection, SyntaxWriter writer) { + if (IsUnsupported(reflection, writer)) return; + + string typeName = ReadFullTypeName(reflection); + + writer.WriteIdentifier(typeName); + writer.WriteString(" = "); + writer.WriteKeyword("function"); + writer.WriteString("();"); + + writer.WriteLine(); + + writer.WriteIdentifier(typeName); + writer.WriteString(".createInterface('"); + writer.WriteIdentifier(typeName); + writer.WriteString("');"); + } + + public override void WriteAttachedEventSyntax(XPathNavigator reflection, SyntaxWriter writer) { + // Not supported + } + + public override void WriteAttachedPropertySyntax(XPathNavigator reflection, SyntaxWriter writer) { + string typeName = ReadContainingTypeName(reflection); + + string methodName = ReadMemberName(reflection); + + string propertyName = String.Format("{0}.{1}", typeName, methodName.Substring(3)); + + if (methodName.StartsWith("Get", StringComparison.OrdinalIgnoreCase)) { + writer.WriteKeyword("var"); + writer.WriteString(" value = obj['"); + writer.WriteString(propertyName); + writer.WriteString("'];"); + } + else if (methodName.StartsWith("Set", StringComparison.OrdinalIgnoreCase)) { + writer.WriteString("obj['"); + writer.WriteString(propertyName); + writer.WriteString("'] = value;"); + } + } + + public override void WriteOperatorSyntax(XPathNavigator reflection, SyntaxWriter writer) { + writer.WriteMessage("UnsupportedOperator_" + Language); + } + + public override void WriteCastSyntax(XPathNavigator reflection, SyntaxWriter writer) { + writer.WriteMessage("UnsupportedCast_" + Language); + } + + public override void WriteNamespaceSyntax(XPathNavigator reflection, SyntaxWriter writer) { + string name = reflection.Evaluate(apiNameExpression).ToString(); + + writer.WriteString("Type.createNamespace('"); + writer.WriteIdentifier(name); + writer.WriteString("');"); + } + + public override void WritePropertySyntax(XPathNavigator reflection, SyntaxWriter writer) { + if (IsUnsupported(reflection, writer)) return; + + if (HasAttribute(reflection, "System.IntrinsicPropertyAttribute")) { + WriteFieldSyntax(reflection, writer); + return; + } + + string memberName = ReadMemberName(reflection); + + bool isStatic = (bool)reflection.Evaluate(apiIsStaticExpression); + + bool isGetter = (bool)reflection.Evaluate(apiIsReadPropertyExpression); + bool isSetter = (bool)reflection.Evaluate(apiIsWritePropertyExpression); + + XPathNavigator reference = reflection.SelectSingleNode(apiReturnTypeExpression); + + if (isGetter) { + if (isStatic) { + writer.WriteIdentifier(ReadFullContainingTypeName(reflection)); + writer.WriteString("."); + + writer.WriteString("get_"); + writer.WriteIdentifier(memberName); + writer.WriteString(" = "); + writer.WriteKeyword("function"); + } + else { + writer.WriteKeyword("function"); + writer.WriteString(" "); + + writer.WriteString("get_"); + writer.WriteIdentifier(memberName); + } + + WriteParameterList(reflection, writer); + writer.WriteString(";"); + writer.WriteLine(); + } + + if (isSetter) { + if (isStatic) { + writer.WriteIdentifier(ReadFullContainingTypeName(reflection)); + writer.WriteString("."); + + writer.WriteString("set_"); + writer.WriteIdentifier(memberName); + writer.WriteString(" = "); + writer.WriteKeyword("function"); + } + else { + writer.WriteKeyword("function"); + writer.WriteString(" "); + + writer.WriteString("set_"); + writer.WriteIdentifier(memberName); + } + + writer.WriteString("("); + writer.WriteParameter("value"); + writer.WriteString(");"); + } + } + + public override void WriteStructureSyntax(XPathNavigator reflection, SyntaxWriter writer) { + if (IsUnsupported(reflection, writer)) return; + writer.WriteMessage("UnsupportedStructure_" + Language); + } + } +}
\ No newline at end of file diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/SyntaxComponents.csproj b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/SyntaxComponents.csproj new file mode 100644 index 0000000..7453b3b --- /dev/null +++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/SyntaxComponents.csproj @@ -0,0 +1,98 @@ +<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5"> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <ProductVersion>9.0.30729</ProductVersion> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{CEAEC85B-973A-4414-8668-723EB65E5088}</ProjectGuid> + <OutputType>Library</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <RootNamespace>SyntaxComponents</RootNamespace> + <AssemblyName>SyntaxComponents</AssemblyName> + <SccProjectName> + </SccProjectName> + <SccLocalPath> + </SccLocalPath> + <SccAuxPath> + </SccAuxPath> + <SccProvider> + </SccProvider> + <SignAssembly>false</SignAssembly> + <AssemblyOriginatorKeyFile>../../../key.snk</AssemblyOriginatorKeyFile> + <FileUpgradeFlags> + </FileUpgradeFlags> + <OldToolsVersion>2.0</OldToolsVersion> + <UpgradeBackupLocation> + </UpgradeBackupLocation> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + <DebugSymbols>true</DebugSymbols> + <DebugType>full</DebugType> + <Optimize>false</Optimize> + <OutputPath>bin\Debug\</OutputPath> + <DefineConstants>DEBUG;TRACE</DefineConstants> + <ErrorReport>prompt</ErrorReport> + <WarningLevel>4</WarningLevel> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + <DebugType>pdbonly</DebugType> + <Optimize>true</Optimize> + <OutputPath>bin\Release\</OutputPath> + <DefineConstants>TRACE</DefineConstants> + <ErrorReport>prompt</ErrorReport> + <WarningLevel>4</WarningLevel> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'WebDocsDebug|AnyCPU' "> + <DebugSymbols>true</DebugSymbols> + <OutputPath>bin\WebDocsDebug\</OutputPath> + <DefineConstants>DEBUG;TRACE</DefineConstants> + <DebugType>full</DebugType> + <PlatformTarget>AnyCPU</PlatformTarget> + <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression> + <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile> + <ErrorReport>prompt</ErrorReport> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Sandcastle|AnyCPU' "> + <DebugSymbols>true</DebugSymbols> + <OutputPath>bin\Sandcastle\</OutputPath> + <DefineConstants>DEBUG;TRACE</DefineConstants> + <DebugType>full</DebugType> + <PlatformTarget>AnyCPU</PlatformTarget> + <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression> + <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile> + <ErrorReport>prompt</ErrorReport> + </PropertyGroup> + <ItemGroup> + <Reference Include="System" /> + <Reference Include="System.configuration" /> + <Reference Include="System.Data" /> + <Reference Include="System.Xml" /> + </ItemGroup> + <ItemGroup> + <Compile Include="AspNetSyntax.cs" /> + <Compile Include="CPlusPlusDeclarationSyntax.cs" /> + <Compile Include="CSharpDeclarationSyntax.cs" /> + <Compile Include="JScriptDeclarationSyntax.cs" /> + <Compile Include="JSharpDeclarationSyntax.cs" /> + <Compile Include="Properties\AssemblyInfo.cs" /> + <Compile Include="ScriptSharpDeclarationSyntax.cs" /> + <Compile Include="SyntaxGenerators.cs" /> + <Compile Include="VisualBasicDeclarationSyntax.cs" /> + <Compile Include="VisualBasicUsageSyntax.cs" /> + <Compile Include="XamlUsageSyntax.cs" /> + </ItemGroup> + <ItemGroup> + <ProjectReference Include="..\BuildComponents\BuildComponents.csproj"> + <Project>{30773718-BC7C-4FCC-A9C2-7EE61DF4EC41}</Project> + <Name>BuildComponents</Name> + </ProjectReference> + </ItemGroup> + <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" /> + <!-- Copy the output assemblies to a common binaries directory (ProductionTools). --> + <Target Name="AfterBuild"> + <CreateItem Include="$(OutputPath)\$(AssemblyName).*"> + <Output TaskParameter="Include" ItemName="ProductionFiles" /> + </CreateItem> + <Copy SourceFiles="@(ProductionFiles)" DestinationFolder="..\..\..\ProductionTools" /> + </Target> +</Project>
\ No newline at end of file diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/SyntaxComponents.csproj.vspscc b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/SyntaxComponents.csproj.vspscc new file mode 100644 index 0000000..b6d3289 --- /dev/null +++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/SyntaxComponents.csproj.vspscc @@ -0,0 +1,10 @@ +"" +{ +"FILE_VERSION" = "9237" +"ENLISTMENT_CHOICE" = "NEVER" +"PROJECT_FILE_RELATIVE_PATH" = "" +"NUMBER_OF_EXCLUDED_FILES" = "0" +"ORIGINAL_PROJECT_FILE_PATH" = "" +"NUMBER_OF_NESTED_PROJECTS" = "0" +"SOURCE_CONTROL_SETTINGS_PROVIDER" = "PROVIDER" +} diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/SyntaxGenerators.cs b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/SyntaxGenerators.cs new file mode 100644 index 0000000..dca7514 --- /dev/null +++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/SyntaxGenerators.cs @@ -0,0 +1,426 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// +using System; +using System.Collections.Generic; +using System.Xml.XPath; + +namespace Microsoft.Ddue.Tools { + + public abstract class SyntaxGeneratorTemplate : SyntaxGenerator { + + protected SyntaxGeneratorTemplate (XPathNavigator configuration) : base(configuration) { + + string nameValue = configuration.GetAttribute("name", String.Empty); + language = nameValue; + + } + + // A maximum width setting + + protected static int maxPosition = 60; + + // The language itentifier + + + protected string language; + + public virtual string Language { + get { + return (language); + } + } + + // Where data is stored + + // api data + protected static XPathExpression apiNameExpression = XPathExpression.Compile("string(apidata/@name)"); + protected static XPathExpression apiGroupExpression = XPathExpression.Compile("string(apidata/@group)"); + protected static XPathExpression apiSubgroupExpression = XPathExpression.Compile("string(apidata/@subgroup)"); + protected static XPathExpression apiSubsubgroupExpression = XPathExpression.Compile("string(apidata/@subsubgroup)"); + + // support testing + protected static XPathExpression apiIsUnsafeExpression = XPathExpression.Compile("boolean(parameters/parameter//pointerTo or returns//pointerTo)"); + protected static XPathExpression apiIsGenericExpression = XPathExpression.Compile("boolean(templates/template)"); + protected static XPathExpression apiIsExtensionMethod = XPathExpression.Compile("boolean(attributes/attribute/type[@api='T:System.Runtime.CompilerServices.ExtensionAttribute'])"); + + // visibility attribute + protected static XPathExpression apiVisibilityExpression = XPathExpression.Compile("string((typedata|memberdata)/@visibility)"); + protected static XPathExpression apiIsFamilyMemberExpression = XPathExpression.Compile("boolean(contains(memberdata/@visibility,'family'))"); + + // type data + protected static XPathExpression apiVisibilityOfTypeExpression = XPathExpression.Compile("string(typedata/@visibility)"); + protected static XPathExpression apiIsAbstractTypeExpression = XPathExpression.Compile("boolean(typedata[@abstract='true'])"); + protected static XPathExpression apiIsSealedTypeExpression = XPathExpression.Compile("boolean(typedata[@sealed='true'])"); + protected static XPathExpression apiIsSerializableTypeExpression = XPathExpression.Compile("boolean(typedata[@serializable='true'])"); + + // class data + protected static XPathExpression apiBaseClassExpression = XPathExpression.Compile("family/ancestors/*[1]"); + protected static XPathExpression apiAncestorsExpression = XPathExpression.Compile("family/ancestors/*"); + + // enumeration data + + // various subheadings + protected static XPathExpression apiAttributesExpression = XPathExpression.Compile("attributes/attribute"); + protected static XPathExpression apiTemplatesExpression = XPathExpression.Compile("templates/template"); + protected static XPathExpression apiImplementedInterfacesExpression = XPathExpression.Compile("implements/type"); + protected static XPathExpression apiParametersExpression = XPathExpression.Compile("parameters/parameter"); + protected static XPathExpression apiReturnTypeExpression = XPathExpression.Compile("returns/*[1]"); + + // member data + protected static XPathExpression apiVisibilityOfMemberExpression = XPathExpression.Compile("string(memberdata/@visibility)"); + protected static XPathExpression apiIsStaticExpression = XPathExpression.Compile("boolean(memberdata[@static='true'])"); + protected static XPathExpression apiIsSpecialExpression = XPathExpression.Compile("boolean(memberdata[@special='true'])"); + protected static XPathExpression apiIsDefaultMemberExpression = XPathExpression.Compile("boolean(memberdata[@default='true'])"); + + // field data + protected static XPathExpression apiIsLiteralFieldExpression = XPathExpression.Compile("boolean(fielddata[@literal='true'])"); + protected static XPathExpression apiIsInitOnlyFieldExpression = XPathExpression.Compile("boolean(fielddata[@initonly='true'])"); + protected static XPathExpression apiIsVolatileFieldExpression = XPathExpression.Compile("boolean(fielddata[@volatile='true'])"); + protected static XPathExpression apiIsSerializedFieldExpression = XPathExpression.Compile("boolean(fielddata[@serialized='true'])"); + + // procedure data + protected static XPathExpression apiIsAbstractProcedureExpression = XPathExpression.Compile("boolean(proceduredata[@abstract='true'])"); + protected static XPathExpression apiIsVirtualExpression = XPathExpression.Compile("boolean(proceduredata[@virtual='true'])"); + protected static XPathExpression apiIsFinalExpression = XPathExpression.Compile("boolean(proceduredata[@final='true'])"); + protected static XPathExpression apiOverridesMemberExpression = XPathExpression.Compile("string(proceduredata/@overrides/member)"); + protected static XPathExpression apiIsExplicitImplementationExpression = XPathExpression.Compile("boolean(memberdata/@visibility='private' and proceduredata/@virtual='true' and boolean(implements/member))"); + protected static XPathExpression apiImplementedMembersExpression = XPathExpression.Compile("implements/member"); + protected static XPathExpression apiIsOverrideExpression = XPathExpression.Compile("boolean(overrides/member)"); + + // property data + protected static XPathExpression apiIsReadPropertyExpression = XPathExpression.Compile("boolean(propertydata/@get='true')"); + protected static XPathExpression apiIsWritePropertyExpression = XPathExpression.Compile("boolean(propertydata/@set='true')"); + protected static XPathExpression apiGetVisibilityExpression = XPathExpression.Compile("string(propertydata/@get-visibility)"); + protected static XPathExpression apiSetVisibilityExpression = XPathExpression.Compile("string(propertydata/@set-visibility)"); + + // event data + protected static XPathExpression apiHandlerOfEventExpression = XPathExpression.Compile("eventhandler/*[1]"); + + // parameter data + //protected static XPathExpression params_expression = XPathExpression.Compile("boolean(@params='true')"); + protected static XPathExpression parameterNameExpression = XPathExpression.Compile("string(@name)"); + protected static XPathExpression parameterTypeExpression = XPathExpression.Compile("*[1]"); + protected static XPathExpression parameterIsInExpression = XPathExpression.Compile("boolean(@in='true')"); + protected static XPathExpression parameterIsOutExpression = XPathExpression.Compile("boolean(@out='true')"); + protected static XPathExpression parameterIsRefExpression = XPathExpression.Compile("boolean(referenceTo)"); + protected static XPathExpression parameterIsParamArrayExpression = XPathExpression.Compile("boolean(@params='true')"); + + // container data + protected static XPathExpression apiContainingTypeExpression = XPathExpression.Compile("containers/type"); + protected static XPathExpression apiContainingTypeNameExpression = XPathExpression.Compile("string(containers/type/apidata/@name)"); + protected static XPathExpression apiContainingTypeSubgroupExpression = XPathExpression.Compile("string(containers/type/apidata/@subgroup)"); + protected static XPathExpression apiContainingAssemblyExpression = XPathExpression.Compile("string(containers/library/@assembly)"); + protected static XPathExpression apiContainingNamespaceIdExpression = XPathExpression.Compile("string(containers/namespace/@api)"); + protected static XPathExpression apiContainingNamespaceNameExpression = XPathExpression.Compile("string(containers/namespace/apidata/@name)"); + // protected static XPathExpression containing_type_templates_expression = XPathExpression.Compile("containers/container[@type]/templates"); + + // referenced type data + protected static XPathExpression typeExpression = XPathExpression.Compile("*[1]"); + protected static XPathExpression typeIdExpression = XPathExpression.Compile("@api"); + protected static XPathExpression typeModifiersExpression = XPathExpression.Compile("optionalModifier|requiredModifier|specialization"); + protected static XPathExpression typeOuterTypeExpression = XPathExpression.Compile("type"); + protected static XPathExpression typeIsObjectExpression = XPathExpression.Compile("boolean(local-name()='type' and @api='T:System.Object')"); + protected static XPathExpression valueExpression = XPathExpression.Compile("*[2]"); + protected static XPathExpression nameExpression = XPathExpression.Compile("string(@name)"); + protected static XPathExpression specializationArgumentsExpression = XPathExpression.Compile("*"); + + // referenced member data + protected static XPathExpression memberDeclaringTypeExpression = XPathExpression.Compile("*[1]"); + + // attribute data + protected static XPathExpression attributeTypeExpression = XPathExpression.Compile("*[1]"); + protected static XPathExpression attributeArgumentsExpression = XPathExpression.Compile("argument"); + protected static XPathExpression attributeAssignmentsExpression = XPathExpression.Compile("assignment"); + protected static XPathExpression assignmentNameExpression = XPathExpression.Compile("string(@name)"); + + // template data + protected static XPathExpression templateNameExpression = XPathExpression.Compile("string(@name)"); + protected static XPathExpression templateIsConstrainedExpression = XPathExpression.Compile("boolean(constrained)"); + protected static XPathExpression templateIsValueTypeExpression = XPathExpression.Compile("boolean(constrained/@value='true')"); + protected static XPathExpression templateIsReferenceTypeExpression = XPathExpression.Compile("boolean(constrained/@ref='true')"); + protected static XPathExpression templateIsConstructableExpression = XPathExpression.Compile("boolean(constrained/@ctor='true')"); + protected static XPathExpression templateConstraintsExpression = XPathExpression.Compile("constrained/type | constrained/implements/type"); + + protected static XPathExpression attachedEventAdderExpression = XPathExpression.Compile("string(attachedeventdata/adder/member/@api)"); + protected static XPathExpression attachedEventRemoverExpression = XPathExpression.Compile("string(attachedeventdata/remover/member/@api)"); + + protected static XPathExpression attachedPropertyGetterExpression = XPathExpression.Compile("string(attachedpropertydata/getter/member/@api)"); + protected static XPathExpression attachedPropertySetterExpression = XPathExpression.Compile("string(attachedpropertydata/setter/member/@api)"); + + // Methods to write syntax for different kinds of APIs + + public override void WriteSyntax (XPathNavigator reflection, SyntaxWriter writer) { + + writer.WriteStartBlock(Language); + + 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; + } + + writer.WriteEndBlock(); + + } + + public virtual void WriteTypeSyntax (XPathNavigator reflection, SyntaxWriter writer) { + + string subgroup = (string) reflection.Evaluate(apiSubgroupExpression); + + switch (subgroup) { + case "class": + WriteClassSyntax(reflection, writer); + break; + case "structure": + WriteStructureSyntax(reflection, writer); + break; + case "interface": + WriteInterfaceSyntax(reflection, writer); + break; + case "delegate": + WriteDelegateSyntax(reflection, writer); + break; + case "enumeration": + WriteEnumerationSyntax(reflection, writer); + break; + } + + } + + public virtual void WriteMemberSyntax (XPathNavigator reflection, SyntaxWriter writer) { + + string subgroup = (string) reflection.Evaluate(apiSubgroupExpression); + string subsubgroup = (string)reflection.Evaluate(apiSubsubgroupExpression); + + switch (subgroup) { + case "constructor": + WriteConstructorSyntax(reflection, writer); + break; + case "method": + WriteMethodSyntax(reflection, writer); + break; + case "property": + if (subsubgroup == "attachedProperty") + WriteAttachedPropertySyntax(reflection, writer); + else + WritePropertySyntax(reflection, writer); + break; + case "event": + if (subsubgroup == "attachedEvent") + WriteAttachedEventSyntax(reflection, writer); + else + WriteEventSyntax(reflection, writer); + break; + case "field": + WriteFieldSyntax(reflection, writer); + break; + } + + } + + public abstract void WriteNamespaceSyntax (XPathNavigator reflection, SyntaxWriter writer); + + public abstract void WriteClassSyntax (XPathNavigator reflection, SyntaxWriter writer); + + public abstract void WriteStructureSyntax (XPathNavigator reflection, SyntaxWriter writer); + + public abstract void WriteInterfaceSyntax (XPathNavigator reflection, SyntaxWriter writer); + + public abstract void WriteDelegateSyntax (XPathNavigator reflection, SyntaxWriter writer); + + public abstract void WriteEnumerationSyntax (XPathNavigator reflection, SyntaxWriter writer); + + public abstract void WriteConstructorSyntax (XPathNavigator reflection, SyntaxWriter writer); + + public virtual void WriteMethodSyntax (XPathNavigator reflection, SyntaxWriter writer) { + bool isSpecialName = (bool)reflection.Evaluate(apiIsSpecialExpression); + string name = (string)reflection.Evaluate(apiNameExpression); + + if (isSpecialName) { + string subsubgroup = (string)reflection.Evaluate(apiSubsubgroupExpression); + if (subsubgroup == "operator") { + if ((name == "Implicit") || (name == "Explicit")) { + WriteCastSyntax(reflection, writer); + } else { + WriteOperatorSyntax(reflection, writer); + } + } + } else { + WriteNormalMethodSyntax(reflection, writer); + } + } + + public abstract void WritePropertySyntax (XPathNavigator reflection, SyntaxWriter writer); + + public abstract void WriteFieldSyntax (XPathNavigator reflection, SyntaxWriter writer); + + public abstract void WriteEventSyntax (XPathNavigator reflection, SyntaxWriter writer); + + public virtual void WriteNormalMethodSyntax (XPathNavigator reflection, SyntaxWriter writer) { } + + public virtual void WriteOperatorSyntax (XPathNavigator reflection, SyntaxWriter writer) { } + + public virtual void WriteCastSyntax (XPathNavigator reflection, SyntaxWriter writer) { } + + public virtual void WriteAttachedPropertySyntax(XPathNavigator reflection, SyntaxWriter writer) + { + string getterId = (string)reflection.Evaluate(attachedPropertyGetterExpression); + string setterId = (string)reflection.Evaluate(attachedPropertySetterExpression); + if (!string.IsNullOrEmpty(getterId)) + { + writer.WriteString("See "); + writer.WriteReferenceLink(getterId); + } + if (!string.IsNullOrEmpty(setterId)) + { + if (!string.IsNullOrEmpty(getterId)) + writer.WriteString(", "); + writer.WriteReferenceLink(setterId); + } + } + + public virtual void WriteAttachedEventSyntax(XPathNavigator reflection, SyntaxWriter writer) + { + string adderId = (string)reflection.Evaluate(attachedEventAdderExpression); + string removerId = (string)reflection.Evaluate(attachedEventRemoverExpression); + if (!(string.IsNullOrEmpty(adderId) && string.IsNullOrEmpty(removerId))) + { + writer.WriteString("See "); + writer.WriteReferenceLink(adderId); + writer.WriteString(", "); + writer.WriteReferenceLink(removerId); + } + } + + protected virtual bool IsUnsupportedUnsafe(XPathNavigator reflection, SyntaxWriter writer) + { + bool isUnsafe = (bool) reflection.Evaluate(apiIsUnsafeExpression); + + if (isUnsafe) { + writer.WriteMessage("UnsupportedUnsafe_" + Language); + } + + return(isUnsafe); + } + + protected virtual bool IsUnsupportedGeneric (XPathNavigator reflection, SyntaxWriter writer) { + + bool isGeneric = (bool) reflection.Evaluate(apiIsGenericExpression); + + if (isGeneric) { + writer.WriteMessage("UnsupportedGeneric_" + Language); + } + + return(isGeneric); + + } + + protected virtual bool IsUnsupportedExplicit (XPathNavigator reflection, SyntaxWriter writer) { + + bool isExplicit = (bool) reflection.Evaluate(apiIsExplicitImplementationExpression); + + if (isExplicit) { + writer.WriteMessage("UnsupportedExplicit_" + Language); + } + + return(isExplicit); + + } + + } + + public abstract class DeclarationSyntaxGeneratorTemplate : SyntaxGeneratorTemplate { + + protected DeclarationSyntaxGeneratorTemplate (XPathNavigator configuration) : base(configuration) { } + + // Methods to implement + + protected abstract void WriteVisibility (XPathNavigator reflection, SyntaxWriter writer); + + // Utility methods + + protected static string[] SeperateTypes (string typelist) { + List<string> types = new List<string>(); + + int start = 0; + int specializationCount = 0; + for (int index=0; index<typelist.Length; index++) { + switch (typelist[index]) { + case '{': + specializationCount++; + break; + case '}': + specializationCount--; + break; + case ',': + if (specializationCount == 0) { + types.Add( "T:" + typelist.Substring(start, index-start) ); + start = index + 1; + } + break; + } + } + types.Add( "T:" + typelist.Substring(start) ); + return(types.ToArray()); + } + + protected static string GetTemplateParameterName (string reference, XPathNavigator reflection) { + + string group = (string) reflection.Evaluate(apiGroupExpression); + + XPathNavigator template = null; + if (reference.StartsWith("T:`")) { + if (reference[3]=='`') { + + // a method template parameter + + int position = Convert.ToInt32( reference.Substring(4) ) + 1; + + if (group == "member") { + // we are in a method, so presumably it is one of that method's template parameters + template = reflection.SelectSingleNode( String.Format("templates/template[{0}]", position) ); + } + + } else { + + // a type template parameter + + int position = Convert.ToInt32( reference.Substring(3) ) + 1; + + if (group == "type") { + // we are in a type, so look there for the parameter + template = reflection.SelectSingleNode( String.Format("templates/template[{0}]", position) ); + } + + if (template == null) { + // either we weren't in a type, or it didn't have the template + // so now look at the templates of the containing type + template = reflection.SelectSingleNode( String.Format("containers/container[@type]/templates/template[{0}]", position) ); + } + + + + } + } + + if (template != null) { + return(template.GetAttribute("name", String.Empty)); + } else { + Console.WriteLine("UNRESOLVED TEMPLATE PARAMETER NAME"); + return("T"); + } + + } + + + } + +} diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/VisualBasicDeclarationSyntax.cs b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/VisualBasicDeclarationSyntax.cs new file mode 100644 index 0000000..34ece60 --- /dev/null +++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/VisualBasicDeclarationSyntax.cs @@ -0,0 +1,903 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// +using System; +using System.Collections.Generic; +using System.Xml.XPath; + +namespace Microsoft.Ddue.Tools { + + public class VisualBasicDeclarationSyntaxGenerator : SyntaxGeneratorTemplate { + + public VisualBasicDeclarationSyntaxGenerator (XPathNavigator configuration) : base(configuration) { + if (String.IsNullOrEmpty(language)) language = "VisualBasic"; + } + + // namespace: done + public override void WriteNamespaceSyntax (XPathNavigator reflection, SyntaxWriter writer) { + + string name = (string) reflection.Evaluate(apiNameExpression); + + writer.WriteKeyword("Namespace"); + writer.WriteString(" "); + writer.WriteIdentifier(name); + } + + // 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); + } + + // structure: add base type + 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("Structure"); + writer.WriteString(" "); + writer.WriteIdentifier(name); + WriteGenericTemplates(reflection, writer); + WriteImplementedInterfaces(reflection, writer); + } + + // 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); + WriteImplementedInterfaces(reflection, writer); + } + + // delegate: done + 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); + WriteParameters(reflection, writer); + if (type != null) { + writer.WriteString(" "); + writer.WriteKeyword("As"); + writer.WriteString(" "); + WriteTypeReference(type, writer); + } + + } + + // enumeration: done + 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); + WriteVisibility(reflection, writer); + writer.WriteString(" "); + writer.WriteKeyword("Enumeration"); + writer.WriteString(" "); + writer.WriteIdentifier(name); + } + + // constructor: done + 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); + + } + + + public override void WriteNormalMethodSyntax (XPathNavigator reflection, SyntaxWriter writer) { + + 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); + } + } + + } + + public override void WriteOperatorSyntax (XPathNavigator reflection, SyntaxWriter writer) { + + string name = (string) reflection.Evaluate(apiNameExpression); + XPathNavigator type = reflection.SelectSingleNode(apiReturnTypeExpression); + + 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 = "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; + // 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); + } + + public override void WriteCastSyntax (XPathNavigator reflection, SyntaxWriter writer) { + WriteOperatorSyntax(reflection, writer); + } + + public override void WritePropertySyntax (XPathNavigator reflection, SyntaxWriter writer) { + + if (IsUnsupportedUnsafe(reflection, writer)) return; + + string name = (string) reflection.Evaluate(apiNameExpression); + bool getter = (bool) reflection.Evaluate(apiIsReadPropertyExpression); + bool setter = (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 (getter && !setter) { + writer.WriteKeyword("ReadOnly"); + writer.WriteString(" "); + } else if (setter && !getter) { + 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); + } + } + } + + + public override void WriteEventSyntax (XPathNavigator reflection, SyntaxWriter writer) { + 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 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(" "); + } + } + } + } + + } + + 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); + + } + + // Visibility + + private void WriteVisibility (XPathNavigator reflection, SyntaxWriter writer) { + + string visibility = (string) reflection.Evaluate(apiVisibilityExpression); + + 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; + } + + } + + // Attributes + + private void WriteAttribute (string reference, SyntaxWriter writer) { + WriteAttribute(reference, true, writer); + } + + private void WriteAttribute (string reference, bool newLine, SyntaxWriter writer) { + writer.WriteString("<"); + writer.WriteReferenceLink(reference); + writer.WriteString(">"); + if (newLine) { + writer.WriteString(" _"); + writer.WriteLine(); + } + } + + private void WriteAttributes (XPathNavigator reflection, SyntaxWriter writer) { + + XPathNodeIterator attributes = (XPathNodeIterator) reflection.Evaluate(apiAttributesExpression); + + foreach (XPathNavigator attribute in attributes) { + + XPathNavigator type = attribute.SelectSingleNode(attributeTypeExpression); + XPathNodeIterator arguments = (XPathNodeIterator) attribute.Select(attributeArgumentsExpression); + XPathNodeIterator assignments = (XPathNodeIterator) attribute.Select(attributeAssignmentsExpression); + + writer.WriteString("<"); + WriteTypeReference(type, writer); + + 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.WriteString(" _"); + 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.WriteString(" _"); + writer.WriteLine(); + writer.WriteString("\t"); + } + } + writer.WriteString((string) assignment.Evaluate(assignmentNameExpression)); + writer.WriteString(" := "); + WriteValue(assignment, writer); + + } + writer.WriteString(")"); + } + + writer.WriteString("> "); + writer.WriteString("_"); + writer.WriteLine(); + } + + } + + 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("Nothing"); + break; + case "typeValue": + writer.WriteKeyword("GetType"); + 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(" "); + writer.WriteKeyword("Or"); + 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("\"C"); + break; + } + break; + } + } + + + // Interfaces + + private void WriteBaseClass (XPathNavigator reflection, SyntaxWriter writer) { + + XPathNavigator baseClass = reflection.SelectSingleNode(apiBaseClassExpression); + + if ((baseClass != null) && !((bool) baseClass.Evaluate(typeIsObjectExpression))) { + writer.WriteString(" _"); + writer.WriteLine(); + writer.WriteString("\t"); + writer.WriteKeyword("Inherits"); + writer.WriteString(" "); + WriteTypeReference(baseClass, writer); + } + + } + + private void WriteImplementedInterfaces (XPathNavigator reflection, SyntaxWriter writer) { + + XPathNodeIterator implements = reflection.Select(apiImplementedInterfacesExpression); + + if (implements.Count == 0) return; + + writer.WriteString(" _"); + writer.WriteLine(); + writer.WriteString("\t"); + writer.WriteKeyword("Implements"); + writer.WriteString(" "); + while (implements.MoveNext()) { + XPathNavigator implement = implements.Current; + if (implements.CurrentPosition > 1) { + writer.WriteString(", "); + if (writer.Position > maxPosition) { + writer.WriteString(" _"); + writer.WriteLine(); + writer.WriteString("\t"); + } + } + WriteTypeReference(implement, writer); + } + + } + + // Generics + + private void WriteGenericTemplates (XPathNavigator reflection, SyntaxWriter writer) { + + XPathNodeIterator templates = reflection.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(", "); + string name = template.GetAttribute("name", String.Empty); + writer.WriteString(name); + + // write out constraints + + bool constrained = (bool) template.Evaluate(templateIsConstrainedExpression); + if (constrained) { + writer.WriteString(" "); + writer.WriteKeyword("As"); + writer.WriteString(" "); + + bool value = (bool) template.Evaluate(templateIsValueTypeExpression); + bool reference = (bool) template.Evaluate(templateIsReferenceTypeExpression); + bool constructor = (bool) template.Evaluate(templateIsConstructableExpression); + XPathNodeIterator constraints = template.Select(templateConstraintsExpression); + + int count = constraints.Count; + if (value) count++; + if (reference) count++; + if (constructor) count++; + + if (count > 1) writer.WriteString("{"); + + int index = 0; + if (value) { + if (index > 0) writer.WriteString(", "); + writer.WriteKeyword("Structure"); + index++; + } + if (reference) { + if (index > 0) writer.WriteString(", "); + writer.WriteKeyword("Class"); + index++; + } + if (constructor) { + if (index > 0) writer.WriteString(", "); + writer.WriteKeyword("New"); + index++; + } + foreach (XPathNavigator constraint in constraints) { + if (index > 0) writer.WriteString(", "); + WriteTypeReference(constraint, writer); + index++; + } + + if (count > 1) writer.WriteString("}"); + + } + + } + writer.WriteString(")"); + } + + // Parameters + + private void WriteParameters (XPathNavigator reflection, SyntaxWriter writer) { + + XPathNodeIterator parameters = reflection.Select(apiParametersExpression); + if (parameters.Count == 0) return; + + writer.WriteString(" ( _"); + writer.WriteLine(); + while (parameters.MoveNext()) { + XPathNavigator parameter = parameters.Current; + XPathNavigator type = parameter.SelectSingleNode(parameterTypeExpression); + string name = (string) parameter.Evaluate(parameterNameExpression); + bool isIn = (bool) parameter.Evaluate(parameterIsInExpression); + bool isOut = (bool) parameter.Evaluate(parameterIsOutExpression); + bool isParamArray = (bool) parameter.Evaluate(parameterIsParamArrayExpression); + bool isByRef = (bool) parameter.Evaluate(parameterIsRefExpression); + + writer.WriteString("\t"); + if (isOut) { + WriteAttribute("T:System.Runtime.InteropServices.OutAttribute", false, writer); + writer.WriteString(" "); + } + if (isParamArray) { + writer.WriteKeyword("ParamArray"); + writer.WriteString(" "); + } + if (isByRef) { + writer.WriteKeyword("ByRef"); + writer.WriteString(" "); + } + writer.WriteParameter(name); + writer.WriteString(" "); + writer.WriteKeyword("As"); + writer.WriteString(" "); + WriteTypeReference(type, writer); + if (parameters.CurrentPosition < parameters.Count) writer.WriteString(","); + writer.WriteString(" _"); + writer.WriteLine(); + } + writer.WriteString(")"); + + } + + // 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); + 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("("); + 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; + } + } + + private void WriteNormalTypeReference (string reference, SyntaxWriter writer) { + switch (reference) { + case "T:System.Int16": + writer.WriteReferenceLink(reference, "Short"); + break; + case "T:System.Int32": + writer.WriteReferenceLink(reference, "Integer"); + break; + case "T:System.Int64": + writer.WriteReferenceLink(reference, "Long"); + break; + case "T:System.UInt16": + writer.WriteReferenceLink(reference, "UShort"); + break; + case "T:System.UInt32": + writer.WriteReferenceLink(reference, "UInteger"); + break; + case "T:System.UInt64": + writer.WriteReferenceLink(reference, "ULong"); + break; + default: + writer.WriteReferenceLink(reference); + break; + } + } + + private void WriteMemberReference (XPathNavigator member, SyntaxWriter writer) { + string api = member.GetAttribute("api", String.Empty); + writer.WriteReferenceLink(api); + } + + } + +}
\ No newline at end of file diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/VisualBasicUsageSyntax.cs b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/VisualBasicUsageSyntax.cs new file mode 100644 index 0000000..ed96a10 --- /dev/null +++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/VisualBasicUsageSyntax.cs @@ -0,0 +1,736 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// +using System; +using System.Collections.Generic; +using System.Xml.XPath; + +namespace Microsoft.Ddue.Tools { + + public class VisualBasicUsageSyntaxGenerator : SyntaxGeneratorTemplate { + + public VisualBasicUsageSyntaxGenerator (XPathNavigator configuration) : base(configuration) { + if (String.IsNullOrEmpty(language)) language = "VisualBasicUsage"; + } + + public override void WriteNamespaceSyntax (XPathNavigator reflection, SyntaxWriter writer) { + + string name = (string)reflection.Evaluate(apiNameExpression); + + writer.WriteKeyword("Imports"); + writer.WriteString(" "); + writer.WriteIdentifier(name); + } + + private void TypeDeclaration (XPathNavigator reflection, SyntaxWriter writer) { + 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); + } + + private void WriteGenericTemplates (XPathNavigator type, SyntaxWriter writer) { + 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(", "); + string name = template.GetAttribute("name", String.Empty); + writer.WriteString(name); + } + 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.ContainsKey(typeName)) { + writer.WriteString("["); + WriteTypeReference(type, writer); + writer.WriteString("]"); + } else { + WriteTypeReference(type, writer); + } + + writer.WriteLine(); + } + + public override void WriteClassSyntax (XPathNavigator reflection, SyntaxWriter writer) { + + bool isAbstract = (bool)reflection.Evaluate(apiIsAbstractTypeExpression); + bool isSealed = (bool)reflection.Evaluate(apiIsSealedTypeExpression); + + if (isAbstract && isSealed) { + writer.WriteMessage("UnsupportedStaticClass_" + Language); + } else { + TypeDeclaration(reflection, writer); + } + + } + + public override void WriteStructureSyntax (XPathNavigator reflection, SyntaxWriter writer) { + TypeDeclaration(reflection, writer); + } + + public override void WriteInterfaceSyntax (XPathNavigator reflection, SyntaxWriter writer) { + TypeDeclaration(reflection, writer); + } + + public override void WriteDelegateSyntax (XPathNavigator reflection, SyntaxWriter writer) { + if (IsUnsupportedUnsafe(reflection, writer)) return; + + string name = (string)reflection.Evaluate(apiNameExpression); + + writer.WriteKeyword("Dim"); + writer.WriteString(" "); + writer.WriteParameter("instance"); + writer.WriteString(" "); + writer.WriteKeyword("As"); + writer.WriteString(" "); + writer.WriteKeyword("New"); + writer.WriteString(" "); + + if (reservedWords.ContainsKey(name)) { + writer.WriteString("["); + writer.WriteIdentifier(name); + writer.WriteString("]"); + } else { + writer.WriteIdentifier(name); + } + + WriteGenericTemplates(reflection, writer); + writer.WriteString("("); + writer.WriteKeyword("AddressOf"); + writer.WriteString(" HandlerMethod)"); + } + + public override void WriteEnumerationSyntax (XPathNavigator reflection, SyntaxWriter writer) { + TypeDeclaration(reflection, writer); + } + + 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"); + + } + + public override void WriteConstructorSyntax (XPathNavigator reflection, SyntaxWriter writer) { + if (IsUnsupportedUnsafe(reflection, writer)) return; + + XPathNavigator declaringType = reflection.SelectSingleNode(apiContainingTypeExpression); + + // if static, no usage + + WriteParameterDeclarations(reflection, writer); + writer.WriteLine(); + writer.WriteKeyword("Dim"); + writer.WriteString(" "); + writer.WriteParameter("instance"); + writer.WriteString(" "); + writer.WriteKeyword("As New"); + writer.WriteString(" "); + + string typeName = (string)declaringType.Evaluate(apiNameExpression); + + if (reservedWords.ContainsKey(typeName)) { + writer.WriteString("["); + WriteTypeReference(declaringType, writer); + writer.WriteString("]"); + } else { + WriteTypeReference(declaringType, writer); + } + + WriteMethodParameters(reflection, writer); + } + + public override void WriteMethodSyntax (XPathNavigator reflection, SyntaxWriter writer) { + if (IsUnsupportedUnsafe(reflection, writer)) return; + base.WriteMethodSyntax(reflection, writer); + } + + public override void WriteNormalMethodSyntax (XPathNavigator reflection, SyntaxWriter writer) { + bool isExtension = (bool)reflection.Evaluate(apiIsExtensionMethod); + if (isExtension) { + WriteExtensionMethodSyntax(reflection, writer); + } else { + + //string name = (string)reflection.Evaluate(apiNameExpression); + XPathNavigator returnType = reflection.SelectSingleNode(apiReturnTypeExpression); + XPathNavigator declaringType = reflection.SelectSingleNode(apiContainingTypeExpression); + //bool isExplicit = (bool)reflection.Evaluate(apiIsExplicitImplementationExpression); + bool isStatic = (bool)reflection.Evaluate(apiIsStaticExpression); + bool isFamily = (bool)reflection.Evaluate(apiIsFamilyMemberExpression); + + if (!(isStatic || isFamily)) ParameterDeclaration("instance", declaringType, writer); + WriteParameterDeclarations(reflection, writer); + if (returnType != null) ParameterDeclaration("returnValue", returnType, writer); + writer.WriteLine(); + + if (returnType != null) { + writer.WriteParameter("returnValue"); + writer.WriteString(" = "); + } + + WriteMemberName(reflection, writer); + WriteMethodParameters(reflection, writer); + + } + } + + // what about generic methods? + + private void WriteMemberName (XPathNavigator reflection, SyntaxWriter writer) { + string name = (string)reflection.Evaluate(apiNameExpression); + bool isExplicit = (bool)reflection.Evaluate(apiIsExplicitImplementationExpression); + bool isStatic = (bool)reflection.Evaluate(apiIsStaticExpression); + bool isFamily = (bool)reflection.Evaluate(apiIsFamilyMemberExpression); + bool isDefault = (bool)reflection.Evaluate(apiIsDefaultMemberExpression); + XPathNavigator declaringType = reflection.SelectSingleNode(apiContainingTypeExpression); + if (isExplicit) { + XPathNavigator member = reflection.SelectSingleNode(apiImplementedMembersExpression); + XPathNavigator contract = member.SelectSingleNode(memberDeclaringTypeExpression); + writer.WriteKeyword("CType"); + writer.WriteString("("); + writer.WriteParameter("instance"); + writer.WriteString(", "); + WriteTypeReference(contract, writer); + writer.WriteString(")."); + WriteMemberReference(member, writer); + } else { + if (isStatic) { + WriteTypeReference(declaringType, writer); + } else { + if (isFamily) { + writer.WriteKeyword("Me"); + } else { + writer.WriteString("instance"); + } + } + if (!isDefault) { + writer.WriteString("."); + writer.WriteIdentifier(name); + } + } + } + + private void WriteExtensionMethodSyntax (XPathNavigator reflection, SyntaxWriter writer) { + + string name = (string)reflection.Evaluate(apiNameExpression); + XPathNavigator returnType = reflection.SelectSingleNode(apiReturnTypeExpression); + XPathNodeIterator parameters = reflection.Select(apiParametersExpression); + + // extract the first parameter as the extension type + parameters.MoveNext(); + XPathNavigator extendedType = parameters.Current.SelectSingleNode(parameterTypeExpression); + string extendedTypeName = (string) parameters.Current.Evaluate(parameterNameExpression); + + // write the declarations + ParameterDeclaration(extendedTypeName, extendedType, writer); + WriteParameterDeclarations(parameters.Clone(), writer); + if (returnType != null) ParameterDeclaration("returnValue", returnType, writer); + writer.WriteLine(); + + // write the method invocation + if (returnType != null) { + writer.WriteParameter("returnValue"); + writer.WriteString(" = "); + } + writer.WriteParameter(extendedTypeName); + writer.WriteString("."); + writer.WriteIdentifier(name); + writer.WriteString("("); + WriteParameters(parameters.Clone(), reflection, writer); + writer.WriteString(")"); + + } + + 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; + int type; + 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; + // 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; + } + } + + } + + public override void WriteCastSyntax (XPathNavigator reflection, SyntaxWriter 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(")"); + } + + public override void WritePropertySyntax (XPathNavigator reflection, SyntaxWriter writer) { + + if (IsUnsupportedUnsafe(reflection, writer)) return; + + bool isStatic = (bool)reflection.Evaluate(apiIsStaticExpression); + bool isFamily = (bool)reflection.Evaluate(apiIsFamilyMemberExpression); + XPathNavigator declaringType = reflection.SelectSingleNode(apiContainingTypeExpression); + XPathNavigator propertyType = reflection.SelectSingleNode(apiReturnTypeExpression); + bool getter = (bool)reflection.Evaluate(apiIsReadPropertyExpression); + bool setter = (bool)reflection.Evaluate(apiIsWritePropertyExpression); + + if (!(isStatic || isFamily)) ParameterDeclaration("instance", declaringType, writer); + WriteParameterDeclarations(reflection, writer); + ParameterDeclaration("value", propertyType, writer); + + // get value + if (getter) { + writer.WriteLine(); + writer.WriteParameter("value"); + writer.WriteString(" = "); + WriteMemberName(reflection, writer); + WritePropertyParameters(reflection, writer); + writer.WriteLine(); + } + + // set value + if (setter) { + writer.WriteLine(); + WriteMemberName(reflection, writer); + WritePropertyParameters(reflection, writer); + writer.WriteString(" = "); + writer.WriteParameter("value"); + } + + } + + public override void WriteEventSyntax (XPathNavigator reflection, SyntaxWriter writer) { + 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(); + } + + private void WriteParameterDeclarations (XPathNavigator reflection, SyntaxWriter writer) { + XPathNodeIterator parameters = reflection.Select(apiParametersExpression); + if (parameters.Count == 0) return; + WriteParameterDeclarations(parameters, writer); + } + + private void WriteParameterDeclarations (XPathNodeIterator parameters, SyntaxWriter writer) { + while (parameters.MoveNext()) { + XPathNavigator parameter = parameters.Current; + XPathNavigator type = parameter.SelectSingleNode(parameterTypeExpression); + string name = (string)parameter.Evaluate(parameterNameExpression); + ParameterDeclaration(name, type, writer); + } + } + + private void WriteMethodParameters (XPathNavigator reflection, SyntaxWriter writer) { + + XPathNodeIterator parameters = reflection.Select(apiParametersExpression); + + writer.WriteString("("); + if (parameters.Count > 0) { + WriteParameters(parameters, reflection, writer); + } + writer.WriteString(")"); + + } + + private void WritePropertyParameters (XPathNavigator reflection, SyntaxWriter writer) { + + XPathNodeIterator parameters = reflection.Select(apiParametersExpression); + + if (parameters.Count == 0) return; + + writer.WriteString("("); + WriteParameters(parameters, reflection, writer); + writer.WriteString(")"); + + } + + + private void WriteParameters(XPathNodeIterator parameters, XPathNavigator reflection, SyntaxWriter writer) + { + while (parameters.MoveNext()) + { + XPathNavigator parameter = parameters.Current; + string name = (string)parameter.Evaluate(parameterNameExpression); + writer.WriteParameter(name); + + if (parameters.CurrentPosition < parameters.Count) + { + writer.WriteString(", "); + if (writer.Position > maxPosition) + { + writer.WriteString("_"); + writer.WriteLine(); + writer.WriteString("\t"); + } + } + } + } + + 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("("); + 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; + } + } + + private void WriteNormalTypeReference (string reference, SyntaxWriter writer) { + switch (reference) { + case "T:System.Int16": + writer.WriteReferenceLink(reference, "Short"); + break; + case "T:System.Int32": + writer.WriteReferenceLink(reference, "Integer"); + break; + case "T:System.Int64": + writer.WriteReferenceLink(reference, "Long"); + break; + case "T:System.UInt16": + writer.WriteReferenceLink(reference, "UShort"); + break; + case "T:System.UInt32": + writer.WriteReferenceLink(reference, "UInteger"); + break; + case "T:System.UInt64": + writer.WriteReferenceLink(reference, "ULong"); + break; + default: + writer.WriteReferenceLink(reference); + break; + } + } + + private void WriteMemberReference (XPathNavigator member, SyntaxWriter writer) { + string api = member.GetAttribute("api", String.Empty); + writer.WriteReferenceLink(api); + } + + private static Dictionary<string, object> reservedWords = new Dictionary<string, object>(); + + static VisualBasicUsageSyntaxGenerator () { + reservedWords.Add("Alias", null); + reservedWords.Add("Assembly", null); + reservedWords.Add("Class", null); + reservedWords.Add("Delegate", null); + reservedWords.Add("Function", null); + reservedWords.Add("Handles", null); + reservedWords.Add("Interface", null); + reservedWords.Add("Loop", null); + reservedWords.Add("Module", null); + reservedWords.Add("New", null); + reservedWords.Add("Next", null); + reservedWords.Add("Nothing", null); + reservedWords.Add("Operator", null); + reservedWords.Add("Option", null); + reservedWords.Add("Property", null); + reservedWords.Add("Structure", null); + } + + } + +}
\ No newline at end of file diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/XamlUsageSyntax.cs b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/XamlUsageSyntax.cs new file mode 100644 index 0000000..99081c5 --- /dev/null +++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/XamlUsageSyntax.cs @@ -0,0 +1,950 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// +using System; +using System.Collections.Generic; +using System.Xml.XPath; +using System.Configuration; +using System.IO; + +namespace Microsoft.Ddue.Tools +{ + public class XamlUsageSyntaxGenerator : SyntaxGeneratorTemplate + { + + public XamlUsageSyntaxGenerator(XPathNavigator configuration) + : base(configuration) + { + LoadConfigNode(configuration); + if (String.IsNullOrEmpty(language)) language = "XAML"; + } + + 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(); + } + + 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(); + } + } + } + } + + // list of classes whose subclasses do NOT get XAML syntax + protected List<string> excludedAncestorList = new List<string>(); + + // list of assemblies whose members get XAML syntax + // the nested Dictionary is a list of assembly's namespaces that have one or more xmlns uris for xaml + private Dictionary<string, Dictionary<string, List<string>>> xamlAssemblies = new Dictionary<string, Dictionary<string, List<string>>>(); + + + private void LoadConfigNode(XPathNavigator configuration) + { + // get the filter files + XPathNodeIterator filterNodes = configuration.Select("filter"); + if (filterNodes.Count == 0) + { + LoadConfiguration(configuration); + return; + } + + foreach (XPathNavigator filterNode in filterNodes) + { + string filterFiles = filterNode.GetAttribute("files", String.Empty); + if ((filterFiles == null) || (filterFiles.Length == 0)) + throw new ConfigurationErrorsException("The XamlUsageSyntaxGenerator filter/@files attribute must specify a path."); + ParseDocuments(filterFiles); + } + } + + private void LoadConfiguration(XPathNavigator configuration) + { + // get the list of excluded ancestor classes + foreach (XPathNavigator excludedClass in configuration.Select("xamlExcludedAncestors/class")) + { + string apiId = excludedClass.GetAttribute("api", string.Empty); + if (apiId.Length > 0 && !excludedAncestorList.Contains(apiId)) + excludedAncestorList.Add(apiId); + } + + // get the list of XAML assemblies; members in other assemblies get no xaml syntax, just 'not applicable' boilerplate + foreach (XPathNavigator xamlAssembly in configuration.Select("xamlAssemblies/assembly")) + { + string assemblyName = xamlAssembly.GetAttribute("name", string.Empty); + if (string.IsNullOrEmpty(assemblyName)) + continue; // should emit warning message + + Dictionary<string, List<string>> clrNamespaces; + if (!xamlAssemblies.TryGetValue(assemblyName.ToLower(), out clrNamespaces)) + { + clrNamespaces = new Dictionary<string, List<string>>(); + xamlAssemblies.Add(assemblyName.ToLower(), clrNamespaces); + } + + foreach (XPathNavigator xmlnsNode in xamlAssembly.Select("xmlns[@uri][clrNamespace]")) + { + string xmlnsUri = xmlnsNode.GetAttribute("uri", string.Empty); + if (string.IsNullOrEmpty(xmlnsUri)) + continue; // should emit warning message + + foreach (XPathNavigator clrNamespaceNode in xmlnsNode.Select("clrNamespace[@name]")) + { + string namespaceName = clrNamespaceNode.GetAttribute("name", string.Empty); + if (string.IsNullOrEmpty(namespaceName)) + continue; // should emit warning message + + List<string> xmlnsUriList; + if (!clrNamespaces.TryGetValue(namespaceName, out xmlnsUriList)) + { + xmlnsUriList = new List<string>(); + clrNamespaces.Add(namespaceName, xmlnsUriList); + } + if (!xmlnsUriList.Contains(xmlnsUri)) + xmlnsUriList.Add(xmlnsUri); + } + } + } + } + + public void ParseDocuments(string wildcardPath) + { + string filterFiles = Environment.ExpandEnvironmentVariables(wildcardPath); + if ((filterFiles == null) || (filterFiles.Length == 0)) + throw new ConfigurationErrorsException("The XamlUsageSyntaxGenerator filter path is an empty string."); + + //WriteMessage(MessageLevel.Info, String.Format("XamlUsageSyntaxGenerator: Searching for files that match '{0}'.", filterFiles)); + string directoryPart = Path.GetDirectoryName(filterFiles); + if (String.IsNullOrEmpty(directoryPart)) + directoryPart = Environment.CurrentDirectory; + directoryPart = Path.GetFullPath(directoryPart); + string filePart = Path.GetFileName(filterFiles); + string[] files = Directory.GetFiles(directoryPart, filePart); + foreach (string file in files) + ParseDocument(file); + //WriteMessage(MessageLevel.Info, String.Format("Found {0} files in {1}.", files.Length, filterFiles)); + } + + private void ParseDocument(string file) + { + try + { + XPathDocument document = new XPathDocument(file); + + XPathNavigator xamlSyntaxNode = document.CreateNavigator().SelectSingleNode("/*"); + LoadConfiguration(xamlSyntaxNode); + } + catch (Exception e) + { + throw new ConfigurationErrorsException(string.Format("Exception parsing XamlUsageSyntaxGenerator filter file: {0}. Exception message: {1}", file, e.Message)); + } + } + + public override void WriteNamespaceSyntax(XPathNavigator reflection, SyntaxWriter writer) + { + // empty xaml syntax for namespace topics + } + + private void WriteXamlBoilerplate(XamlBoilerplateID bpID, SyntaxWriter writer) + { + WriteXamlBoilerplate(bpID, null, writer); + } + + private void WriteXamlBoilerplate(XamlBoilerplateID bpID, XPathNavigator typeReflection, SyntaxWriter writer) + { + string xamlBlockId = System.Enum.GetName(typeof(XamlBoilerplateID), bpID); + if (xamlBlockId != null) + { + writer.WriteStartSubBlock(xamlBlockId); + if (typeReflection != null) + WriteTypeReference(typeReflection, writer); + writer.WriteEndSubBlock(); + } + } + + 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 (isAbstract && !isSealed) + { + // Output boilerplate for abstract class + WriteXamlBoilerplate(XamlBoilerplateID.classXamlSyntax_abstract, writer); + } + else if (!HasDefaultConstructor(reflection)) + { + if (HasTypeConverterAttribute(reflection)) + { + WriteXamlBoilerplate(XamlBoilerplateID.classXamlSyntax_noDefaultCtorWithTypeConverter, writer); + } + else + { + WriteXamlBoilerplate(XamlBoilerplateID.classXamlSyntax_noDefaultCtor, writer); + } + } + else if (IsExcludedSubClass(reflection)) + { + WriteXamlBoilerplate(XamlBoilerplateID.classXamlSyntax_excludedSubClass, writer); + } + else + { + // show the default XAML syntax for classes + // Note: skipped the test for TypeConverterAttribute shown in the flowchart because same syntax either way + ObjectElementUsageForClassStruct(reflection, writer); + } + } + + private void ObjectElementUsageForClassStruct(XPathNavigator reflection, SyntaxWriter writer) + { + string typeName = (string)reflection.Evaluate(apiNameExpression); + bool isGeneric = (bool)reflection.Evaluate(apiIsGenericExpression); + string xamlBlockId = System.Enum.GetName(typeof(XamlHeadingID), XamlHeadingID.xamlObjectElementUsageHeading); + + string contentPropertyId = (string)reflection.Evaluate(contentPropertyIdExpression); + if (contentPropertyId == "") + contentPropertyId = (string)reflection.Evaluate(ancestorContentPropertyIdExpression); + + // start the syntax block + writer.WriteStartSubBlock(xamlBlockId); + + writer.WriteString("<"); + if (isGeneric) + { + writer.WriteIdentifier(typeName); + + // for generic types show the type arguments + XPathNodeIterator templates = (XPathNodeIterator)reflection.Evaluate(apiTemplatesExpression); + if (templates.Count > 0) + { + writer.WriteString(" x:TypeArguments=\""); + while (templates.MoveNext()) + { + XPathNavigator template = templates.Current; + string name = template.GetAttribute("name", String.Empty); + writer.WriteString(name); + if (templates.CurrentPosition < templates.Count) + writer.WriteString(","); + } + writer.WriteString("\""); + } + } + else + { + // for non-generic types just show the name + writer.WriteIdentifier(typeName); + } + if (contentPropertyId == string.Empty) + { + writer.WriteString(" .../>"); + } + else + { + // close the start tag + writer.WriteString(">"); + + // the inner xml of the Object Element syntax for a type with a content property + // is a link to the content property + writer.WriteLine(); + writer.WriteString(" "); + writer.WriteReferenceLink(contentPropertyId); + writer.WriteLine(); + + // write the end tag + writer.WriteString("</"); + writer.WriteIdentifier(typeName); + writer.WriteString(">"); + } + + // end the sub block + writer.WriteEndSubBlock(); + } + + + public override void WriteStructureSyntax(XPathNavigator reflection, SyntaxWriter writer) + { + string name = (string)reflection.Evaluate(apiNameExpression); + bool notWriteable = (bool)reflection.Evaluate(noSettablePropertiesExpression); + + if (notWriteable) + { + // Output boilerplate for struct with no writeable properties + WriteXamlBoilerplate(XamlBoilerplateID.structXamlSyntax_nonXaml, writer); + } + else + { + // All writeable structs in XAML assemblies are usable in XAML + // always show the Object Element Usage syntax + ObjectElementUsageForClassStruct(reflection, writer); + + // For structs with TypeConverterAttribute, + // if we can show multiple syntax blocks, also output AttributeUsage boilerplate + if (HasTypeConverterAttribute(reflection)) + WriteXamlBoilerplate(XamlBoilerplateID.structXamlSyntax_attributeUsage, writer); + } + } + + public override void WriteInterfaceSyntax(XPathNavigator reflection, SyntaxWriter writer) + { + WriteXamlBoilerplate(XamlBoilerplateID.interfaceOverviewXamlSyntax, writer); + } + + public override void WriteDelegateSyntax(XPathNavigator reflection, SyntaxWriter writer) + { + WriteXamlBoilerplate(XamlBoilerplateID.delegateOverviewXamlSyntax, writer); + } + + public override void WriteEnumerationSyntax(XPathNavigator reflection, SyntaxWriter writer) + { + WriteXamlBoilerplate(XamlBoilerplateID.enumerationOverviewXamlSyntax, writer); + } + + public override void WriteConstructorSyntax(XPathNavigator reflection, SyntaxWriter writer) + { + WriteXamlBoilerplate(XamlBoilerplateID.constructorOverviewXamlSyntax, writer); + } + + public override void WriteMethodSyntax(XPathNavigator reflection, SyntaxWriter writer) + { + WriteXamlBoilerplate(XamlBoilerplateID.methodOverviewXamlSyntax, writer); + } + + public override void WriteAttachedPropertySyntax(XPathNavigator reflection, SyntaxWriter writer) + { + string propertyName = (string)reflection.Evaluate(apiNameExpression); + string containingTypeName = (string)reflection.Evaluate(apiContainingTypeNameExpression); + bool isSettable = (bool)reflection.Evaluate(apiIsWritePropertyExpression); + XPathNavigator returnType = reflection.SelectSingleNode(apiReturnTypeExpression); + if (!isSettable) + { + WriteXamlBoilerplate(XamlBoilerplateID.propertyXamlSyntax_readOnly, writer); + } + else + { + // xaml syntax block for attached property + string xamlBlockId = System.Enum.GetName(typeof(XamlHeadingID), XamlHeadingID.xamlAttributeUsageHeading); + writer.WriteStartSubBlock(xamlBlockId); + writer.WriteString("<"); + writer.WriteParameter("object"); + writer.WriteString(" "); + writer.WriteIdentifier(containingTypeName + "." + propertyName); + writer.WriteString("=\""); + WriteTypeReference(returnType, writer); + writer.WriteString("\" .../>"); + writer.WriteEndSubBlock(); + } + } + + public override void WritePropertySyntax(XPathNavigator reflection, SyntaxWriter writer) + { + //containingTypeSubgroupExpression + string propertyName = (string)reflection.Evaluate(apiNameExpression); + 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) + { + 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); + } + } + } + + // 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(); + } + + // A grandiose Property Element Usage block + // syntax looks like: + // <object> + // <object.PropertyName> + // <linkToType .../> + // </object.PropertyName> + // </object> + private void PropertyElementUsageGrande(XPathNavigator propertyReflection, SyntaxWriter writer) + { + string xamlBlockId = System.Enum.GetName(typeof(XamlHeadingID), XamlHeadingID.xamlPropertyElementUsageHeading); + string propertyName = (string)propertyReflection.Evaluate(apiNameExpression); + XPathNavigator returnType = propertyReflection.SelectSingleNode(apiReturnTypeExpression); + + // start the syntax block + writer.WriteStartSubBlock(xamlBlockId); + + // <object> + writer.WriteString("<"); + writer.WriteParameter("object"); + writer.WriteString(">"); + writer.WriteLine(); + // <object.PropertyName> + writer.WriteString(" <"); + writer.WriteParameter("object"); + writer.WriteString("."); + writer.WriteIdentifier(propertyName); + writer.WriteString(">"); + writer.WriteLine(); + // <linkToType .../> + writer.WriteString(" <"); + WriteTypeReference(returnType, writer); + writer.WriteString(" .../>"); + writer.WriteLine(); + // </object.PropertyName> + writer.WriteString(" </"); + writer.WriteParameter("object"); + writer.WriteString("."); + writer.WriteIdentifier(propertyName); + writer.WriteString(">"); + writer.WriteLine(); + // </object> + writer.WriteString("</"); + writer.WriteParameter("object"); + writer.WriteString(">"); + + writer.WriteEndSubBlock(); + } + + // An Attribute Usage block + private void PropertyAttributeUsage(XPathNavigator propertyReflection, SyntaxWriter writer) + { + string xamlBlockId = System.Enum.GetName(typeof(XamlHeadingID), XamlHeadingID.xamlAttributeUsageHeading); + string propertyName = (string)propertyReflection.Evaluate(apiNameExpression); + XPathNavigator returnType = propertyReflection.SelectSingleNode(apiReturnTypeExpression); + + // start the syntax block + writer.WriteStartSubBlock(xamlBlockId); + + // syntax looks like: + // <object PropertyName="linkToType" .../> + writer.WriteString("<"); + writer.WriteParameter("object"); + writer.WriteString(" "); + writer.WriteIdentifier(propertyName); + writer.WriteString("=\""); + WriteTypeReference(returnType, writer); + writer.WriteString("\" .../>"); + + writer.WriteEndSubBlock(); + } + + public override void WriteEventSyntax(XPathNavigator reflection, SyntaxWriter writer) + { + string eventName = (string)reflection.Evaluate(apiNameExpression); + string eventVisibility = (string)reflection.Evaluate(apiVisibilityExpression); + bool isAbstract = (bool)reflection.Evaluate(apiIsAbstractProcedureExpression); + XPathNavigator eventHandler = reflection.SelectSingleNode(apiHandlerOfEventExpression); + + XPathNavigator containingType = reflection.SelectSingleNode(apiContainingTypeExpression); + string containingTypeSubgroup = (string)containingType.Evaluate(apiSubgroupExpression); + bool containingTypeIsAbstract = (bool)containingType.Evaluate(apiIsAbstractTypeExpression); + bool containingTypeIsSealed = (bool)containingType.Evaluate(apiIsSealedTypeExpression); + + if (containingTypeSubgroup == "interface") + { + WriteXamlBoilerplate(XamlBoilerplateID.eventXamlSyntax_noXamlSyntaxForInterfaceMembers, writer); + } + else if (containingTypeIsAbstract && containingTypeIsSealed) + { + // the event's containing type is static if it's abstract and sealed + // members of a static class cannot be used in XAML. + WriteXamlBoilerplate(XamlBoilerplateID.eventXamlSyntax_nonXamlParent, writer); + } + else if (IsExcludedSubClass(containingType)) + { + WriteXamlBoilerplate(XamlBoilerplateID.eventXamlSyntax_parentIsExcludedSubClass, writer); + } + else if (!DoesParentSupportXaml(reflection)) + { + WriteXamlBoilerplate(XamlBoilerplateID.eventXamlSyntax_nonXamlParent, writer); + } + else if (eventVisibility != "public") + { + WriteXamlBoilerplate(XamlBoilerplateID.eventXamlSyntax_notPublic, writer); + } + else if (isAbstract) + { + WriteXamlBoilerplate(XamlBoilerplateID.eventXamlSyntax_abstract, writer); + } + else + { + // start the syntax block + string xamlBlockId = System.Enum.GetName(typeof(XamlHeadingID), XamlHeadingID.xamlAttributeUsageHeading); + writer.WriteStartSubBlock(xamlBlockId); + + // syntax looks like: + // <object eventName="eventHandlerLink" .../> + writer.WriteString("<"); + writer.WriteParameter("object"); + writer.WriteString(" "); + writer.WriteIdentifier(eventName); + writer.WriteString("=\""); + WriteTypeReference(eventHandler, writer); + writer.WriteString("\" .../>"); + + writer.WriteEndSubBlock(); + } + } + + public override void WriteAttachedEventSyntax(XPathNavigator reflection, SyntaxWriter writer) + { + string eventName = (string)reflection.Evaluate(apiNameExpression); + string containingTypeName = (string)reflection.Evaluate(apiContainingTypeNameExpression); + XPathNavigator eventHandler = reflection.SelectSingleNode(apiHandlerOfEventExpression); + + // xaml syntax block for attached event + string xamlBlockId = System.Enum.GetName(typeof(XamlHeadingID), XamlHeadingID.xamlAttributeUsageHeading); + writer.WriteStartSubBlock(xamlBlockId); + + writer.WriteString("<"); + writer.WriteParameter("object"); + writer.WriteString(" "); + writer.WriteIdentifier(containingTypeName + "." + eventName); + writer.WriteString("=\""); + WriteTypeReference(eventHandler, writer); + writer.WriteString(string.Format("\" .../>")); + + writer.WriteEndSubBlock(); + } + + public override void WriteFieldSyntax(XPathNavigator reflection, SyntaxWriter writer) + { + WriteXamlBoilerplate(XamlBoilerplateID.fieldOverviewXamlSyntax, writer); + } + + // 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); + 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); + + XPathNavigator outerTypeReference = reference.SelectSingleNode(typeOuterTypeExpression); + if (outerTypeReference != null) + { + WriteTypeReference(outerTypeReference, writer); + writer.WriteString("."); + } + + 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 WriteNormalTypeReference(string reference, SyntaxWriter writer) + { + switch (reference) + { + case "T:System.Void": + writer.WriteReferenceLink(reference, "void"); + break; + case "T:System.String": + writer.WriteReferenceLink(reference, "string"); + break; + case "T:System.Boolean": + writer.WriteReferenceLink(reference, "bool"); + break; + case "T:System.Byte": + writer.WriteReferenceLink(reference, "byte"); + break; + case "T:System.SByte": + writer.WriteReferenceLink(reference, "sbyte"); + break; + case "T:System.Char": + writer.WriteReferenceLink(reference, "char"); + break; + case "T:System.Int16": + writer.WriteReferenceLink(reference, "short"); + break; + case "T:System.Int32": + writer.WriteReferenceLink(reference, "int"); + break; + case "T:System.Int64": + writer.WriteReferenceLink(reference, "long"); + break; + case "T:System.UInt16": + writer.WriteReferenceLink(reference, "ushort"); + break; + case "T:System.UInt32": + writer.WriteReferenceLink(reference, "uint"); + break; + case "T:System.UInt64": + writer.WriteReferenceLink(reference, "ulong"); + break; + case "T:System.Single": + writer.WriteReferenceLink(reference, "float"); + break; + case "T:System.Double": + writer.WriteReferenceLink(reference, "double"); + break; + case "T:System.Decimal": + writer.WriteReferenceLink(reference, "decimal"); + break; + default: + writer.WriteReferenceLink(reference); + break; + } + } + + // utility routines + + + // A default constructor is a a parameterless, public constructor method + // This is called for: + // a class + // the declaring type of a member + // the type of a property + private bool HasDefaultConstructor(XPathNavigator typeReflection) + { + // all structs have implicit default constructors + string subgroup = (string)typeReflection.Evaluate(apiSubgroupExpression); + if (subgroup == "structure") + return true; + + return (bool)typeReflection.Evaluate(hasDefaultConstructorExpression); + } + + // This is called to check for a "TypeConverterAttribute" on: + // a class or structure topic + // the declaring type of a property or event member + // the type of a property + private bool HasTypeConverterAttribute(XPathNavigator typeReflection) + { + return (bool)typeReflection.Evaluate(hasTypeConverterAttributeExpression); + } + + // Get the id of the content property, if any, for the property's containing type + // return true if the content property id matches the current property's id + private bool IsContentProperty(XPathNavigator propertyReflection) + { + string propertyName = (string)propertyReflection.Evaluate(apiNameExpression); + XPathNavigator containingType = propertyReflection.SelectSingleNode(apiContainingTypeExpression); + string containingTypeName = (string)containingType.Evaluate(apiNameExpression); + string namespaceId = (string)propertyReflection.Evaluate(apiContainingNamespaceIdExpression); + string propertyId = string.Concat("P:", namespaceId.Substring(2), ".", string.Concat(containingTypeName, ".", propertyName)); + string contentPropertyId = (string)containingType.Evaluate(contentPropertyIdExpression); + if (propertyId == contentPropertyId) + return true; + else + return false; + } + + // Check the list of subclasses to exclude + // This is called to check the class ancestors of + // a class + // the declaring type of a property or event member + private bool IsExcludedSubClass(XPathNavigator typeReflection) + { + XPathNodeIterator ancestors = (XPathNodeIterator)typeReflection.Evaluate(apiAncestorsExpression); + + foreach (XPathNavigator ancestor in ancestors) + { + string ancestorId = ancestor.GetAttribute("api", string.Empty); + if (excludedAncestorList.Contains(ancestorId)) + return true; + } + return false; + } + + // Check the parent type of a property or event. + // Does it have the necessary characteristics so the property or event can be used in XAML? + // Is PARENT CLASS abstract OR does it have a default ctor OR a class-level TypeConverter attribute? + private bool DoesParentSupportXaml(XPathNavigator memberReflection) + { + XPathNavigator containingType = memberReflection.SelectSingleNode(apiContainingTypeExpression); + if ((bool)containingType.Evaluate(apiIsAbstractTypeExpression)) + return true; + + if (HasDefaultConstructor(containingType)) + return true; + + if (HasTypeConverterAttribute(containingType)) + return true; + + // A property that returns a String doesn't need a TypeConverterAttribute, so return true here + XPathNavigator returnType = memberReflection.SelectSingleNode(apiReturnTypeExpression); + if (returnType != null) + { + string returnTypeId = returnType.GetAttribute("api", string.Empty); + if (returnTypeId == "T:System.String") + return true; + } + + return false; + } + + private bool IsPrimitiveType(string typeId) + { + // The primitive types are Boolean, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, IntPtr, Char, Double, and Single. + switch (typeId) + { + case "T:System.Boolean": + case "T:System.Byte": + case "T:System.SByte": + case "T:System.Int16": + case "T:System.UInt16": + case "T:System.Int32": + case "T:System.UInt32": + case "T:System.Int64": + case "T:System.UInt64": + case "T:System.IntPtr": + case "T:System.Char": + case "T:System.Double": + case "T:System.Single": + case "T:System.String": // String is not a primitive but is treated as one for this XAML purpose + return true; + default: + return false; + } + } + + + private XPathExpression hasTypeConverterAttributeExpression = XPathExpression.Compile("boolean(attributes/attribute/type[@api='T:System.ComponentModel.TypeConverterAttribute'])"); + + private XPathExpression hasDefaultConstructorExpression = XPathExpression.Compile("boolean(typedata/@defaultConstructor)"); + + private XPathExpression contentPropertyNameExpression = XPathExpression.Compile("string(attributes/attribute[type[contains(@api,'.ContentPropertyAttribute')]]/argument/value/.)"); + private XPathExpression contentPropertyIdExpression = XPathExpression.Compile("string(typedata/@contentProperty)"); + private XPathExpression ancestorContentPropertyIdExpression = XPathExpression.Compile("string(family/ancestors/type/@contentProperty)"); + + private XPathExpression noSettablePropertiesExpression = XPathExpression.Compile("boolean(typedata/@noSettableProperties)"); + + private XPathExpression apiIsSetterPublicExpression = XPathExpression.Compile("boolean((memberdata[@visibility='public'] and not(propertydata[@set-visibility!='public'])) or propertydata[@set-visibility='public'])"); + } + + public enum XamlBoilerplateID + { + // boilerplate for classes in xaml assemblies + classXamlSyntax_abstract, + classXamlSyntax_excludedSubClass, + classXamlSyntax_noDefaultCtor, + classXamlSyntax_noDefaultCtorWithTypeConverter, + // boilerplate for structs in xaml assemblies + structXamlSyntax_nonXaml, + structXamlSyntax_attributeUsage, + // boilerplate for events in xaml assemblies + eventXamlSyntax_parentIsExcludedSubClass, + eventXamlSyntax_noXamlSyntaxForInterfaceMembers, + eventXamlSyntax_nonXamlParent, + eventXamlSyntax_notPublic, + eventXamlSyntax_abstract, + eventXamlSyntax_nonXaml, + // boilerplate for properties in xaml assemblies + propertyXamlSyntax_parentIsExcludedSubClass, + propertyXamlSyntax_noXamlSyntaxForInterfaceMembers, + propertyXamlSyntax_nonXamlParent, + propertyXamlSyntax_notPublic, + propertyXamlSyntax_abstract, + propertyXamlSyntax_readOnly, + propertyXamlSyntax_abstractType, + propertyXamlSyntax_nonXaml, + // syntax used with all enums in xaml assemblies + enumerationOverviewXamlSyntax, + // boilerplate used with all method, field, etc. in xaml assemblies + delegateOverviewXamlSyntax, + interfaceOverviewXamlSyntax, + constructorOverviewXamlSyntax, + fieldOverviewXamlSyntax, + methodOverviewXamlSyntax, + // boilerplate used with all types and members in all non-xaml assemblies + nonXamlAssemblyBoilerplate + } + + // XAML headings + public enum XamlHeadingID + { + xamlAttributeUsageHeading, + xamlObjectElementUsageHeading, + xamlPropertyElementUsageHeading, + xamlContentElementUsageHeading, + xamlSyntaxBoilerplateHeading + } + + +} diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/makefile b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/makefile new file mode 100644 index 0000000..defc9db --- /dev/null +++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/makefile @@ -0,0 +1,11 @@ + +LIBRARY = ..\BuildComponents\BuildComponents.dll + +COMPONENT_FILES = SyntaxGenerators.cs CSharpDeclarationSyntax.cs VisualBasicDeclarationSyntax.cs CPlusPlusDeclarationSyntax.cs JSharpDeclarationSyntax.cs +COMPONENT_FILES_OLD = SyntaxGenerators.cs CSharpDeclarationSyntax.cs VisualBasicDeclarationSyntax.cs + +all: SyntaxGenerators.dll + +SyntaxGenerators.dll: $(COMPONENT_FILES) $(LIBRARY) + csc /t:library /out:SyntaxGenerators.dll $(COMPONENT_FILES) /r:$(LIBRARY) + copy SyntaxGenerators.dll ..\..\ProductionTools\BuildComponents
\ No newline at end of file diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/makefile.inc b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/makefile.inc new file mode 100644 index 0000000..32f7350 --- /dev/null +++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/makefile.inc @@ -0,0 +1,2 @@ +!INCLUDE $(INETROOT)\build\makefile.inc + diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/makefile.org b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/makefile.org new file mode 100644 index 0000000..d48cffe --- /dev/null +++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/makefile.org @@ -0,0 +1,11 @@ + +LIBRARY = ..\BuildComponents.dll + +COMPONENT_FILES = SyntaxGenerators.cs CSharpDeclarationSyntax.cs VisualBasicDeclarationSyntax.cs CPlusPlusDeclarationSyntax.cs +COMPONENT_FILES_OLD = SyntaxGenerators.cs CSharpDeclarationSyntax.cs VisualBasicDeclarationSyntax.cs + +all: SyntaxGenerators.dll + +SyntaxGenerators.dll: $(COMPONENT_FILES) $(LIBRARY) + csc /t:library /out:SyntaxGenerators.dll $(COMPONENT_FILES) /r:$(LIBRARY) + copy SyntaxGenerators.dll ..\..\..\..\ProductionTools\BuildComponents
\ No newline at end of file diff --git a/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/placefile b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/placefile new file mode 100644 index 0000000..6d266be --- /dev/null +++ b/tools/Sandcastle/Source/BuildAssembler/SyntaxComponents/placefile @@ -0,0 +1 @@ +Microsoft.Ddue.Tools.BuildComponents.SyntaxGenerators.dll Manifold |