/// <summary>
/// Wires up parameters for a parameterized instance
/// </summary>
/// <param name="state">The validation state</param>
/// <param name="sourceinstance">The instance to wire up</param>
private void WireUpParameters(ValidationState state, Instance.IParameterizedInstance sourceinstance)
{
if (sourceinstance.MappedParameters.Count < sourceinstance.SourceParameters.Length)
{
if (sourceinstance.MappedParameters.Count != 0)
{
throw new Exception("Unexpected half-filled parameter list");
}
var position = 0;
var anynamed = false;
var map = new Instance.MappedParameter[sourceinstance.SourceParameters.Length];
var scope = state.LocalScopes[sourceinstance];
// Map for getting the parameter index of a name
var namelist = sourceinstance
.SourceParameters
.Zip(
Enumerable.Range(0, sourceinstance.SourceParameters.Length),
(p, i) => new { i, p.Name.Name }
);
var collisions = namelist
.GroupBy(x => x.Name)
.Where(x => x.Count() != 1)
.FirstOrDefault();
if (collisions != null)
{
throw new ParserException($"Multiple arguments named {collisions.Key}, positions: {string.Join(", ", collisions.Select(x => x.i.ToString())) }", sourceinstance.SourceParameters[collisions.Last().i].Name);
}
var nameindexmap = namelist.ToDictionary(x => x.Name, x => x.i);
foreach (var p in sourceinstance.ParameterMap)
{
var pos = position;
if (p.Name == null)
{
if (anynamed)
{
throw new ParserException($"Cannot have positional arguments after named arguments", p);
}
}
else
{
anynamed = true;
if (!nameindexmap.TryGetValue(p.Name.Name, out pos))
{
throw new ParserException($"No parameter named {p.Name.Name} in {sourceinstance.SourceName}", sourceinstance.SourceItem);
}
}
if (map[pos] != null)
{
throw new ParserException($"Double argument for {sourceinstance.SourceParameters[pos].Name.Name} detected", sourceinstance.SourceItem);
}
// Extract the parameter definition
var sourceparam = sourceinstance.SourceParameters[pos];
Instance.IInstance value;
var tc = p.Expression as AST.TypeCast;
if (tc != null)
{
value = state.ResolveSymbol(tc.Expression, scope);
}
else
{
value = state.ResolveSymbol(p.Expression, scope);
}
if (value == null)
{
throw new ParserException("Unable to resolve expression", p.Expression.SourceToken);
}
var itemtype = state.InstanceType(value);
var parametertype =
sourceparam.ExplictType == null
? itemtype
: state.ResolveTypeName(sourceparam.ExplictType, scope);
if (parametertype.IsValue && sourceparam.Direction == AST.ParameterDirection.Out)
{
throw new ParserException($"Cannot use a value-type parameter as output: {sourceparam.SourceToken}", sourceparam);
}
// We need to expand both types to intrinsics to remove any type aliases that need lookups
var intrinsic_itemtype = state.ResolveToIntrinsics(itemtype, scope);
var intrinsic_parametertype = state.ResolveToIntrinsics(parametertype, scope);
// If the input is a typecast (and required) we wire it through a process
if (tc != null && !state.CanUnifyTypes(intrinsic_itemtype, intrinsic_parametertype, scope))
{
var typecast_target = state.ResolveToIntrinsics(state.ResolveTypeName(tc.TargetName, scope), scope);
var typecast_source = sourceparam.Direction == ParameterDirection.In ? intrinsic_itemtype : intrinsic_parametertype;
var sourceSignals = typecast_source
.Shape
.Signals
.Select(x => x.Key)
.ToHashSet();
var shared_shape =
typecast_target
.Shape
.Signals
.Where(x => sourceSignals.Contains(x.Key))
.Select(x => new AST.BusSignalDeclaration(
p.SourceToken,
new AST.Identifier(
new ParseToken(0, 0, 0, x.Key)
),
x.Value.Type,
null,
x.Value.Direction
))
.ToArray();
if (sourceSignals.Count != shared_shape.Length)
{
throw new ParserException($"The typecast is invalid as the names do not match", p.SourceToken);
}
var proc = IdentityHelper.CreateTypeCastProcess(
state,
scope,
p.SourceToken,
tc.Expression,
new AST.Name(p.SourceToken, new[] {
new AST.Identifier(new ParseToken(0, 0, 0, sourceinstance.Name)),
sourceparam.Name
}, null).AsExpression(),
shared_shape,
shared_shape
);
throw new ParserException($"Typecasts inside process instantiations are not currently supported", p.SourceToken);
// using (state.StartScope(proc))
// CreateAndRegisterInstance(state, proc);
// parentCollection.Add(proc);
}
// Check argument compatibility
if (!state.CanUnifyTypes(intrinsic_itemtype, intrinsic_parametertype, scope))
{
throw new ParserException($"Cannot use {p.Expression.SourceToken} of type {intrinsic_itemtype.ToString()} as the argument for {sourceparam.Name.SourceToken} of type {intrinsic_parametertype}", p.Expression);
}
// Check that the type we use as input is "larger" than the target
var unified = state.UnifiedType(intrinsic_itemtype, parametertype, scope);
if (!object.Equals(unified, intrinsic_itemtype))
{
throw new ParserException($"Cannot use {p.Expression.SourceToken} of type {intrinsic_itemtype.ToString()} as the argument for {sourceparam.Name.SourceToken} of type {intrinsic_parametertype}", p.Expression);
}
map[pos] = new Instance.MappedParameter(p, sourceparam, value, parametertype);
var localname = map[pos].LocalName;
// Register the instance in the local symbol table to allow
// refering to the instance with the parameter name
scope.TryAddSymbol(localname, value, sourceparam.Name);
position++;
}
if (map.Any(x => x == null))
{
throw new ParserException("Argument missing", sourceinstance.SourceItem);
}
sourceinstance.MappedParameters.AddRange(map);
}
}
/// <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;
}
}
}
}