void ExportEnum(EnumDeclarationSyntax c)
{
string name = "";
string nameSpace = "";
NamespaceDeclarationSyntax namespaceDeclarationSyntax = c.Parent as NamespaceDeclarationSyntax;
if (namespaceDeclarationSyntax != null)
{
nameSpace = namespaceDeclarationSyntax.Name.ToString();
}
else
{
nameSpace = ModelData.GloableNamespaceName;
}
name = c.Identifier.Text;
if (step == ECompilerStet.ScanType)
{
type_list.Add(new ULTypeInfo());
types.Push(type_list[type_list.Count - 1]);
currentType.Namespace = nameSpace;
currentType.Name = name;
currentType.IsEnum = true;
ModelData.UpdateType(currentType);
}
else
{
types.Push(ModelData.FindTypeByFullName(nameSpace + "." + name));
}
if (step == ECompilerStet.ScanMember)
{
//导出所有变量
var virableNodes = c.ChildNodes().OfType <EnumMemberDeclarationSyntax>();
foreach (var v in virableNodes)
{
var dB_Member = new ULMemberInfo();
dB_Member.Name = v.Identifier.Text;
dB_Member.IsStatic = false;
dB_Member.DeclareTypeName = currentType.FullName;
dB_Member.MemberType = ULMemberInfo.EMemberType.Enum;
currentType.Members.Add(dB_Member);
}
}
types.Pop();
}
public static string EnumDeclaration(EnumDeclarationSyntax node)
{
//TODO: parse EnumMemberDeclaration separately
var parsedAttributes = ParseAttributes(node.AttributeLists);
var output = parsedAttributes.Item1;
var nameToUse = parsedAttributes.Item2;
output += "enum " + (nameToUse ?? node.Identifier.Text);
//Get the value of the enum
foreach (var decl in node.ChildNodes().OfType <EnumMemberDeclarationSyntax>().Where(decl => decl.EqualsValue != null).Select(decl => decl.EqualsValue.Value))
{
if (decl.IsKind(SyntaxKind.StringLiteralExpression))
{
output += ": String";
}
else if (decl.IsKind(SyntaxKind.CharacterLiteralExpression))
{
output += ": Character";
}
else if (decl.IsKind(SyntaxKind.NumericLiteralExpression))
{
output += ": Int";
}
else
{
continue;
}
break;
}
output += " {" + NewLine;
output += string.Join("," + NewLine, node.Members.Select(SyntaxNode)) + NewLine + "}" + NewLine + NewLine;
return(output);
}
public override void VisitEnumDeclaration(EnumDeclarationSyntax node)
{
var defineName = node.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.VisitEnumDeclaration(node);
}
public static string EnumDeclaration(EnumDeclarationSyntax declaration)
{
var parsedAttributes = ParseAttributes(declaration.AttributeLists);
var output = parsedAttributes.Item1;
var nameToUse = parsedAttributes.Item2;
output += "enum " + (nameToUse ?? declaration.Identifier.Text);
//Get the value of the enum
foreach (var decl in declaration.ChildNodes().OfType<EnumMemberDeclarationSyntax>().Where(decl => decl.EqualsValue != null).Select(decl => decl.EqualsValue.Value))
{
if (decl.IsKind(SyntaxKind.StringLiteralExpression))
{
output += ": String";
}
else if (decl.IsKind(SyntaxKind.CharacterLiteralExpression))
{
output += ": Character";
}
else if (decl.IsKind(SyntaxKind.NumericLiteralExpression))
{
output += ": Int";
}
else
{
continue;
}
break;
}
return output + " {" + NewLine +
string.Join("," + NewLine, declaration.Members.Select(SyntaxNode)) + NewLine +
"}" + NewLine + NewLine;
}
/// <summary>
/// Still needs work!
/// </summary>
/// <returns></returns>
private Model.Enum TraverseEnums(EnumDeclarationSyntax eds)
{
Model.Enum retEnu = new Model.Enum();
//public List<string> EnumItems { get; set; }
//public string Name { get; set; }
//public Type Type { get; set; }
if (eds.HasLeadingTrivia)
{
SetOuterComments(retEnu, eds.GetLeadingTrivia().ToFullString());
}
if (eds.HasTrailingTrivia)
{
SetInnerComments(retEnu, eds.GetTrailingTrivia().ToFullString());
}
var types = from aType in eds.ChildNodes().OfType<TypeDeclarationSyntax>() select aType;
foreach (TypeDeclarationSyntax tds in types)
{
//TODO put breakpoint here
//to find out how to get types
}
foreach (SyntaxToken st in eds.Modifiers)
{
string modifier = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(st.ValueText);
retEnu.Encapsulation.Add((Encapsulation)System.Enum.Parse(typeof(Encapsulation), modifier));
}
var enumItems = from aEnumItem in eds.ChildNodes().OfType<EnumMemberDeclarationSyntax>() select aEnumItem;
foreach (EnumMemberDeclarationSyntax emds in enumItems)
{
//TODO put breakpoint here
//to find out how to get enumitems
}
return retEnu;
}
