public void ClearTest()
{
//Fill list with one node
Module node1 = new Module();
nodes.Add(node1);
//Check if size is bigger than zero
Assert.AreEqual(1, nodes.Count);
//Clear list and check if zero elements in it
nodes.Clear();
Assert.AreEqual(0, nodes.Count);
}
public void GetElementsTest()
{
//Add elements to list and retrieve them and check if they are correct
Module node1 = new Module();
ModuleId node2 = new ModuleId();
nodes.Add(node1);
nodes.Add(node2);
ISyntaxNode[] list = nodes.GetElements();
Assert.IsTrue(list.Length == 2);
Assert.AreSame(node1, list[0]);
Assert.AreSame(node2, list[1]);
}
public override void Visit(Module module)
{
//Check filename
module.GetModuleId().AcceptVisitor(this);
//Get dependencies and check their existence
List<Module> DependencyList = ModuleCache.Instance.RequestDependencies(module);
foreach (Module moduleDependency in DependencyList)
{
foreach (Import import in moduleDependency.GetImports())
{ //Check imports of dependency's
import.AcceptVisitor(this);
ModuleCache.Instance.RequestModule(import.GetModuleId());
}
}
}
/// <summary>
/// Parse one module
/// </summary>
/// <param name="module">Module to parse</param>
public Module ParseModule()
{
Module module = new Module();
//Skip module token
NextToken("module", "module identifier", "module");
//Parse first the identifier of the module and set it
ModuleId moduleIdentifier = ParseModuleId();
module.SetModuleId(moduleIdentifier);
//Look for elements like SITE, DEF, etc
while (TokenStream.HasNext())
{
if (MatchValue(TokenStream.Peek(1).GetValue().ToString(), Waebric.WaebricKeyword.MODULE.ToString()))
{ //New module found, raise exception, only one module per file allowed
throw new UnexpectedToken("Unexpected token, found second module definition:", "module", TokenStream.Peek(1).GetLine());
}
CurrentToken = TokenStream.NextToken();
//Check for different elements which may appear in a module
if(MatchValue(CurrentToken.GetValue().ToString(), Waebric.WaebricKeyword.DEF.ToString()))
{ //Function definition found
module.AddFunctionDefinition(functionParser.ParseFunctionDefinition());
}
else if(MatchValue(CurrentToken.GetValue().ToString(), Waebric.WaebricKeyword.SITE.ToString()))
{ //Site definition found, call siteparser
module.AddSite(siteParser.ParseSite());
}
else if(MatchValue(CurrentToken.GetValue().ToString(), Waebric.WaebricKeyword.IMPORT.ToString()))
{ //Imports found
module.AddImport(ParseImport());
}
else
{
//Exception
throw new UnexpectedToken("Unexpected token found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine());
}
}
return module;
}
/// <summary>
/// Visit module and check declarations in module and dependency's
/// </summary>
/// <param name="module">Module to visit</param>
public override void Visit(Module module)
{
//Get dependency for module
List<Module> dependencyList = ModuleCache.Instance.RequestDependencies(module);
//Store all functiondefinitions
foreach (Module dependency in dependencyList)
{
foreach (FunctionDefinition functionDef in dependency.GetFunctionDefinitions())
{
//Check if function is not already defined
if (SymbolTable.ContainsFunction(functionDef.GetIdentifier()))
{
ExceptionList.Add(new FunctionAlreadyDefined(functionDef.GetIdentifier()));
}
else
{
SymbolTable.AddFunctionDefinition(functionDef);
}
}
}
//Check all definitions
foreach (Module dependency in dependencyList)
{
//Check FunctionDefinitions
foreach (FunctionDefinition function in dependency.GetFunctionDefinitions())
{
function.AcceptVisitor(this);
}
//Check markups in sites
foreach (Site site in dependency.GetSites())
{
foreach (Mapping mapping in site.GetMappings())
{
mapping.AcceptVisitor(this);
}
}
}
}
/// <summary>
/// Set root of tree
/// </summary>
/// <param name="rootNode">Node to set as root</param>
public void SetRoot(Module.Module rootNode)
{
this.root = rootNode;
}
/// <summary>
/// Constructor which fills root with specified rootNode
/// </summary>
/// <param name="rootNode">Node to set as root</param>
public SyntaxTree(Module.Module rootNode)
{
root = rootNode;
}
//All visit methods for all kind of NodeTypes
public virtual void Visit(Module.Module module)
{
VisitSubNodes(module);
}
//All visit methods for all kind of NodeTypes
public virtual void Visit(Module.Module module)
{
VisitSubNodes(module);
}
/// <summary>
/// Add an specific module to the modulecache
/// </summary>
/// <param name="module"></param>
public void AddModuleToCache(Module module)
{
ModuleTable.Add(module.GetModuleId().ToString(), module);
}
/// <summary>
/// Get dependencies of module and return a list of founded dependencies
/// </summary>
/// <param name="module">Module to get dependencies from</param>
/// <returns>List of dependencies</returns>
public List<Module> RequestDependencies(Module module)
{
List<Module> moduleList = new List<Module>();
RequestDependencies(module, moduleList);
return moduleList;
}
/// <summary>
/// Request dependencies of specified modules
/// </summary>
/// <param name="module"></param>
public void RequestDependencies(Module module, List<Module> list)
{
//Check if module is already in Table
if (!ContainsModule(list,module.GetModuleId().ToString()))
{
list.Add(module);
ISyntaxNode[] importArray = module.GetImports().ToArray();
foreach(Import import in importArray)
{
if (!ContainsModule(list, import.GetModuleId().ToString()))
{
//Get module
Module requestedDependency = RequestModule(import.GetModuleId());
if (requestedDependency != null)
{ //Not null, so add to list
//Get dependencies of retrieved module
RequestDependencies(requestedDependency, list);
}
}
}
}
}
/// <summary>
/// Set root of tree
/// </summary>
/// <param name="rootNode">Node to set as root</param>
public void SetRoot(Module.Module rootNode)
{
this.root = rootNode;
}
/// <summary>
/// Constructor which fills root with specified rootNode
/// </summary>
/// <param name="rootNode">Node to set as root</param>
public SyntaxTree(Module.Module rootNode)
{
root = rootNode;
}
public void GetTest()
{
//Add elements to list and retrieve them and check if they are correct
Module node1 = new Module();
ModuleId node2 = new ModuleId();
nodes.Add(node1);
nodes.Add(node2);
ISyntaxNode[] list = nodes.GetElements();
Assert.IsTrue(list.Length == 2);
//Test if get with index works
Assert.AreSame(nodes.Get(1), node2);
}
