public override void VisitEnumBlock(EnumBlockSyntax node)
{
var statementNode = node.ChildNodes().OfType <EnumStatementSyntax>().FirstOrDefault();
var defineName = statementNode.ChildTokens().FirstOrDefault(x => x.Kind() == SyntaxKind.IdentifierToken).ToString();
var enumMembers = node.ChildNodes().OfType <EnumMemberDeclarationSyntax>().Select(x => x.Identifier.Text);
var startLength = node.Span.Start;
var endLength = node.Span.End;
var parentNamespace = GetNamespace(DefineKinds.Enum, startLength, endLength);
UserDefinitions.Add(new UserDefinition
{
DefineKinds = DefineKinds.Enum,
Namespace = parentNamespace,
DefineName = defineName,
DefineFullName = $"{parentNamespace}.{defineName}",
EnumMembers = enumMembers.ToList(),
SourceFile = SourceFile,
StartLength = startLength,
EndLength = endLength,
});;
base.VisitEnumBlock(node);
}
internal static CodeStructureItem MapItem(EnumBlockSyntax node)
{
var item = CreateItem <EnumNode>(node);
item.AccessModifier = node.EnumStatement.Modifiers.GetAccessModifier();
item.Name = node.EnumStatement.Identifier.Text;
return(item);
}
public override SyntaxNode VisitEnumBlock(EnumBlockSyntax node)
{
var enumStatement = (EnumStatementSyntax)EnsureVisibility(
node.EnumStatement,
node.EnumStatement.EnumKeyword,
node.EnumStatement.Modifiers,
(x, k) => x.WithEnumKeyword(k),
(x, l) => x.WithModifiers(l),
() => GetDelegateTypeDefaultVisibility(node));
return(node.WithEnumStatement(enumStatement));
}
/// <summary>
/// Generates .NET code for an enumeration.
/// </summary>
/// <param name="context">Enumeration AST.</param>
/// <returns></returns>
public override CodeGeneratorBase VisitEnumerationStmt(VisualBasic6Parser.EnumerationStmtContext context)
{
SyntaxTokenList accessibility = new SyntaxTokenList();
VisualBasic6Parser.PublicPrivateVisibilityContext vis = context.publicPrivateVisibility();
if (vis != null)
{
if (vis.PUBLIC() != null)
{
accessibility = RoslynUtils.PublicModifier;
}
else if (vis.PRIVATE() != null)
{
accessibility = RoslynUtils.PrivateModifier;
}
}
EnumStatementSyntax stmt = SyntaxFactory.EnumStatement(context.ambiguousIdentifier().GetText()).WithModifiers(accessibility);
EnumBlockSyntax enumBlock = SyntaxFactory.EnumBlock(stmt);
List <EnumMemberDeclarationSyntax> members = new List <EnumMemberDeclarationSyntax>();
foreach (var constant in context.enumerationStmt_Constant())
{
string constantName = constant.ambiguousIdentifier().GetText();
if (constant.valueStmt() != null)
{
string constantValue = constant.valueStmt().GetText();
members.Add(SyntaxFactory.EnumMemberDeclaration(constantName)
.WithInitializer(SyntaxFactory.EqualsValue(SyntaxFactory.NumericLiteralExpression(SyntaxFactory.ParseToken(constantValue)))));
}
else
{
members.Add(SyntaxFactory.EnumMemberDeclaration(constantName));
}
}
mMainDeclMembers.Add(enumBlock.WithMembers(SyntaxFactory.List <StatementSyntax>(members)));
return(this);
}
public override void VisitEnumBlock(EnumBlockSyntax node)
{
AddBlockData(node);
base.VisitEnumBlock(node);
}
public override void VisitEnumBlock(EnumBlockSyntax node)
{
LogicalLineCount++;
base.VisitEnumBlock(node);
}
public override void VisitEnumBlock(EnumBlockSyntax node)
{
}
private Model.Enum TraverseEnum(EnumBlockSyntax ebs)
{
Model.Enum retEnum = new Model.Enum();
/*
Type = new Type();
Encapsulation = new List<Encapsulation>();
EnumItems = new List<string>();
*/
retEnum.Name = ebs.EnumStatement.Identifier.ValueText;
//TODO: What is the deal with Type?
foreach (SyntaxToken st in ebs.EnumStatement.Modifiers)
{
string modifier = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(st.ValueText);
retEnum.Encapsulation.Add((Encapsulation)System.Enum.Parse(typeof(Encapsulation), modifier));
}
//TODO: EnumItems
foreach (EnumMemberDeclarationSyntax emds in ebs.Members)
{
retEnum.EnumItems.Add(emds.Identifier.ValueText);
}
return retEnum;
}
