/// <summary>
/// Parses a Java package directive
/// </summary>
/// <param name="namespaceElement">A file unit</param>
/// <param name="context">The parser context</param>
public override void ParseNamespaceElement(XElement namespaceElement, ParserContext context) {
var javaPackage = context.FileUnit.Elements(SRC.Package).FirstOrDefault();
// Add a global namespace definition
var globalNamespace = new NamespaceDefinition();
context.Push(globalNamespace);
if(null != javaPackage) {
var namespaceElements = from name in javaPackage.Elements(SRC.Name)
select name;
foreach(var name in namespaceElements) {
var namespaceForName = new NamespaceDefinition() {
Name = name.Value,
ProgrammingLanguage = ParserLanguage,
};
namespaceForName.AddSourceLocation(context.CreateLocation(name));
context.Push(namespaceForName, globalNamespace);
}
}
}
/// <summary>
/// Creates a NamespaceDefinition object for the given namespace typeUseElement. This must be one of the typeUseElement types defined in NamespaceElementNames.
/// </summary>
/// <param name="namespaceElement">the namespace element</param>
/// <param name="context">The parser context</param>
/// <returns>a new NamespaceDefinition object</returns>
public override void ParseNamespaceElement(XElement namespaceElement, ParserContext context) {
if(namespaceElement == null)
throw new ArgumentNullException("namespaceElement");
if(!NamespaceElementNames.Contains(namespaceElement.Name))
throw new ArgumentException(string.Format("Not a valid namespace typeUseElement: {0}", namespaceElement.Name), "namespaceElement");
var nameElement = namespaceElement.Element(SRC.Name);
var namespaceName = nameElement != null ? nameElement.Value : string.Empty;
var namespaceDefinition = new NamespaceDefinition { Name = namespaceName };
context.Push(namespaceDefinition);
}
/// <summary>
/// Parses a C# namespace block
/// </summary>
/// <param name="namespaceElement">the namespace element to parse</param>
/// <param name="context">the parser context</param>
public override void ParseNamespaceElement(XElement namespaceElement, ParserContext context) {
if(namespaceElement == null) throw new ArgumentNullException("namespaceElement");
if(!NamespaceElementNames.Contains(namespaceElement.Name)) throw new ArgumentException(string.Format("Not a valid namespace element: {0}", namespaceElement.Name), "namespaceElement");
var nameElement = namespaceElement.Element(SRC.Name);
string namespaceName;
if(nameElement == null) {
namespaceName = string.Empty;
} else {
NamespaceDefinition root = null;
foreach(var name in NameHelper.GetNameElementsFromName(nameElement)) {
var namespaceForName = new NamespaceDefinition() {
Name = name.Value,
ProgrammingLanguage = ParserLanguage,
};
if(root == null) {
root = namespaceForName;
} else {
namespaceForName.AddSourceLocation(context.CreateLocation(name));
}
context.Push(namespaceForName, root);
}
}
}
/// <summary>
/// Creates a global <see cref="NamespaceDefinition"/> object for <paramref name="unitElement"/> and pushes it onto <paramref name="context"/>
/// </summary>
/// <param name="unitElement">The element to parse</param>
/// <param name="context">The context to place the resulting namespace definition in</param>
public virtual void ParseUnitElement(XElement unitElement, ParserContext context) {
if(null == unitElement) throw new ArgumentNullException("unitElement");
if(SRC.Unit != unitElement.Name) throw new ArgumentException("should be a SRC.Unit", "unitElement");
context.FileUnit = unitElement;
var aliases = from aliasStatement in GetAliasElementsForFile(unitElement)
select ParseAliasElement(aliasStatement, context);
context.Aliases = new Collection<Alias>(aliases.ToList());
var namespaceForUnit = new NamespaceDefinition();
context.Push(namespaceForUnit);
}
/// <summary>
/// Parses a type element and pushes a it onto the <paramref name="context"/>.
/// </summary>
/// <param name="typeElement">the type element to parse</param>
/// <param name="context">The parser context</param>
public virtual void ParseTypeElement(XElement typeElement, ParserContext context) {
if(null == typeElement) throw new ArgumentNullException("typeElement");
var typeDefinition = new TypeDefinition() {
Accessibility = GetAccessModifierForType(typeElement),
Kind = XNameMaps.GetKindForXElement(typeElement),
Name = GetNameForType(typeElement),
};
foreach(var parentTypeElement in GetParentTypeUseElements(typeElement)) {
var parentTypeUse = ParseTypeUseElement(parentTypeElement, context);
typeDefinition.AddParentType(parentTypeUse);
}
context.Push(typeDefinition);
}
/// <summary>
/// Creates a <see cref="MethodDefinition"/> object for <paramref name="methodElement"/> and pushes it onto <paramref name="context"/>
/// </summary>
/// <param name="methodElement">The element to parse</param>
/// <param name="context">The context to place the resulting method definition in</param>
public virtual void ParseMethodElement(XElement methodElement, ParserContext context) {
if(null == methodElement) throw new ArgumentNullException("methodElement");
if(!MethodElementNames.Contains(methodElement.Name)) throw new ArgumentException("must be a method typeUseElement", "fileUnit");
var methodDefinition = new MethodDefinition() {
Name = GetNameForMethod(methodElement),
IsConstructor = (methodElement.Name == SRC.Constructor || methodElement.Name == SRC.ConstructorDeclaration),
IsDestructor = (methodElement.Name == SRC.Destructor || methodElement.Name == SRC.DestructorDeclaration),
Accessibility = GetAccessModifierForMethod(methodElement),
};
// get the return type for the method
var returnTypeElement = methodElement.Element(SRC.Type);
if(returnTypeElement != null) {
// construct the return type
// however, if the Name of the return type is "void", don't use it because it means the return type is void
var returnTypeUse = ParseTypeUseElement(returnTypeElement, context);
if(returnTypeUse.Name != "void") {
methodDefinition.ReturnType = ParseTypeUseElement(returnTypeElement, context);
}
}
var parameters = from paramElement in GetParametersFromMethodElement(methodElement)
select ParseMethodParameterElement(paramElement, context);
methodDefinition.AddMethodParameters(parameters);
context.Push(methodDefinition);
}
/// <summary>
/// Creates a <see cref="Scope"/> object for <paramref name="element"/> and pushes it onto <paramref name="context"/>
/// </summary>
/// <param name="element">The element to parse</param>
/// <param name="context">the context to place the resulting scope on</param>
public virtual void ParseContainerElement(XElement element, ParserContext context) {
var scope = new Scope();
context.Push(scope);
}
