/// <summary>
/// Loads the module and its imports
/// </summary>
/// <param name="file">The main module</param>
/// <param name="toplevel">The top-level network or null</param>
/// <returns>The state for the loaded modules</returns>
public static Validation.ValidationState LoadModuleAndImports(string file, string toplevel, string[] arguments)
{
// Basic setup
var state = new Validation.ValidationState();
var rootscope = state.CurrentScope;
var toResolve = new Stack <AST.Module>();
state.TopLevel.Module = LoadModule(file);
state.TopLevel.ModuleInstance = new Instance.Module(state.TopLevel.Module);
// Find the entry network
var networks = state.TopLevel.Module.Entities.OfType <AST.Network>().ToList();
if (string.IsNullOrWhiteSpace(toplevel))
{
if (networks.Count == 0)
{
throw new ArgumentException("The main module contains no networks?");
}
if (networks.Count != 1)
{
throw new ArgumentException($"The main module contains {networks.Count} networks, please specify a network name");
}
state.TopLevel.SourceNetwork = networks.First();
}
else
{
var namednetworks = networks.Where(x => string.Equals(x.Name.Name, toplevel, StringComparison.OrdinalIgnoreCase)).ToList();
if (networks.Count == 0)
{
throw new ArgumentException($"The main module contains no networks named \"{toplevel}\"");
}
if (networks.Count != 1)
{
throw new ArgumentException($"The main module contains {networks.Count} network named \"{toplevel}\"");
}
state.TopLevel.SourceNetwork = namednetworks.First();
}
// Wire up the top-level network parameters
var dummyparsetoken = new ParseToken(0, 0, 0, "__commandline__");
var name = new AST.Identifier(new ParseToken(0, 0, 0, "__main__"));
state.TopLevel.CommandlineArguments = arguments = arguments ?? new string[0];
state.Modules[file] = state.TopLevel.Module;
state.LocalScopes[state.TopLevel.Module] = rootscope;
// Recursively load and resolve imports
LoadImports(file, state, state.TopLevel.Module);
// Register the symbols from the main module in the root scope
state.RegisterSymbols(state.TopLevel.Module, rootscope);
// Check that all parameters in the top-level network are explicitly typed
var untypedparam = state.TopLevel.SourceNetwork.Parameters.FirstOrDefault(x => x.ExplictType == null);
if (untypedparam != null)
{
throw new ParserException("All parameters to the top-level network must have an explict type", untypedparam);
}
// Prepare for the parameters to the top-level network
var pmap = new AST.ParameterMap[state.TopLevel.SourceNetwork.Parameters.Length];
var externalargumentindex = 0;
for (var i = 0; i < pmap.Length; i++)
{
var p = state.TopLevel.SourceNetwork.Parameters[i];
var realtype = state.ResolveTypeName(p.ExplictType, rootscope);
if (realtype == null)
{
throw new ParserException($"Unable to find type: {p.ExplictType.SourceToken.Text}", p);
}
if (realtype.IsValue)
{
if (p.Direction == AST.ParameterDirection.Out)
{
throw new ParserException($"A value-type parameter cannot be sent as output: {p.Name}", p);
}
if (externalargumentindex >= state.TopLevel.CommandlineArguments.Length)
{
throw new ParserException($"No value provided for the parameter {p.Name} in the commandline inputs", p);
}
var argtext = state.TopLevel.CommandlineArguments[externalargumentindex++];
var literal = ParseAsLiteral(argtext);
var littype = new AST.DataType(new ParseToken(0, 0, 0, argtext), literal.Value.Type, -1);
if (!state.CanTypeCast(littype, realtype, rootscope))
{
throw new ParserException($"Parsed {argtext} to {littype} but cannot interpret as {realtype} which is required for parameter {p.Name}", p);
}
pmap[i] = new AST.ParameterMap(p.SourceToken, p.Name, literal);
rootscope.TryAddSymbol(p.Name.Name, literal, p.Name);
}
else if (realtype.IsBus)
{
var typedef = (AST.TypeDefinition)state.FindTypeDefinition(p.ExplictType.Alias, rootscope);
// Create a new bus as a stand-in for the input or output
var newbus = new Instance.Bus(
new AST.BusDeclaration(
dummyparsetoken,
p.Name,
realtype
.Shape
.Signals
.Select(x =>
new AST.BusSignalDeclaration(
dummyparsetoken,
new AST.Identifier(new ParseToken(0, 0, 0, x.Key)),
x.Value.Type,
typedef.Initializers[x.Key],
x.Value.Direction
)
).ToArray(),
null
)
);
newbus.Instances.AddRange(
newbus
.Source
.Signals
.Select(x =>
new Instance.Signal(newbus, x)
{
ResolvedType = state.ResolveTypeName(x.Type, rootscope)
}
)
);
newbus.ResolvedSignalTypes =
newbus
.Instances
.OfType <Instance.Signal>()
.ToDictionary(x => x.Name, x => x.ResolvedType);
if (p.Direction == AST.ParameterDirection.Out)
{
state.TopLevel.OutputBusses.Add(newbus);
}
else if (p.Direction == AST.ParameterDirection.In)
{
state.TopLevel.InputBusses.Add(newbus);
}
else
{
throw new ParserException($"Cannot use a top-level bus with direction {p.Direction}", p);
}
pmap[i] = new AST.ParameterMap(p.SourceToken, p.Name, AST.EnumerationExtensions.AsExpression(p.Name));
rootscope.TryAddSymbol(p.Name.Name, newbus, p.Name);
// Register signals
using (var sc = state.StartScope(newbus))
foreach (var s in newbus.Instances.OfType <Instance.Signal>())
{
sc.TryAddSymbol(s.Name, s, s.Source);
}
state.TopLevel.ModuleInstance.Instances.Add(newbus);
}
else
{
throw new ParserException($"Unexpected type: {realtype}", p);
}
}
// Check that we have at least one output bus
if (state.TopLevel.OutputBusses.Count == 0)
{
throw new ParserException("The top-level network must have at least one output bus", state.TopLevel.SourceNetwork);
}
if (state.TopLevel.CommandlineArguments.Length > externalargumentindex)
{
throw new ParserException($"Too many arguments on commandline, expected {externalargumentindex} but got {state.TopLevel.CommandlineArguments.Length}", state.TopLevel.SourceNetwork);
}
state.TopLevel.NetworkDeclaration = new AST.InstanceDeclaration(
dummyparsetoken,
new AST.InstanceName(dummyparsetoken, name, null),
name,
pmap
);
state.TopLevel.NetworkInstance = new Instance.Network(
state.TopLevel.NetworkDeclaration,
state.TopLevel.SourceNetwork
);
return(state);
}
/// <summary>
/// Performs the type assignment to a process instance
/// </summary>
/// <param name="state">The validation state to use</param>
/// <param name="instance">The process instance to use</param>
private static void AssignProcessTypes(ValidationState state, Instance.IInstance parent, AST.Statement[] statements, Dictionary <Expression, DataType> assignedTypes)
{
// Get the scope for the intance
var defaultScope = state.LocalScopes[parent];
// Extra expression that needs examining
var extras = new AST.Expression[0].AsEnumerable();
if (parent is Instance.IDeclarationContainer pdecl1)
{
extras = extras.Concat(
pdecl1.Declarations
// Functions are handled elsewhere and have their own scopes
.Where(x => !(x is AST.FunctionDefinition))
.SelectMany(
x => x.All().OfType <AST.Expression>().Select(y => y.Current)
)
);
}
if (parent is Instance.IParameterizedInstance pp)
{
extras = extras.Concat(
pp.MappedParameters
.Select(x => x.MappedItem)
.OfType <Instance.Bus>()
.SelectMany(x => x.Instances
.OfType <Instance.Signal>()
.Select(y => y.Source.Initializer)
.Where(y => y != null)
)
);
}
if (parent is Instance.IChildContainer ck)
{
extras = extras.Concat(
ck.Instances
.OfType <Instance.Bus>()
.SelectMany(x => x.Instances
.OfType <Instance.Signal>()
.Select(y => y.Source.Initializer)
.Where(y => y != null)
)
);
}
// List of statement expressions to examine for literal/constant type items
var allExpressions = statements
.All()
.OfType <AST.Expression>()
.Select(x => new { Item = x.Current, Scope = state.TryFindScopeForItem(x) ?? defaultScope })
.Concat(extras.Select(x => new { Item = x, Scope = defaultScope }))
.Concat(
extras
.SelectMany(x => x.All().OfType <AST.Expression>().Select(y => y.Current))
.Select(x => new { Item = x, Scope = defaultScope })
)
.ToArray()
.AsEnumerable();
// We use multiple iterations to assign types
// The first iteration assigns types to all literal, bus, signal and variable expressions
foreach (var nn in allExpressions)
{
var item = nn.Item;
var scope = nn.Scope;
// Skip duplicate assignments
if (assignedTypes.ContainsKey(item))
{
continue;
}
if (item is AST.LiteralExpression literal)
{
if (literal.Value is AST.BooleanConstant)
{
assignedTypes[literal] = new AST.DataType(literal.SourceToken, ILType.Bool, 1);
}
else if (literal.Value is AST.IntegerConstant)
{
assignedTypes[literal] = new AST.DataType(literal.SourceToken, ILType.SignedInteger, -1);
}
else if (literal.Value is AST.FloatingConstant)
{
assignedTypes[literal] = new AST.DataType(literal.SourceToken, ILType.Float, -1);
}
}
else if (item is AST.NameExpression name)
{
var symbol = state.FindSymbol(name.Name, scope);
var dt = FindDataType(state, name, scope);
if (dt != null)
{
if (name.Name.Index.LastOrDefault() != null && dt.IsArray)
{
assignedTypes[name] = dt.ElementType;
}
else
{
assignedTypes[name] = dt;
}
if (parent is Instance.IParameterizedInstance ip)
{
state.RegisterItemUsageDirection(ip, symbol, ItemUsageDirection.Read, item);
}
}
}
}
// Handle variables not used in normal expressions
foreach (var item in statements.All().Select(x => x.Current))
{
var scope = defaultScope;
if (item is AST.AssignmentStatement assignmentStatement)
{
var symbol = state.FindSymbol(assignmentStatement.Name, scope);
if (symbol is Instance.Variable var)
{
if (var.ResolvedType == null)
{
var.ResolvedType = state.ResolveTypeName(var.Source.Type, scope);
}
}
else if (symbol is Instance.Signal sig)
{
if (sig.ResolvedType == null)
{
sig.ResolvedType = state.ResolveTypeName(sig.Source.Type, scope);
}
}
else if (symbol == null)
{
throw new ParserException($"Symbol not found: \"{assignmentStatement.Name.AsString}\"", assignmentStatement.Name.SourceToken);
}
else
{
throw new ParserException($"Can only assign to signal or variable, {assignmentStatement.Name.AsString} is {symbol.GetType().Name}", assignmentStatement.Name.SourceToken);
}
}
else if (item is AST.ForStatement forStatement)
{
var forScope = state.LocalScopes[forStatement];
var symbol = state.FindSymbol(forStatement.Variable.Name, forScope);
if (symbol is Instance.Variable var)
{
if (var.ResolvedType == null)
{
var.ResolvedType = state.ResolveTypeName(var.Source.Type, scope);
}
}
else if (symbol == null)
{
throw new ParserException($"Symbol not found: \"{forStatement.Variable.Name}\"", forStatement.Variable.SourceToken);
}
else
{
throw new ParserException($"Can only use variable as the counter in a for loop, {forStatement.Variable.Name} is {symbol.GetType().Name}", forStatement.Variable.SourceToken);
}
}
}
allExpressions = statements
.All(AST.TraverseOrder.DepthFirstPostOrder)
.OfType <AST.Expression>()
.Select(x => new { Item = x.Current, Scope = state.TryFindScopeForItem(x) ?? defaultScope })
.Concat(
extras
.SelectMany(x => x.All(AST.TraverseOrder.DepthFirstPostOrder).OfType <AST.Expression>().Select(y => y.Current))
.Select(x => new { Item = x, Scope = defaultScope })
)
.Concat(extras.Select(x => new { Item = x, Scope = defaultScope }));
// We are only concerned with expressions, working from leafs and up
// At this point all literals, variables, signals, etc. should have a resolved type
foreach (var nn in allExpressions)
{
var item = nn.Item;
var scope = nn.Scope;
// Skip duplicate assignments
if (assignedTypes.ContainsKey(item))
{
continue;
}
if (item is AST.UnaryExpression unaryExpression)
{
var sourceType = assignedTypes[unaryExpression.Expression];
switch (unaryExpression.Operation.Operation)
{
case AST.UnaryOperation.UnOp.LogicalNegation:
if (!sourceType.IsBoolean)
{
throw new ParserException($"Cannot perform {unaryExpression.Operation.Operation} on {sourceType}", unaryExpression);
}
break;
case AST.UnaryOperation.UnOp.Identity:
case AST.UnaryOperation.UnOp.Negation:
if (!sourceType.IsNumeric)
{
throw new ParserException($"Cannot perform {unaryExpression.Operation.Operation} on {sourceType}", unaryExpression);
}
break;
case AST.UnaryOperation.UnOp.BitwiseInvert:
if (!sourceType.IsInteger)
{
throw new ParserException($"Cannot perform {unaryExpression.Operation.Operation} on {sourceType}", unaryExpression);
}
break;
default:
throw new ParserException($"Unsupported unary operation: {unaryExpression.Operation.Operation}", unaryExpression);
}
// Unary operations do not change the type
assignedTypes[item] = sourceType;
}
else if (item is AST.BinaryExpression binaryExpression)
{
var leftType = assignedTypes[binaryExpression.Left];
var rightType = assignedTypes[binaryExpression.Right];
// If we have a numerical operation, verify that the operands are numeric
if (binaryExpression.Operation.IsNumericOperation)
{
if (!leftType.IsNumeric)
{
throw new ParserException($"The operand {binaryExpression.Left} must be numerical to be used with {binaryExpression.Operation.Operation}", binaryExpression.Left);
}
if (!rightType.IsNumeric)
{
throw new ParserException($"The operand {binaryExpression.Right} must be numerical to be used with {binaryExpression.Operation.Operation}", binaryExpression.Right);
}
}
// If we have a logical operation, verify that the operands are boolean
if (binaryExpression.Operation.IsLogicalOperation)
{
if (!leftType.IsBoolean)
{
throw new ParserException($"The operand {binaryExpression.Left} must be boolean to be used with {binaryExpression.Operation.Operation}", binaryExpression.Left);
}
if (!rightType.IsBoolean)
{
throw new ParserException($"The operand {binaryExpression.Right} must be boolean to be used with {binaryExpression.Operation.Operation}", binaryExpression.Right);
}
}
// If we are doing a compare operation, verify that the types can be compared
if (binaryExpression.Operation.IsEqualityOperation)
{
if (!state.CanEqualityCompare(leftType, rightType, scope))
{
throw new ParserException($"Cannot perform boolean operation {binaryExpression.Operation.Operation} on types {leftType} and {rightType}", binaryExpression);
}
}
// Special handling of bitshift, where the type of the shift count does not change they type on the input
if (binaryExpression.Operation.Operation == BinOp.ShiftLeft || binaryExpression.Operation.Operation == BinOp.ShiftRight)
{
if (!leftType.IsInteger)
{
throw new ParserException($"The value being shifted must be an integer type but has type {leftType}", binaryExpression.Left);
}
if (!rightType.IsInteger)
{
throw new ParserException($"The shift operand must be an integer type but has type {rightType}", binaryExpression.Right);
}
assignedTypes[binaryExpression] = leftType;
}
else
{
// Make sure we can unify the types
if (!state.CanUnifyTypes(leftType, rightType, scope))
{
throw new ParserException($"The types types {leftType} and {rightType} cannot be unified for use with the operation {binaryExpression.Operation.Operation}", binaryExpression);
}
// Compute the unified type
var unified = state.UnifiedType(leftType, rightType, scope);
// If the source operands do not have the unified types, inject an implicit type-cast
if (!object.Equals(leftType, unified))
{
assignedTypes[binaryExpression.Left = new AST.TypeCast(binaryExpression.Left, unified, false)] = unified;
}
if (!object.Equals(rightType, unified))
{
assignedTypes[binaryExpression.Right = new AST.TypeCast(binaryExpression.Right, unified, false)] = unified;
}
// Assign the type to this operation
switch (binaryExpression.Operation.Operation)
{
// These operations just use the unified type
case BinOp.Add:
case BinOp.Subtract:
case BinOp.Multiply:
case BinOp.Divide:
case BinOp.Modulo:
case BinOp.BitwiseAnd:
case BinOp.BitwiseOr:
case BinOp.BitwiseXor:
assignedTypes[binaryExpression] = unified;
break;
// These operations return a boolean result
case BinOp.Equal:
case BinOp.NotEqual:
case BinOp.LessThan:
case BinOp.LessThanOrEqual:
case BinOp.GreaterThan:
case BinOp.GreaterThanOrEqual:
case BinOp.LogicalAnd:
case BinOp.LogicalOr:
assignedTypes[binaryExpression] = new AST.DataType(binaryExpression.SourceToken, ILType.Bool, 1);
break;
default:
throw new ParserException($"Unable to handle operation: {binaryExpression.Operation.Operation}", binaryExpression);
}
}
}
else if (item is AST.TypeCast typecastExpression)
{
// Implicit typecasts are made by the parser so we do not validate those
if (!typecastExpression.Explicit)
{
continue;
}
var sourceType = assignedTypes[typecastExpression.Expression];
var targetType = state.ResolveTypeName(typecastExpression.TargetName, scope);
if (!state.CanTypeCast(sourceType, targetType, scope))
{
throw new ParserException($"Cannot cast from {sourceType} to {typecastExpression.TargetName}", typecastExpression);
}
assignedTypes[typecastExpression] = targetType;
}
// Carry parenthesis expression types
else if (item is AST.ParenthesizedExpression parenthesizedExpression)
{
assignedTypes[item] = assignedTypes[parenthesizedExpression.Expression];
}
}
// Then make sure we have assigned all targets
foreach (var item in statements.All().OfType <AST.Statement>().Select(x => x.Current))
{
var scope = defaultScope;
if (item is AST.AssignmentStatement assignmentStatement)
{
var symbol = state.FindSymbol(assignmentStatement.Name, scope);
var exprType = assignedTypes[assignmentStatement.Value];
DataType targetType;
if (symbol is Instance.Variable variableInstance)
{
targetType = state.ResolveTypeName(variableInstance.Source.Type, scope);
}
else if (symbol is Instance.Signal signalInstance)
{
targetType = state.ResolveTypeName(signalInstance.Source.Type, scope);
}
else
{
throw new ParserException($"Assignment must be to a variable or a signal", item);
}
if (targetType.IsArray && assignmentStatement.Name.Index?.LastOrDefault() != null)
{
targetType = targetType.ElementType;
}
if (!state.CanUnifyTypes(targetType, exprType, scope))
{
throw new ParserException($"Cannot assign \"{assignmentStatement.Value.SourceToken.Text}\" (with type {exprType}) to {assignmentStatement.Name.SourceToken} (with type {targetType})", item);
}
//var unified = state.UnifiedType(targetType, exprType, scope);
// Force the right-hand side to be the type we are assigning to
if (!object.Equals(exprType, targetType))
{
// Make sure we do not loose bits with implicit typecasting
if (exprType.BitWidth > targetType.BitWidth && targetType.BitWidth > 0)
{
throw new ParserException($"Assignment would loose precision from {exprType.BitWidth} bits to {targetType.BitWidth}", item);
}
assignedTypes[assignmentStatement.Value = new AST.TypeCast(assignmentStatement.Value, targetType, false)] = targetType;
}
if (parent is Instance.IParameterizedInstance ip)
{
state.RegisterItemUsageDirection(ip, symbol, ItemUsageDirection.Write, item);
}
}
else if (item is AST.ForStatement forStatement)
{
var fromType = assignedTypes[forStatement.FromExpression];
var toType = assignedTypes[forStatement.ToExpression];
if (!fromType.IsInteger)
{
throw new ParserException("The from/to arguments in a for loop must be integer types", forStatement.FromExpression);
}
if (!toType.IsInteger)
{
throw new ParserException("The from/to arguments in a for loop must be integer types", forStatement.ToExpression);
}
var inttype = new DataType(forStatement.Variable.Name.SourceToken, ILType.SignedInteger, -1);
if (fromType.BitWidth != -1)
{
assignedTypes[forStatement.FromExpression = new AST.TypeCast(forStatement.FromExpression, inttype, false)] = inttype;
}
if (toType.BitWidth != -1)
{
assignedTypes[forStatement.ToExpression = new AST.TypeCast(forStatement.ToExpression, inttype, false)] = inttype;
}
}
}
}
