public void BuilderVisitorShouldBuildEnum()
{
#region Arrange Expected NodeTree Input
var root = new RootNode();
var enumnode = new Node(NodeType.Enum, "enum");
var enumname = new Node(NodeType.Identifier, "EnumName");
var field = new Node(NodeType.EnumField, "DEFAULT");
var name = new Node(NodeType.Identifier, "DEFAULT");
var value = new Node(NodeType.FieldNumber, "0");
var field1 = new Node(NodeType.EnumField, "VALONE");
var name1 = new Node(NodeType.Identifier, "VALONE");
var value1 = new Node(NodeType.FieldNumber, "1");
field.AddChildren(name, value);
field1.AddChildren(name1, value1);
enumnode.AddChildren(enumname, field, field1);
root.AddChild(enumnode);
#endregion Arrange Expected NodeTree Input
var expected = new EnumDefinition("EnumName", null, new List<EnumField>
{
new EnumField("DEFAULT", 0, null),
new EnumField("VALONE", 1, null)
});
var sut = new BuilderVisitor();
root.Accept(sut);
sut.FileDescriptor.Enumerations.First().Should().Be(expected);
}
public override void Visit(Node node)
{
var name = node.Children.Single(t => t.NodeType.Equals(NodeType.Identifier)).NodeValue;
var enumFieldNodes = node.Children.Where(t => t.NodeType.Equals(NodeType.EnumField));
var enumFields = new List<EnumField>();
foreach (var ef in enumFieldNodes)
{
var vis = new EnumFieldVisitor(Errors);
ef.Accept(vis);
enumFields.Add(vis.EnumField);
}
EnumDefinition = new EnumDefinition(name, null, enumFields);
}
private static string GetIdentifier(EnumDefinition enumDefinition, string @namespace = null) =>
string.IsNullOrEmpty(@namespace) ?
enumDefinition.Identifier :
$"{@namespace}.{enumDefinition.Identifier}";
static IEnumerable<ClassDefinition> ReadClassDefinition(WrapperProject project,
XmlReader reader, HeaderDefinition header, ClassDefinition parent = null)
{
string className = reader.GetAttribute("Name");
ClassDefinition @class;
string classType = reader.Name;
switch (classType)
{
case "Class":
@class = new ClassDefinition(className, header, parent);
break;
case "ClassTemplate":
@class = new ClassTemplateDefinition(className, header, parent);
break;
case "Enum":
@class = new EnumDefinition(className, header, parent);
break;
default:
throw new NotImplementedException();
}
string namespaceName = reader.GetAttribute("Namespace");
if (namespaceName != null)
{
@class.NamespaceName = namespaceName;
}
if ("true".Equals(reader.GetAttribute("IsExcluded"))) @class.IsExcluded = true;
if ("true".Equals(reader.GetAttribute("HasPreventDelete"))) @class.HasPreventDelete = true;
if ("true".Equals(reader.GetAttribute("MarshalAsStruct"))) @class.MarshalAsStruct = true;
if (reader.IsEmptyElement)
{
yield return @class;
yield break;
}
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "Class":
case "ClassTemplate":
case "Enum":
var classes = ReadClassDefinition(project, reader, header, @class);
foreach (var c in classes)
{
yield return c;
}
break;
case "Method":
ReadMethodDefinition(reader, @class);
break;
case "TemplateParameter":
(@class as ClassTemplateDefinition).TemplateParameters
.Add(reader.ReadElementContentAsString());
break;
}
}
else if (reader.NodeType == XmlNodeType.EndElement)
{
break;
}
}
yield return @class;
}
public EnumDefinition GetEnumDefinition(string name)
{
EnumDefinition output = null;
return(this.enumDefinitions.TryGetValue(name, out output) ? output : null);
}
public override void OnEnumDefinition(EnumDefinition node)
{
base.OnEnumDefinition(node);
Check(node);
}
/// <summary>
/// Exports a DataTypeDefinition
/// </summary>
private Opc.Ua.Export.DataTypeDefinition Export(
DataTypeState dataType,
ExtensionObject source,
NamespaceTable namespaceUris,
bool outputRedundantNames)
{
if (source == null || source.Body == null)
{
return(null);
}
DataTypeDefinition definition = new DataTypeDefinition();
if (outputRedundantNames || dataType.BrowseName != null)
{
definition.Name = Export(dataType.BrowseName, namespaceUris);
}
if (dataType.BrowseName.Name != dataType.SymbolicName)
{
definition.SymbolicName = dataType.SymbolicName;
}
switch (dataType.DataTypeModifier)
{
case DataTypeModifier.Union: { definition.IsUnion = true; break; }
case DataTypeModifier.OptionSet: { definition.IsOptionSet = true; break; }
}
StructureDefinition structureDefinition = source.Body as StructureDefinition;
if (structureDefinition != null)
{
if (structureDefinition.StructureType == StructureType.Union)
{
definition.IsUnion = true;
}
if (structureDefinition.Fields != null)
{
List <Opc.Ua.Export.DataTypeField> fields = new List <DataTypeField>();
for (int ii = structureDefinition.FirstExplicitFieldIndex; ii < structureDefinition.Fields.Count; ii++)
{
StructureField field = structureDefinition.Fields[ii];
Opc.Ua.Export.DataTypeField output = new Opc.Ua.Export.DataTypeField();
output.Name = field.Name;
output.Description = Export(new Opc.Ua.LocalizedText[] { field.Description });
output.IsOptional = field.IsOptional;
if (NodeId.IsNull(field.DataType))
{
output.DataType = Export(DataTypeIds.BaseDataType, namespaceUris);
}
else
{
output.DataType = Export(field.DataType, namespaceUris);
}
output.ValueRank = field.ValueRank;
fields.Add(output);
}
definition.Field = fields.ToArray();
}
}
EnumDefinition enumDefinition = source.Body as EnumDefinition;
if (enumDefinition != null)
{
if (enumDefinition.Fields != null)
{
List <Opc.Ua.Export.DataTypeField> fields = new List <DataTypeField>();
foreach (EnumField field in enumDefinition.Fields)
{
Opc.Ua.Export.DataTypeField output = new Opc.Ua.Export.DataTypeField();
output.Name = field.Name;
if (field.DisplayName != null && output.Name != field.DisplayName.Text)
{
output.DisplayName = Export(new Opc.Ua.LocalizedText[] { field.DisplayName });
}
else
{
output.DisplayName = new LocalizedText[0];
}
output.Description = Export(new Opc.Ua.LocalizedText[] { field.Description });
output.ValueRank = ValueRanks.Scalar;
output.Value = (int)field.Value;
fields.Add(output);
}
definition.Field = fields.ToArray();
}
}
return(definition);
}
internal InternalEnum(InternalTypeSystemProvider provider, EnumDefinition enumDefinition) :
this(provider, enumDefinition, false)
{
}
private bool IsClientModel(EnumDefinition classDefinition, string attributeTypeName)
{
return(classDefinition.Attributes.Any(a => a.ClassName.EndsWith(attributeTypeName)));
}
override public void OnEnumDefinition(EnumDefinition ed)
{
WriteTypeDefinition("enum", ed);
}
static IEnumerable <ClassDefinition> ReadClassDefinition(WrapperProject project,
XmlReader reader, HeaderDefinition header, ClassDefinition parent = null)
{
string className = reader.GetAttribute("Name");
ClassDefinition @class;
string classType = reader.Name;
switch (classType)
{
case "Class":
@class = new ClassDefinition(className, header, parent);
break;
case "ClassTemplate":
@class = new ClassTemplateDefinition(className, header, parent);
break;
case "Enum":
@class = new EnumDefinition(className, header, parent);
break;
default:
throw new NotImplementedException();
}
string namespaceName = reader.GetAttribute("Namespace");
if (namespaceName != null)
{
@class.NamespaceName = namespaceName;
}
if ("true".Equals(reader.GetAttribute("IsExcluded")))
{
@class.IsExcluded = true;
}
if ("true".Equals(reader.GetAttribute("HasPreventDelete")))
{
@class.HasPreventDelete = true;
}
if ("true".Equals(reader.GetAttribute("MarshalAsStruct")))
{
@class.MarshalAsStruct = true;
}
if (reader.IsEmptyElement)
{
yield return(@class);
yield break;
}
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "Class":
case "ClassTemplate":
case "Enum":
var classes = ReadClassDefinition(project, reader, header, @class);
foreach (var c in classes)
{
yield return(c);
}
break;
case "Method":
ReadMethodDefinition(reader, @class);
break;
case "TemplateParameter":
(@class as ClassTemplateDefinition).TemplateParameters
.Add(reader.ReadElementContentAsString());
break;
}
}
else if (reader.NodeType == XmlNodeType.EndElement)
{
break;
}
}
yield return(@class);
}
public override void LeaveEnumDefinition(EnumDefinition node)
{
this.SetPublicByDefault(node);
}
public virtual bool Visit(EnumDefinition node)
{
return(CommonVisit(node));
}
public virtual void EndVisit(EnumDefinition node)
{
CommonEndVisit(node);
}
private Dictionary <string, Executable> CreateFullyQualifiedLookup(IList <Executable> code)
{
HashSet <string> namespaces = new HashSet <string>();
Dictionary <string, Executable> lookup = new Dictionary <string, Executable>();
bool mainFound = false;
foreach (Executable item in code)
{
string ns;
string memberName;
if (item is FunctionDefinition)
{
FunctionDefinition fd = (FunctionDefinition)item;
ns = fd.Namespace;
memberName = fd.NameToken.Value;
if (memberName == "main")
{
if (mainFound)
{
throw new ParserException(item.FirstToken, "Multiple main methods found.");
}
mainFound = true;
lookup["~"] = item;
}
}
else if (item is ClassDefinition)
{
ClassDefinition cd = (ClassDefinition)item;
ns = cd.Namespace;
memberName = cd.NameToken.Value;
// TODO: nested classes, constants, and enums.
}
else if (item is EnumDefinition)
{
EnumDefinition ed = (EnumDefinition)item;
ns = ed.Namespace;
memberName = ed.Name;
}
else if (item is ConstStatement)
{
ConstStatement cs = (ConstStatement)item;
ns = cs.Namespace;
memberName = cs.Name;
}
else
{
string error = "This sort of expression cannot exist outside of function or field definitions.";
if (item is Assignment)
{
error += " Did you mean to mark this as a const expression?";
}
throw new ParserException(item.FirstToken, error);
}
if (ns.Length > 0)
{
string accumulator = "";
foreach (string nsPart in ns.Split('.'))
{
if (accumulator.Length > 0)
{
accumulator += ".";
}
accumulator += nsPart;
namespaces.Add(accumulator);
}
}
string fullyQualifiedName = (ns.Length > 0 ? (ns + ".") : "") + memberName;
lookup[fullyQualifiedName] = item;
}
foreach (string key in lookup.Keys)
{
if (namespaces.Contains(key))
{
throw new ParserException(lookup[key].FirstToken, "This name collides with a namespace definition.");
}
}
// Go through and fill in all the partially qualified namespace names.
foreach (string ns in namespaces)
{
lookup[ns] = new Namespace(null, ns, null);
}
if (lookup.ContainsKey("~"))
{
FunctionDefinition mainFunc = (FunctionDefinition)lookup["~"];
if (mainFunc.ArgNames.Length > 1)
{
throw new ParserException(mainFunc.FirstToken, "The main function must accept 0 or 1 arguments.");
}
}
else
{
throw new Exception("No main(args) function was defined.");
}
return(lookup);
}
public virtual TResult VisitEnumDefinition(EnumDefinition node)
{
return(DefaultVisit(node));
}
protected virtual void ExitEnumDefinition(TContext context, EnumDefinition enumDefinition)
{
}
override public void LeaveEnumDefinition(EnumDefinition node)
{
LeaveTypeDefinition(node);
}
override public void LeaveEnumDefinition(EnumDefinition node)
{
CheckName(node, node.Name);
}
/// <summary>
/// Imports a DataTypeDefinition
/// </summary>
private Opc.Ua.DataTypeDefinition Import(UADataType dataType, Opc.Ua.Export.DataTypeDefinition source, NamespaceTable namespaceUris)
{
if (source == null)
{
return(null);
}
Opc.Ua.DataTypeDefinition definition = null;
if (source.Field != null)
{
// check if definition is for enumeration or structure.
bool isStructure = Array.Exists <DataTypeField>(source.Field, delegate(DataTypeField fieldLookup)
{
return(fieldLookup.Value == -1);
});
if (isStructure)
{
StructureDefinition structureDefinition = new StructureDefinition();
structureDefinition.BaseDataType = ImportNodeId(source.BaseType, namespaceUris, true);
if (source.IsUnion)
{
structureDefinition.StructureType = StructureType.Union;
}
if (source.Field != null)
{
List <StructureField> fields = new List <StructureField>();
foreach (DataTypeField field in source.Field)
{
if (field.IsOptional)
{
structureDefinition.StructureType = StructureType.StructureWithOptionalFields;
}
StructureField output = new StructureField();
output.Name = field.Name;
output.Description = Import(field.Description);
output.DataType = ImportNodeId(field.DataType, namespaceUris, true);
output.ValueRank = field.ValueRank;
output.IsOptional = field.IsOptional;
fields.Add(output);
}
structureDefinition.Fields = fields.ToArray();
}
definition = structureDefinition;
}
else
{
EnumDefinition enumDefinition = new EnumDefinition();
if (source.Field != null)
{
List <EnumField> fields = new List <EnumField>();
foreach (DataTypeField field in source.Field)
{
EnumField output = new EnumField();
output.Name = field.Name;
output.DisplayName = Import(field.DisplayName);
output.Description = Import(field.Description);
output.Value = field.Value;
fields.Add(output);
}
enumDefinition.Fields = fields.ToArray();
}
definition = enumDefinition;
}
}
return(definition);
}
public override void OnEnumDefinition(EnumDefinition node)
{
// ignore
}
/// <summary>
/// Generate enum file.
/// </summary>
/// <param name="inputJsonText">Input json text to generate the enum from</param>
/// <param name="outputPath">Path where to save the generated enum to</param>
/// <param name="outputType">Type of output to produce</param>
/// <param name="collectionJPath">JPath to the collection in the input file</param>
/// <param name="entryNameJPath">
/// JPath to the name field in an entry in the input file</param>
/// <param name="entryValueJPath">
/// Optional JPath to the value field in an entry in the input file.
/// </param>
/// <param name="entryCommentJPath">
/// Optional JPath to the comment field in an entry in the input file.
/// </param>
/// <param name="enumComment">
/// Optional comment to add to the generated enum.
/// </param>
/// <param name="enumNamespace">
/// Optional namespace to add the generated enum to.
/// </param>
/// <param name="headerMode">Mode to use when adding a header</param>
/// <param name="indentMode">Mode to use when indenting text</param>
/// <param name="indentSize">When indenting with spaces this controls how many</param>
/// <param name="newlineMode">Mode to use when adding newlines to text</param>
/// <param name="storageType">Storage type for the exported enum</param>
/// <param name="curlyBracketMode">Mode to use when writing curly-brackets</param>
/// <param name="logger">Optional logger for diagnostic output</param>
public static void GenerateEnumToFile(
string inputJsonText,
string outputPath,
OutputType outputType,
string collectionJPath,
string entryNameJPath,
string entryValueJPath,
string entryCommentJPath,
string enumComment,
string enumNamespace,
HeaderMode headerMode,
CodeBuilder.IndentMode indentMode,
int indentSize,
CodeBuilder.NewlineMode newlineMode,
StorageType storageType,
CurlyBracketMode curlyBracketMode,
ILogger logger = null)
{
// Generate enum name.
var enumName = GetEnumName(outputPath, logger);
if (enumName == null)
{
return;
}
// Create mapping context.
var context = Context.Create(
collectionJPath,
entryNameJPath,
entryValueJPath,
entryCommentJPath,
logger);
// Map enum.
EnumDefinition enumDefinition = null;
try
{
enumDefinition = context.MapEnum(inputJsonText, enumName, enumComment);
}
catch (JsonParsingFailureException)
{
logger?.LogCritical("Failed to parse input file: invalid json");
return;
}
catch (MappingFailureException e)
{
logger?.LogCritical($"Failed to map enum: {e.InnerException.Message}");
return;
}
// Export.
byte[] output = null;
switch (outputType)
{
case OutputType.CSharp:
try
{
output = Utf8NoBom.GetBytes(enumDefinition.ExportCSharp(
enumNamespace,
headerMode,
indentMode,
indentSize,
newlineMode,
storageType,
curlyBracketMode));
}
catch (Exception e)
{
logger?.LogCritical($"Failed to generate csharp: {e.Message}");
return;
}
break;
case OutputType.FSharp:
try
{
output = Utf8NoBom.GetBytes(enumDefinition.ExportFSharp(
string.IsNullOrEmpty(enumNamespace) ? "Generated" : enumNamespace,
headerMode,
indentSize,
newlineMode,
storageType));
}
catch (Exception e)
{
logger?.LogCritical($"Failed to generate fsharp: {e.Message}");
return;
}
break;
case OutputType.VisualBasic:
try
{
output = Utf8NoBom.GetBytes(enumDefinition.ExportVisualBasic(
enumNamespace,
headerMode,
indentMode,
indentSize,
newlineMode,
storageType));
}
catch (Exception e)
{
logger?.LogCritical($"Failed to generate visual-basic: {e.Message}");
return;
}
break;
case OutputType.Cil:
try
{
output = Utf8NoBom.GetBytes(enumDefinition.ExportCil(
assemblyName: enumName,
enumNamespace,
headerMode,
indentMode,
indentSize,
newlineMode,
storageType,
curlyBracketMode));
}
catch (Exception e)
{
logger?.LogCritical($"Failed to generate cil: {e.Message}");
return;
}
break;
case OutputType.ClassLibrary:
try
{
output = enumDefinition.ExportClassLibrary(
assemblyName: enumName,
enumNamespace,
storageType);
}
catch (Exception e)
{
logger?.LogCritical($"Failed to generate classlibrary: {e.Message}");
return;
}
break;
}
// Write the file.
try
{
var fullPath = Path.Combine(UnityEngine.Application.dataPath, outputPath);
if (!fullPath.EndsWith(GetRequiredExtension(outputType), StringComparison.OrdinalIgnoreCase))
{
fullPath = $"{fullPath}{GetDesiredExtension(outputType)}";
}
var outputDir = Path.GetDirectoryName(fullPath);
if (!Directory.Exists(outputDir))
{
logger?.LogDebug($"Creating output directory: '{outputDir}'");
Directory.CreateDirectory(outputDir);
}
File.WriteAllBytes(fullPath, output);
logger?.LogInformation($"Saved enum: '{fullPath}'");
}
catch (Exception e)
{
logger?.LogCritical($"Failed to save enum: {e.Message}");
}
}
/// <summary>
/// Create fsharp source-code representation of a <see cref="EnumDefinition"/>.
/// </summary>
/// <exception cref="Exceptions.InvalidNamespaceException">
/// Thrown when a invalid namespace identifier is given.
/// </exception>
/// <exception cref="Exceptions.OutOfBoundsValueException">
/// Thrown when enum value does not fit in given storage-type.
/// </exception>
/// <param name="enumDefinition">Enum to generate fsharp source-code for</param>
/// <param name="namespace">Namespace to add the enum to</param>
/// <param name="headerMode">Mode to use when adding a header</param>
/// <param name="indentSize">How many spaces should be used for indents</param>
/// <param name="newlineMode">Mode to use for ending lines</param>
/// <param name="storageType">Underlying enum storage-type to use</param>
/// <returns>String containing the genenerated fsharp sourcecode</returns>
public static string ExportFSharp(
this EnumDefinition enumDefinition,
string @namespace,
HeaderMode headerMode = HeaderMode.Default,
int indentSize = 4,
CodeBuilder.NewlineMode newlineMode = CodeBuilder.NewlineMode.Unix,
StorageType storageType = StorageType.Implicit)
{
if (enumDefinition == null)
{
throw new ArgumentNullException(nameof(enumDefinition));
}
if (!IdentifierValidator.ValidateNamespace(@namespace))
{
throw new InvalidNamespaceException(@namespace);
}
foreach (var oobEntry in enumDefinition.Entries.Where(e => !storageType.Validate(e.Value)))
{
throw new OutOfBoundsValueException(storageType, oobEntry.Value);
}
var builder = new CodeBuilder(CodeBuilder.IndentMode.Spaces, indentSize, newlineMode);
if (headerMode != HeaderMode.None)
{
builder.AddHeader();
builder.WriteEndLine();
}
// Add namespace.
builder.WriteLine($"namespace {@namespace}");
builder.WriteEndLine();
// Open System.CodeDom.Compiler (for the 'GeneratedCode' attribute)
builder.WriteLine("open System.CodeDom.Compiler");
builder.WriteEndLine();
// Add type comment.
if (!string.IsNullOrEmpty(enumDefinition.Comment))
{
builder.AddSummary(enumDefinition.Comment);
}
// Add enum definition.
var assemblyName = typeof(FSharpExporter).Assembly.GetName();
builder.WriteLine($"[<GeneratedCode(\"{assemblyName.Name}\", \"{assemblyName.Version}\")>]");
builder.WriteLine($"type {enumDefinition.Identifier} =");
// Add entries.
foreach (var entry in enumDefinition.Entries)
{
var literalSuffix = storageType == StorageType.Implicit ?
string.Empty :
storageType.GetFSharpLiteralSuffix();
builder.WriteLine($"| {entry.Name} = {entry.Value}{literalSuffix}", additionalIndent: 1);
}
return(builder.Build());
}
/// <summary>
/// Formats the header definitions, and adds a new class definition for each class entry.
/// </summary>
/// <param name="entireHeaderDefinitions">A header file as one string.</param>
public ClassGenerator(string entireHeaderDefinitions)
{
// Preprocess the definitions, removing line breaks and tabs.
string strippedHeaderFile = entireHeaderDefinitions.Replace("\t", "").Replace("\r", "");
// Split the header file based on where it defines a new class.
// Gets from the definition onwards until it hits another definition.
List <string> definitions = Regex.Split(strippedHeaderFile, @"(?=\/\/ Class)|(?=\/\/ Enum)|(?=\/\/ ScriptStruct)").ToList();
// First element is always empty.
definitions.RemoveAt(0);
List <string> classDefinitions = new List <string>();
List <string> enumDefinitions = new List <string>();
List <string> structDefinitions = new List <string>();
// Handle each definition.
foreach (string definition in definitions)
{
// Figure out which type of definition.
if (definition.Contains("// Class"))
{
classDefinitions.Add(definition);
}
else if (definition.Contains("// Enum"))
{
enumDefinitions.Add(definition);
}
else if (definition.Contains("// ScriptStruct"))
{
structDefinitions.Add(definition);
}
}
// Hold a reference to all classes that should be native.
List <string> nativeClasses = new List <string>();
// Create each class.
foreach (string definition in classDefinitions)
{
ClassDefinition newClass = new ClassDefinition(definition);
this.GeneratedDefinitions.Add(newClass);
// Update the list of native classes.
if (newClass.IsNative)
{
if (!nativeClasses.Contains(newClass.ParentClassName))
{
nativeClasses.Add(newClass.ParentClassName);
}
}
}
// Update each native class to be marked as native.
// Native classes must extend from native classes, but classes are only naturally marked native if they contain native properties.
// This can't be done above as there is no guarantee that the parent class will exist when the child is made.
foreach (string className in nativeClasses)
{
ClassDefinition nativeClass = this.GeneratedDefinitions.Find(predicateClass => predicateClass.Name == className);
// Could extend from a class that isn't in the header files given.
if (nativeClass != null)
{
Logger.Info("Setting class '" + className + "' to native.");
nativeClass.IsNative = true;
}
else
{
Logger.Warn("Attempted to set the class '" + className + "' to native, but no class with that name exists.");
}
}
// Add each enum to the correct class.
foreach (string definition in enumDefinitions)
{
EnumDefinition newEnum = new EnumDefinition(definition);
ClassDefinition parentClass = GeneratedDefinitions.Find(def => def.PackageName == newEnum.PackageName && def.ClassFileName == newEnum.ClassFileName);
// Create a new class if the parent doesn't exist.
if (parentClass == null)
{
Logger.Error("Parent class '" + newEnum.PackageName + "." + newEnum.ClassFileName + "' of enum '" + newEnum.Name + "' not found, setting as invalid.");
ClassDefinition invalidClass = new ClassDefinition(newEnum);
this.GeneratedDefinitions.Add(invalidClass);
}
else if (parentClass.ClassType == ClassDefinition.ClassTypes.Invalid)
{
Logger.Error("Parent class '" + newEnum.PackageName + "." + newEnum.ClassFileName + "' of enum '" + newEnum.Name + "' not found, setting as invalid.");
parentClass.Enums.Add(newEnum);
}
else
{
parentClass.Enums.Add(newEnum);
}
}
// Add each struct to the correct class.
foreach (string definition in structDefinitions)
{
StructDefinition newStruct = new StructDefinition(definition);
ClassDefinition parentClass = GeneratedDefinitions.Find(def => def.PackageName == newStruct.PackageName && def.ClassFileName == newStruct.ClassFileName);
// Create a new class if the parent doesn't exist.
if (parentClass == null)
{
Logger.Error("Parent class '" + newStruct.PackageName + "." + newStruct.ClassFileName + "' of struct '" + newStruct.Name + "' not found, setting as invalid.");
ClassDefinition invalidClass = new ClassDefinition(newStruct);
this.GeneratedDefinitions.Add(invalidClass);
}
else if (parentClass.ClassType == ClassDefinition.ClassTypes.Invalid)
{
Logger.Error("Parent class '" + newStruct.PackageName + "." + newStruct.ClassFileName + "' of struct '" + newStruct.Name + "' not found, setting as invalid.");
parentClass.Structs.Add(newStruct);
}
else
{
parentClass.Structs.Add(newStruct);
}
}
// Check each class and set the extension class to native if the class is native. (Native classes can only extend native classes).
foreach (ClassDefinition definition in this.GeneratedDefinitions)
{
if (definition.IsNative)
{
}
}
}
override public void OnEnumDefinition(EnumDefinition node)
{
VisitTypeDefinition(node);
}
public void Docstrings()
{
/*
* """
* A module can have a docstring.
* """
* namespace Foo.Bar
* """
* And so can the namespace declaration.
* """
*
* class Person:
* """
* A class can have it.
* With multiple lines.
* """
* _fname as string
* """Fields can have one."""
*
* def constructor([required] fname as string):
* """
* And so can a method or constructor.
* """
* _fname = fname
*
* FirstName as string:
* """And why couldn't a property?"""
* get:
* return _fname
* interface ICustomer:
* """an interface."""
*
* def Initialize()
* """interface method"""
*
* Name as string:
* """interface property"""
* get
*
* enum AnEnum:
* """and so can an enum"""
* AnItem
* """and its items"""
* AnotherItem
*/
Boo.Lang.Compiler.Ast.Module module = ParseTestCase("docstrings_1.boo");
Assert.AreEqual("A module can have a docstring.", module.Documentation);
Assert.AreEqual("And so can the namespace declaration.", module.Namespace.Documentation);
ClassDefinition person = (ClassDefinition)module.Members[0];
Assert.AreEqual("A class can have it.\nWith multiple lines.", person.Documentation);
Assert.AreEqual("Fields can have one.", person.Members[0].Documentation);
Assert.AreEqual("\tAnd so can a method or constructor.\n\t", person.Members[1].Documentation);
Assert.AreEqual("And why couldn't a property?", person.Members[2].Documentation);
InterfaceDefinition customer = (InterfaceDefinition)module.Members[1];
Assert.AreEqual("an interface.", customer.Documentation);
Assert.AreEqual("interface method", customer.Members[0].Documentation);
Assert.AreEqual("interface property", customer.Members[1].Documentation);
EnumDefinition anEnum = (EnumDefinition)module.Members[2];
Assert.AreEqual("and so can an enum", anEnum.Documentation);
Assert.AreEqual("and its items", anEnum.Members[0].Documentation);
}
static void ReadClassDefinition(WrapperProject project, XmlReader reader, HeaderDefinition header, ClassDefinition parent = null)
{
string className = reader.GetAttribute("Name");
ClassDefinition @class;
string classType = reader.Name;
switch (classType)
{
case "Class":
@class = new ClassDefinition(className, header, parent);
break;
case "ClassTemplate":
@class = new ClassTemplateDefinition(className, header, parent);
break;
case "Enum":
@class = new EnumDefinition(className, header, parent);
break;
default:
throw new NotImplementedException();
}
string namespaceName = reader.GetAttribute("Namespace");
if (namespaceName != null)
{
@class.NamespaceName = namespaceName;
}
if ("true".Equals(reader.GetAttribute("IsExcluded")))
{
@class.IsExcluded = true;
}
if ("true".Equals(reader.GetAttribute("HasPreventDelete")))
{
@class.HasPreventDelete = true;
}
project.ClassDefinitions.Add(@class.FullyQualifiedName, @class);
if (reader.IsEmptyElement)
{
return;
}
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "Class":
case "ClassTemplate":
case "Enum":
{
ReadClassDefinition(project, reader, header, @class);
}
break;
case "Method":
{
ReadMethodDefinition(reader, @class);
}
break;
}
}
else if (reader.NodeType == XmlNodeType.EndElement)
{
break;
}
}
}
public EnumDefinition Transform(EnumDefinition other)
{
return(_doTransform(other));
}
public override void OnEnumDefinition(EnumDefinition node)
{
EnterNamespace((INamespace)GetEntity(node));
VisitTypeDefinitionBody(node);
LeaveNamespace();
}
override public void OnEnumDefinition(EnumDefinition node)
{
}
public static EnumDefinition WithDescription(this EnumDefinition definition,
in StringValue?description)
private Dictionary <string, TopLevelConstruct> CreateFullyQualifiedLookup(IList <TopLevelConstruct> code)
{
using (new PerformanceSection(""))
{
HashSet <string> namespaces = new HashSet <string>();
Dictionary <string, TopLevelConstruct> lookup = new Dictionary <string, TopLevelConstruct>();
bool mainFound = false;
foreach (TopLevelConstruct item in code)
{
string ns;
string memberName;
if (item is FunctionDefinition)
{
FunctionDefinition fd = (FunctionDefinition)item;
ns = fd.Namespace;
memberName = fd.NameToken.Value;
if (memberName == "main")
{
if (mainFound)
{
throw new ParserException(item.FirstToken, "Multiple main methods found.");
}
mainFound = true;
lookup["~"] = item;
}
}
else if (item is ClassDefinition)
{
ClassDefinition cd = (ClassDefinition)item;
ns = cd.Namespace;
memberName = cd.NameToken.Value;
// TODO: nested classes, constants, and enums.
}
else if (item is EnumDefinition)
{
EnumDefinition ed = (EnumDefinition)item;
ns = ed.Namespace;
memberName = ed.Name;
}
else if (item is ConstStatement)
{
ConstStatement cs = (ConstStatement)item;
ns = cs.Namespace;
memberName = cs.Name;
}
else
{
string error = "This sort of expression cannot exist outside of function or field definitions.";
throw new ParserException(item.FirstToken, error);
}
if (ns.Length > 0)
{
string accumulator = "";
foreach (string nsPart in ns.Split('.'))
{
if (accumulator.Length > 0)
{
accumulator += ".";
}
accumulator += nsPart;
namespaces.Add(accumulator);
}
}
string fullyQualifiedName = (ns.Length > 0 ? (ns + ".") : "") + memberName;
if (lookup.ContainsKey(fullyQualifiedName))
{
// TODO: token information from two locations
throw new ParserException(item.FirstToken, "Two items have identical fully-qualified names: '" + fullyQualifiedName + "'");
}
lookup[fullyQualifiedName] = item;
}
foreach (string key in lookup.Keys)
{
if (namespaces.Contains(key))
{
throw new ParserException(lookup[key].FirstToken, "This name collides with a namespace definition.");
}
}
// Go through and fill in all the partially qualified namespace names.
foreach (string ns in namespaces)
{
Namespace nsInstance = new Namespace(null, ns, null, null, null);
string possibleLibraryName = ns.Split('.')[0];
TODO.EnglishLocaleAssumed();
Library library = this.parser.LibraryManager.GetLibraryFromName(possibleLibraryName);
if (library != null)
{
// TODO: once you get rid of this line, make the Library setter protected
nsInstance.Library = library;
}
lookup[ns] = nsInstance;
}
if (lookup.ContainsKey("~"))
{
FunctionDefinition mainFunc = (FunctionDefinition)lookup["~"];
if (mainFunc.ArgNames.Length > 1)
{
throw new ParserException(mainFunc.FirstToken, "The main function must accept 0 or 1 arguments.");
}
}
else
{
throw new InvalidOperationException("No main(args) function was defined.");
}
return(lookup);
}
}
public ServiceDefinition AddEnum(EnumDefinition @enum)
{
Entities.Add(@enum);
return this;
}
