/// <summary>
/// Parses the given <paramref name="aliasElement"/> and creates an ImportStatement or AliasStatement from it.
/// </summary>
/// <param name="aliasElement">The alias element to parse.</param>
/// <param name="context">The parser context to use.</param>
/// <returns>An ImportStatement if the element is an import, or an AliasStatement if it is an alias.</returns>
protected override Statement ParseAliasElement(XElement aliasElement, ParserContext context)
{
if (aliasElement == null)
{
throw new ArgumentNullException("aliasElement");
}
if (aliasElement.Name != AliasElementName)
{
throw new ArgumentException(string.Format("Must be a SRC.{0} element", AliasElementName.LocalName), "aliasElement");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
var isNamespaceImport = aliasElement.Descendants(SRC.Name).Any(n => n.Value.Contains("*"));
//Elements("name").Any(n => n.Value.Contains("*")); //).Any(n => n.Value.Contains("*"));
Statement stmt = null;
if (isNamespaceImport)
{
//namespace import
var import = new ImportStatement()
{
ProgrammingLanguage = ParserLanguage
};
import.AddLocation(context.CreateLocation(aliasElement));
var nameElement = aliasElement.Element(SRC.Name);
if (nameElement != null)
{
//we have an import that ends with .*. We remove the . and *.
nameElement.LastNode.Remove(); //remove *
nameElement.LastNode.Remove(); //remove .
import.ImportedNamespace = ParseNameUseElement <NamespaceUse>(nameElement, context);
//TODO: fix to handle the trailing operator tag
}
stmt = import;
}
else
{
//importing a single member, i.e. an alias
var alias = new AliasStatement()
{
ProgrammingLanguage = ParserLanguage
};
alias.AddLocation(context.CreateLocation(aliasElement));
var nameElement = aliasElement.Element(SRC.Name);
if (nameElement != null)
{
alias.Target = ParseExpression(nameElement, context);
alias.AliasName = NameHelper.GetLastName(nameElement);
}
stmt = alias;
}
return(stmt);
}
/// <summary>
/// Parses the given <paramref name="aliasElement"/> and creates an ImportStatement or AliasStatement from it.
/// </summary>
/// <param name="aliasElement">The alias element to parse.</param>
/// <param name="context">The parser context to use.</param>
/// <returns>An ImportStatement if the element is an import, or an AliasStatement if it is an alias.</returns>
protected override Statement ParseAliasElement(XElement aliasElement, ParserContext context) {
if(null == aliasElement)
throw new ArgumentNullException("aliasElement");
if(aliasElement.Name != AliasElementName)
throw new ArgumentException(string.Format("Must be a SRC.{0} element", AliasElementName.LocalName), "aliasElement");
if(context == null)
throw new ArgumentNullException("context");
Statement stmt = null;
var namespaceElement = aliasElement.Element(SRC.Namespace);
if(namespaceElement != null) {
//import statement
var import = new ImportStatement() {ProgrammingLanguage = ParserLanguage};
import.AddLocation(context.CreateLocation(aliasElement));
var nameElement = namespaceElement.Element(SRC.Name);
if(nameElement != null) {
import.ImportedNamespace = ParseNameUseElement<NamespaceUse>(nameElement, context);
}
stmt = import;
} else {
//alias statement
var alias = new AliasStatement() {ProgrammingLanguage = ParserLanguage};
alias.AddLocation(context.CreateLocation(aliasElement));
//TODO: Make sure that using descendant is correct for nameElement
var nameElement = aliasElement.Element(SRC.Name);
var initElement = aliasElement.Element(SRC.Init);
if(initElement != null) {
//example: using foo = std::bar;
if(nameElement != null) {
alias.AliasName = nameElement.Value;
}
//TODO check this once srcml is updated to see if it's accurate
alias.Target = ParseExpression(GetFirstChildExpression(initElement), context);
} else {
//example: using std::cout;
if(nameElement != null) {
alias.Target = ParseTypeUseElement(nameElement, context);
alias.AliasName = NameHelper.GetLastName(nameElement);
}
}
stmt = alias;
}
return stmt;
}
/// <summary>
/// Parses the given <paramref name="aliasElement"/> and creates an ImportStatement or AliasStatement from it.
/// </summary>
/// <param name="aliasElement">The alias element to parse.</param>
/// <param name="context">The parser context to use.</param>
/// <returns>An ImportStatement if the element is an import, or an AliasStatement if it is an alias.</returns>
protected override Statement ParseAliasElement(XElement aliasElement, ParserContext context)
{
if (null == aliasElement)
{
throw new ArgumentNullException("aliasElement");
}
if (aliasElement.Name != AliasElementName)
{
throw new ArgumentException(string.Format("Must be a SRC.{0} element", AliasElementName.LocalName), "aliasElement");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
Statement stmt = null;
var namespaceElement = aliasElement.Element(SRC.Namespace);
if (namespaceElement != null)
{
//import statement
var import = new ImportStatement()
{
ProgrammingLanguage = ParserLanguage
};
import.AddLocation(context.CreateLocation(aliasElement));
var nameElement = namespaceElement.Element(SRC.Name);
if (nameElement != null)
{
import.ImportedNamespace = ParseNameUseElement <NamespaceUse>(nameElement, context);
}
stmt = import;
}
else
{
//alias statement
var alias = new AliasStatement()
{
ProgrammingLanguage = ParserLanguage
};
alias.AddLocation(context.CreateLocation(aliasElement));
//TODO: Make sure that using descendant is correct for nameElement
var nameElement = aliasElement.Element(SRC.Name);
var initElement = aliasElement.Element(SRC.Init);
if (initElement != null)
{
//example: using foo = std::bar;
if (nameElement != null)
{
alias.AliasName = nameElement.Value;
}
//TODO check this once srcml is updated to see if it's accurate
alias.Target = ParseExpression(GetFirstChildExpression(initElement), context);
}
else
{
//example: using std::cout;
if (nameElement != null)
{
alias.Target = ParseTypeUseElement(nameElement, context);
alias.AliasName = NameHelper.GetLastName(nameElement);
}
}
stmt = alias;
}
return(stmt);
}
/// <summary>
/// Parses the given <paramref name="aliasElement"/> and creates an ImportStatement or AliasStatement from it.
/// </summary>
/// <param name="aliasElement">The alias element to parse.</param>
/// <param name="context">The parser context to use.</param>
/// <returns>An ImportStatement if the element is an import, or an AliasStatement if it is an alias.</returns>
protected override Statement ParseAliasElement(XElement aliasElement, ParserContext context)
{
if (aliasElement == null)
{
throw new ArgumentNullException("aliasElement");
}
if (aliasElement.Name != AliasElementName)
{
throw new ArgumentException(string.Format("Must be a SRC.{0} element", AliasElementName.LocalName), "aliasElement");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
Statement stmt = null;
if (GetTextNodes(aliasElement).Any(n => n.Value.Contains("(")))
{
//using block
stmt = ParseUsingBlockElement(aliasElement, context);
}
else if (aliasElement.Element(SRC.Init) != null)
{
//alias
var alias = new AliasStatement()
{
ProgrammingLanguage = ParserLanguage
};
alias.AddLocation(context.CreateLocation(aliasElement));
var nameElement = aliasElement.Element(SRC.Name);
if (nameElement != null)
{
alias.AliasName = nameElement.Value;
}
var initElement = aliasElement.Element(SRC.Init);
alias.Target = ParseExpression <TypeContainerUse>(GetFirstChildExpression(initElement), context);
stmt = alias;
}
else
{
//import
var import = new ImportStatement()
{
ProgrammingLanguage = ParserLanguage
};
import.AddLocation(context.CreateLocation(aliasElement));
var nameElement = aliasElement.Element(SRC.Name);
if (nameElement != null)
{
import.ImportedNamespace = ParseNameUseElement <NamespaceUse>(nameElement, context);
}
stmt = import;
}
return(stmt);
}
/// <summary>
/// Parses the given <paramref name="aliasElement"/> and creates an ImportStatement or AliasStatement from it.
/// </summary>
/// <param name="aliasElement">The alias element to parse.</param>
/// <param name="context">The parser context to use.</param>
/// <returns>An ImportStatement if the element is an import, or an AliasStatement if it is an alias.</returns>
protected override Statement ParseAliasElement(XElement aliasElement, ParserContext context) {
if(aliasElement == null)
throw new ArgumentNullException("aliasElement");
if(aliasElement.Name != AliasElementName)
throw new ArgumentException(string.Format("Must be a SRC.{0} element", AliasElementName.LocalName), "aliasElement");
if(context == null)
throw new ArgumentNullException("context");
Statement stmt = null;
if(GetTextNodes(aliasElement).Any(n => n.Value.Contains("("))) {
//using block
stmt = ParseUsingBlockElement(aliasElement, context);
} else if(aliasElement.Element(SRC.Init) != null) {
//alias
var alias = new AliasStatement() {ProgrammingLanguage = ParserLanguage};
alias.AddLocation(context.CreateLocation(aliasElement));
var nameElement = aliasElement.Element(SRC.Name);
if(nameElement != null) {
alias.AliasName = nameElement.Value;
}
var initElement = aliasElement.Element(SRC.Init);
alias.Target = ParseExpression<TypeContainerUse>(GetFirstChildExpression(initElement), context);
stmt = alias;
} else {
//import
var import = new ImportStatement() {ProgrammingLanguage = ParserLanguage};
import.AddLocation(context.CreateLocation(aliasElement));
var nameElement = aliasElement.Element(SRC.Name);
if(nameElement != null) {
import.ImportedNamespace = ParseNameUseElement<NamespaceUse>(nameElement, context);
}
stmt = import;
}
return stmt;
}
/// <summary>
/// Parses the given <paramref name="aliasElement"/> and creates an ImportStatement or AliasStatement from it.
/// </summary>
/// <param name="aliasElement">The alias element to parse.</param>
/// <param name="context">The parser context to use.</param>
/// <returns>An ImportStatement if the element is an import, or an AliasStatement if it is an alias.</returns>
protected override Statement ParseAliasElement(XElement aliasElement, ParserContext context) {
if(aliasElement == null)
throw new ArgumentNullException("aliasElement");
if(aliasElement.Name != AliasElementName)
throw new ArgumentException(string.Format("Must be a SRC.{0} element", AliasElementName.LocalName), "aliasElement");
if(context == null)
throw new ArgumentNullException("context");
var isNamespaceImport = aliasElement.Descendants(SRC.Name).Any(n => n.Value.Contains("*"));
//Elements("name").Any(n => n.Value.Contains("*")); //).Any(n => n.Value.Contains("*"));
Statement stmt = null;
if(isNamespaceImport) {
//namespace import
var import = new ImportStatement() {ProgrammingLanguage = ParserLanguage};
import.AddLocation(context.CreateLocation(aliasElement));
var nameElement = aliasElement.Element(SRC.Name);
if(nameElement != null) {
//we have an import that ends with .*. We remove the . and *.
nameElement.LastNode.Remove();//remove *
nameElement.LastNode.Remove();//remove .
import.ImportedNamespace = ParseNameUseElement<NamespaceUse>(nameElement, context);
//TODO: fix to handle the trailing operator tag
}
stmt = import;
} else {
//importing a single member, i.e. an alias
var alias = new AliasStatement() {ProgrammingLanguage = ParserLanguage};
alias.AddLocation(context.CreateLocation(aliasElement));
var nameElement = aliasElement.Element(SRC.Name);
if(nameElement != null) {
alias.Target = ParseExpression(nameElement, context);
alias.AliasName = NameHelper.GetLastName(nameElement);
}
stmt = alias;
}
return stmt;
}