Switched out the Sandcastle binaries for the source code.

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