/// <summary>
/// Creates a fake process that is used to create the connection
/// </summary>
/// <param name="state">The validation state to use</param>
/// <param name="scope">The active scope</param>
/// <param name="connEntry">The connection entry to create the process for</param>
/// <returns>A fake process instance</returns>
public static Instance.Process CreateConnectProcess(Validation.ValidationState state, Validation.ScopeState scope, AST.ConnectEntry connEntry)
{
var lhs = state.FindSymbol(connEntry.Source, scope) ?? throw new ParserException($"Could not resolve symbol {connEntry.Source.SourceToken}", connEntry.Source);
var rhs = state.FindSymbol(connEntry.Target, scope) ?? throw new ParserException($"Could not resolve symbol {connEntry.Target.SourceToken}", connEntry.Target);
if (lhs is Instance.Signal lhs_signal && rhs is Instance.Signal rhs_signal)
{
return(IdentityHelper.CreateIdentityProcess(
state,
scope,
connEntry.SourceToken,
// Extract the bus name locally
new Name(connEntry.Source.SourceToken, connEntry.Source.Identifier.SkipLast(1).ToArray(), null).AsExpression(),
new Name(connEntry.Target.SourceToken, connEntry.Target.Identifier.SkipLast(1).ToArray(), null).AsExpression(),
// Assign just the named entry
new[] { lhs_signal.Source },
// Ensure we use the same type to avoid silent type-casting
new[] {
new BusSignalDeclaration(connEntry.Target.SourceToken,
rhs_signal.Source.Name,
lhs_signal.Source.Type,
null,
AST.SignalDirection.Normal
)
},
Instance.ProcessType.Connect
));
}
/// <summary>
/// Creates all sub-instances for a process
/// </summary>
/// <param name="state">The state to use</param>
/// <param name="parent">The parent process</param>
private void CreateAndRegisterInstance(Validation.ValidationState state, Instance.Process parent)
{
var scope = state.CurrentScope;
CreateAndRegisterInstancesForDeclarations(state, parent.ProcessDefinition.Declarations, parent.Instances);
// TODO: The scope should work within the statement tree. We can have nested statements....
foreach (var loop in parent.Statements.All().OfType <AST.ForStatement>())
{
var l = new Instance.ForLoop(loop.Current);
using (var sc = state.StartScope(l, loop.Current)) {
var varinst = new Instance.Variable(loop.Current.Variable);
sc.TryAddSymbol(loop.Current.Variable.Name.Name, varinst, loop.Current.Variable.SourceToken);
}
parent.Instances.Add(l);
}
// Find all function invocations so we can map parameters
foreach (var func in parent.Statements.All().OfType <AST.FunctionStatement>())
{
var fdef = state.FindSymbol(func.Current.Name, scope);
if (fdef == null)
{
throw new ParserException($"No function named {func.Current.Name.AsString} found", func.Current);
}
if (!(fdef is AST.FunctionDefinition ffdef))
{
throw new ParserException($"Expected a function for {func.Current.Name.AsString}, but found {fdef.GetType()}", func.Current);
}
var f = new Instance.FunctionInvocation(ffdef, func.Current);
using (var sc = state.StartScope(f))
CreateAndRegisterInstancesForDeclarations(state, ffdef.Declarations, f.Instances);
parent.Instances.Add(f);
}
}
/// <summary>
/// Creates and registers all network declaration instances
/// </summary>
/// <param name="state">The state to use</param>
/// <param name="networkDecls">The network declarations to instantiate</param>
/// <param name="parentCollection"></param>
private void CreateAndRegisterInstances(Validation.ValidationState state, IEnumerable <NetworkDeclaration> networkDecls, IList <Instance.IInstance> parentCollection)
{
var scope = state.CurrentScope;
foreach (var decl in networkDecls)
{
if (decl is AST.BusDeclaration bus)
{
var b = new Instance.Bus(bus);
scope.TryAddSymbol(b.Name, b, bus.Name);
using (state.StartScope(b))
CreateAndRegisterInstance(state, b);
parentCollection.Add(b);
}
else if (decl is AST.ConstantDeclaration cdecl)
{
var cref = new Instance.ConstantReference(cdecl);
scope.TryAddSymbol(cref.Name, cref, cdecl.Name);
parentCollection.Add(cref);
continue;
}
else if (decl is AST.GeneratorDeclaration genDecl)
{
var startSymbol = state.ResolveToInteger(genDecl.SourceExpression, scope);
var finishSymbol = state.ResolveToInteger(genDecl.TargetExpression, scope);
// TODO: Need to fix array support for this to work correctly?
for (var i = startSymbol; i < finishSymbol; i++)
{
CreateAndRegisterInstances(state, genDecl.Networks, parentCollection);
}
}
else if (decl is AST.InstanceDeclaration instDecl)
{
var sym = state.FindSymbol(instDecl.SourceItem, scope);
if (sym != null && sym is AST.Network netw)
{
// Recursively create network
// TODO: Guard against infinite recursion
parentCollection.Add(CreateAndRegisterInstance(state, instDecl, netw));
}
else if (sym != null && sym is AST.Process proc)
{
var p = new Instance.Process(instDecl, proc, Instance.ProcessType.Normal);
if (instDecl.Name.Name != null)
{
scope.TryAddSymbol(instDecl.Name.Name.Name, p, instDecl.Name.Name);
}
using (state.StartScope(p, instDecl))
CreateAndRegisterInstance(state, p);
parentCollection.Add(p);
}
else
{
if (sym == null)
{
throw new ParserException($"No item found with the name {instDecl.SourceItem}", decl);
}
else
{
throw new ParserException($"The item {instDecl.SourceItem} is not a process, but a {sym.GetType().Name}", decl);
}
}
}
else if (decl is AST.ConnectDeclaration connDecl)
{
foreach (var connEntry in connDecl.Entries)
{
var p = IdentityHelper.CreateConnectProcess(state, scope, connEntry);
using (state.StartScope(p, connEntry))
CreateAndRegisterInstance(state, p);
parentCollection.Add(p);
}
}
else
{
throw new ParserException($"Attempted to create an instance of type: {decl.GetType()}", decl);
}
}
}