public EnumerationEntity Parse(TypedEntity typedEntity, String name, IEnumerable<XElement> elements)
{
EnumerationEntity enumerationEntity = new EnumerationEntity ();
XElement declarationElement = (from el in elements
where el.Name == "div" &&
el.Attribute ("class") != null &&
el.Attribute ("class").Value == "declaration_indent"
select el).FirstOrDefault ();
XElement parameterElement = (from el in elements
where el.Name == "div" &&
el.Attribute ("class") != null &&
el.Attribute ("class").Value == "param_indent"
select el).FirstOrDefault ();
//XElement discussionElement = (from el in elements
// where el.Name == "h5" && el.Value.Trim() == "Discussion"
// select el).FirstOrDefault();
XElement availabilityElement = (from el in elements
let term = el.Descendants ("dt").FirstOrDefault ()
let definition = el.Descendants ("dd").FirstOrDefault ()
where el.Name == "dl" &&
term != null &&
term.Value.Trim () == "Availability"
select definition).FirstOrDefault ();
String declaration = declarationElement.TrimAll ();
String type = "NOTYPE";
String values = String.Empty;
bool result = this.SplitEnumeration (declaration, ref name, ref type, ref values);
if (!result) {
return null;
}
enumerationEntity.Name = name;
enumerationEntity.BaseType = type;
enumerationEntity.Namespace = "MISSING";
// Extract abstract
IEnumerable<XElement> abstractElements = elements.SkipWhile (el => el.Name != "p").TakeWhile (el => el.Name == "p");
foreach (XElement element in abstractElements) {
String line = element.TrimAll ();
if (!String.IsNullOrEmpty (line)) {
enumerationEntity.Summary.Add (line);
}
}
//// Extract discussion
//if (discussionElement != null)
//{
// IEnumerable<XElement> discussionElements = discussionElement.ElementsAfterSelf().TakeWhile(el => el.Name == "p");
// foreach (XElement element in discussionElements)
// {
// String line = element.TrimAll();
// if (!String.IsNullOrEmpty(line))
// {
// enumerationEntity.Summary.Add(line);
// }
// }
//}
// Parse the values
string[] pairs = values.Split (new []{','}, StringSplitOptions.RemoveEmptyEntries);
foreach (string pair in pairs) {
if (String.Equals (pair.TrimAll (), String.Empty)) {
continue;
}
String key;
String value = String.Empty;
if (pair.IndexOf ('=') != -1) {
string[] parts = pair.Split (new []{'='}, StringSplitOptions.RemoveEmptyEntries);
key = parts [0].Trim ();
value = parts [1].Trim ();
} else {
key = pair.Trim ();
}
// Add a new value
EnumerationValueEntity enumerationValueEntity = new EnumerationValueEntity ();
enumerationValueEntity.Name = key;
if (value.Length == 6 && value.StartsWith ("'") && value.EndsWith ("'")) {
String v = value.Trim ('\'');
enumerationValueEntity.Value = "0x" + FourCharToInt (v).ToString ("X8");
} else {
enumerationValueEntity.Value = value;
}
enumerationEntity.Values.Add (enumerationValueEntity);
}
XElement termList = parameterElement != null ? parameterElement.Descendants ("dl").FirstOrDefault () : null;
if (termList != null) {
IEnumerable<XElement> dtList = from el in termList.Elements ("dt") select el;
IEnumerable<XElement> ddList = from el in termList.Elements ("dd") select el;
if (dtList.Count () == ddList.Count ()) {
// Iterate over definitions
for (int i = 0; i < dtList.Count(); i++) {
String term = dtList.ElementAt (i).TrimAll ();
//String summary = ddList.ElementAt(i).TrimAll();
IEnumerable<String> summaries = ddList.ElementAt (i).Elements ("p").Select (p => p.Value.TrimAll ());
// Find the parameter
EnumerationValueEntity enumerationValueEntity = enumerationEntity.Values.Find (p => String.Equals (p.Name, term));
if (enumerationValueEntity != null) {
foreach (string sum in summaries) {
enumerationValueEntity.Summary.Add (sum);
}
}
}
}
}
// Get the availability
if (availabilityElement != null) {
enumerationEntity.MinAvailability = CommentHelper.ExtractAvailability (availabilityElement.TrimAll ());
}
return enumerationEntity;
}
private List<BaseEntity> ExtractEnumeration(XElement constantElement, String name, String summary, String declaration)
{
declaration = declaration.Trim (';');
// Default values
String type = "NOTYPE";
String values = String.Empty;
// Match the enumeration definition
bool result = this.SplitEnumeration (declaration, ref name, ref type, ref values);
if (!result) {
return null;
}
if (type == "NOTYPE") {
type = RefineEnumBaseType(values);
}
// Create the enumeration
EnumerationEntity enumerationEntity = new EnumerationEntity ();
enumerationEntity.Name = name;
enumerationEntity.BaseType = type;
enumerationEntity.Namespace = "MISSING";
enumerationEntity.Summary.Add (summary);
// Parse the values
var pairs = values.Split (new []{'\n'}, StringSplitOptions.RemoveEmptyEntries);
foreach (string immutablePair in pairs) {
String key;
String value = String.Empty;
String pair = immutablePair.Replace(",","");
// Handle value assignment
if (pair.IndexOf ('=') != -1) {
string[] parts = pair.Split (new []{'='}, StringSplitOptions.RemoveEmptyEntries);
key = parts [0].Trim ();
value = parts [1].Trim ();
} else {
key = pair.Trim ();
}
// Add a new value
EnumerationValueEntity enumerationValueEntity = new EnumerationValueEntity ();
enumerationValueEntity.Name = key;
if (value.Length == 6 && value.StartsWith ("'") && value.EndsWith ("'")) {
String v = value.Trim ('\'');
enumerationValueEntity.Value = "0x" + FourCharToInt (v).ToString ("X8");
} else {
enumerationValueEntity.Value = value;
}
// Convert number qualifiers from native to managed
enumerationValueEntity.Value = ConvertNumericQualifier (enumerationValueEntity.Value);
enumerationEntity.Values.Add (enumerationValueEntity);
}
// Get the definitions
XElement termList = (from el in constantElement.ElementsAfterSelf ("dl")
where (String)el.Attribute ("class") == "termdef"
select el).FirstOrDefault ();
if (termList != null) {
IEnumerable<XElement> dtList = termList.Elements ("dt");
IEnumerable<XElement> ddList = termList.Elements ("dd");
if (dtList.Count () == ddList.Count ()) {
// Iterate over definitions
for (int i = 0; i < dtList.Count(); i++) {
String term = dtList.ElementAt (i).Value.TrimAll ();
IEnumerable<String> summaries = ddList.ElementAt (i).Elements ("p").Select (p => p.Value.TrimAll ());
// Find the enumeration value
EnumerationValueEntity enumerationValueEntity = enumerationEntity.Values.Find (v => v.Name == term);
if (enumerationValueEntity != null) {
foreach (string sum in summaries) {
if (CommentHelper.IsAvailability (sum)) {
enumerationValueEntity.MinAvailability = CommentHelper.ExtractAvailability (sum);
break;
}
enumerationValueEntity.Summary.Add (sum);
}
} else {
this.Logger.WriteLine ("Term with no match '" + term + "'");
}
}
} else {
this.Logger.WriteLine ("MISMATCH in terms");
}
}
// Make sure availability is ok
enumerationEntity.AdjustAvailability ();
return new List<BaseEntity> {enumerationEntity};
}
public EnumerationEntity Parse(TypedEntity typedEntity, XElement enumerationElement)
{
EnumerationEntity enumerationEntity = new EnumerationEntity();
String name = enumerationElement.Element("name").TrimAll();
enumerationEntity.Name = name.Trim('_');
enumerationEntity.BaseType = "MISSING";
enumerationEntity.Namespace = "MISSING";
// Elements for brief description
IEnumerable<XElement> abstractElements = enumerationElement.Element("briefdescription").Elements("para");
// Extract for detailed description
IEnumerable<XElement> detailsElements = (from el in enumerationElement.Element("detaileddescription").Elements("para")
where !el.Elements("simplesect").Any()
&& el.Elements("parameterlist").Any()
&& el.Elements("xrefsect").Any()
select el);
// Elements for values
IEnumerable<XElement> enumerationValueElements = enumerationElement.Elements("enumvalue");
// Add brief description
foreach (XElement paragraph in abstractElements)
{
enumerationEntity.Summary.Add(paragraph.TrimAll());
}
foreach (XElement paragraph in detailsElements)
{
enumerationEntity.Summary.Add(paragraph.TrimAll());
}
// Add each value
foreach (XElement enumerationValueElement in enumerationValueElements)
{
String key = enumerationValueElement.Element("name").TrimAll();
String value;
if (enumerationValueElement.Element("initializer") != null)
{
value = enumerationValueElement.Element("initializer").Value;
value = value.Replace("=", String.Empty);
value = value.TrimAll();
}
else
{
value = String.Empty;
}
// Add a new value
EnumerationValueEntity enumerationValueEntity = new EnumerationValueEntity();
enumerationValueEntity.Name = key;
enumerationValueEntity.Value = value;
enumerationEntity.Values.Add(enumerationValueEntity);
// Elements for brief description
abstractElements = enumerationValueElement.Element("briefdescription").Elements("para");
// Add brief description
foreach (XElement paragraph in abstractElements)
{
enumerationValueEntity.Summary.Add(paragraph.TrimAll());
}
}
/*
// Get the availability
if (availabilityElement != null)
{
enumerationEntity.MinAvailability = CommentHelper.ExtractAvailability(availabilityElement.TrimAll());
}
*/
return enumerationEntity;
}
/// <summary>
/// Parses the specified entity.
/// </summary>
/// <param name = "entity">The entity.</param>
/// <param name = "reader">The reader.</param>
public override void Parse(BaseEntity entity, TextReader reader)
{
EnumerationEntity enumerationEntity = (EnumerationEntity)entity;
if (enumerationEntity == null) {
throw new ArgumentException ("EnumerationEntity expected", "entity");
}
IParser parser = ParserFactory.CreateParser (SupportedLanguage.CSharp, reader);
parser.Parse ();
// Extract the special nodes (comment, etc)
List<ISpecial> specials = parser.Lexer.SpecialTracker.RetrieveSpecials ();
this.CodeDomSpecialParser = new CodeDomSpecialParser (specials);
// Parse the compilation unit
CompilationUnit cu = parser.CompilationUnit;
foreach (INode child1 in cu.Children) {
NamespaceDeclaration namespaceDeclaration = child1 as NamespaceDeclaration;
if (namespaceDeclaration == null) {
continue;
}
foreach (INode child2 in child1.Children) {
TypeDeclaration declaration = child2 as TypeDeclaration;
if (declaration == null) {
continue;
}
if (declaration.Type != ClassType.Enum) {
continue;
}
// Extract basic informations
enumerationEntity.BaseType = declaration.BaseTypes.Count > 0 ? declaration.BaseTypes [0].Type : "int";
// Extract attributes
Attribute attribute = FindAttribute (declaration, "Flags");
enumerationEntity.Flags = (attribute != null);
IEnumerable<Comment> comments = this.GetDocumentationCommentsBefore (declaration);
AppendComment (entity, comments);
// Append each values
foreach (INode child3 in declaration.Children) {
FieldDeclaration fieldDeclaration = child3 as FieldDeclaration;
if (fieldDeclaration == null) {
continue;
}
EnumerationValueEntity valueEntity = new EnumerationValueEntity ();
valueEntity.Name = fieldDeclaration.Fields [0].Name;
Expression expression = fieldDeclaration.Fields [0].Initializer;
if (expression != null) {
CodeDomExpressionPrinter printer = new CodeDomExpressionPrinter ();
expression.AcceptVisitor (printer, null);
valueEntity.Value = printer.ToString ();
}
comments = this.GetDocumentationCommentsBefore (fieldDeclaration);
AppendComment (valueEntity, comments);
enumerationEntity.Values.Add (valueEntity);
}
}
}
// Ensure that availability is set on entity.
entity.AdjustAvailability ();
}