public override void Visit(ArrayAccessNode node)
{
node.IndexValue.Accept(this);
if (node.IndexValue.Type != "int")
{
throw new SemanticException($"Error on line {node.line}: ArrayIndex is not of type integer.");
}
}
public void Visit(ArrayAccessNode arrayAccess)
{
foreach (var index in arrayAccess.Arguments)
{
index.Parent = arrayAccess;
index.Accept(this);
}
}
/// <summary>
/// This method prints the arrayAccess and make an indentation
/// Then it accepts all the array accesses
/// Then outdent
/// </summary>
/// <param name="arrayAccess">The node to print.</param>
/// <returns>Returns null</returns>
public override object Visit(ArrayAccessNode arrayAccess)
{
Print("ArrayAccess");
Indent++;
if (arrayAccess.Accesses.Any())
{
arrayAccess.Accesses.ForEach(node => node.Accept(this));
}
Indent--;
return(null);
}
/// <summary>
/// This method visits an array access node
/// It checks what array is being accessed, and accesses it with the according dimensional access.
/// </summary>
/// <param name="arrayAccess"></param>
/// <returns></returns>
public override object Visit(ArrayAccessNode arrayAccess)
{
string arrAccess = "";
arrAccess += arrayAccess.Actual.ActualId.Id;
foreach (string access in arrayAccess.Accesses.Select(node => node.IsType(typeof(VarNode)) ? ((VarNode)node).Id : ((NumericNode)node).Value))
{
arrAccess += $"[{access}]";
}
return(arrAccess);
}
/// <summary>
/// This method type checks the ArrayAccessNode node in the AST.
/// </summary>
/// <param name="arrayAccess">The node to check.</param>
/// <returns>The type of the accessed array</returns>
public override object Visit(ArrayAccessNode arrayAccess)
{
int accessLocation = 0;
foreach (int access in arrayAccess.Accesses.Where(n => n.IsType(typeof(NumericNode))).Select(n => ((NumericNode)n).IValue))
{
if (arrayAccess.Actual.Dimensions[accessLocation++].IValue <= access)
{
new OutOfRangeException($"Illegal access to array '{arrayAccess.Actual.ActualId.Id}'. Access out of range. Error at {arrayAccess.Line}:{arrayAccess.Offset}");
}
}
return((CurrentScope ?? GlobalScope).FindArray(arrayAccess.Actual.ActualId.Id).Accept(this));
}
private List <ArrayAccessNode> OptionalArrayAccessList()
{
printDebug("Optional Array Access List");
if (ConsumeOnMatch(TokenType.BRACKET_OPEN))
{
var exprs = ExpressionList();
MatchExactly(TokenType.BRACKET_CLOSE);
var access = new ArrayAccessNode(exprs);
var lista = OptionalArrayAccessList();
lista.Insert(0, access);
return(lista);
}
else
{
return(new List <ArrayAccessNode>());
}
}
public void Visit(ArrayAccessNode node)
{
var paren = node.GetPrecedence() < node.GetArray().GetPrecedence();
if (paren)
{
source.Append("(");
}
node.GetArray().Visit(this);
if (paren)
{
source.Append(")");
}
source.Append("[");
node.GetIndex().Visit(this);
source.Append("]");
}
public void Test_ParseTable_ArrayAccess_NotImplementedException_Operator_Set() // -
{
ArrayAccessNode node = new ArrayAccessNode(new ArrayNode(1, 1), 1, 1);
Assert.Throws <NotImplementedException>(() => node.Operator = new PlusNode(new ScannerToken(OP_PLUS, 1, 1)));
}
/// <summary>
/// This method type checks the AssignmentNode node in the AST.
/// </summary>
/// <param name="assignmentNode">The node to check.</param>
/// <returns>Returns null</returns>
public override object Visit(AssignmentNode assignmentNode)
{
TypeContext lhs = (TypeContext)assignmentNode.LeftHand.Accept(this);
TypeContext rhs;
if (assignmentNode.RightHand.IsType(typeof(ArrayNode)))
{
ArrayNode arr = (ArrayNode)assignmentNode.RightHand;
if (arr.HasBeenAccessed)
{
if (lhs.Type == VAR)
{
arr.SymbolType = lhs = rhs = (TypeContext)arr.FirstAccess.RightHand.Accept(this);
assignmentNode.LeftHand.SymbolType = rhs;
assignmentNode.LeftHand.Type = rhs.Type;
}
else
{
rhs = (TypeContext)arr.FirstAccess.RightHand.Accept(this);
}
}
else
{
new InvalidTypeException($"Array type never set. Error at {arr.Line}:{arr.Offset}");
return(null);
}
}
else
{
rhs = (TypeContext)assignmentNode.RightHand.Accept(this);
}
if (assignmentNode.RightHand.IsType(typeof(ArrayAccessNode)))
{
if (CurrentScope.FindArray((assignmentNode.LeftHand as ArrayAccessNode).Actual.ActualId.Id).Type == ARR)
{
ArrayAccessNode node = (assignmentNode.LeftHand as ArrayAccessNode);
ArrayNode arr = CurrentScope.FindArray(node.Actual.ActualId.Id);
if (!(arr.Dimensions.Count >= node.Accesses.Count))
{
new OutOfRangeException($"Illegal access to {arr.Dimensions.Count} dimensional array. Error at {node.Line}:{node.Offset}");
return(null);
}
if (arr.Dimensions.Count > node.Accesses.Count && node.Accesses.Count > 1)
{
AssignmentNode declaringStatement = new AssignmentNode(node.Line, node.Offset);
declaringStatement.LeftHand =
new VarNode($"protected_declaration_{arr.ActualId.Id}_{node.Accesses.Count - 1}", new ScannerToken(node.Type, $"protected_declaration_{arr.ActualId.Id}_{node.Accesses.Count - 1}", node.Line, node.Offset))
{
IsArray = true, SymbolType = new TypeContext(node.Type)
};
ArrayNode declaringArray = new ArrayNode(node.Line, node.Offset);
for (int i = 0; i < node.Accesses.Count; i++)
{
declaringArray.Dimensions.Add(arr.Dimensions[i]);
}
((IScope)assignmentNode.Parent).Statements.Insert(((IScope)assignmentNode.Parent).Statements.IndexOf(assignmentNode), declaringStatement);
}
node.Actual.FirstAccess.LeftHand.SymbolType = rhs;
node.Actual.FirstAccess.LeftHand.Type = rhs.Type;
arr.SymbolType = rhs;
arr.Type = rhs.Type;
lhs = rhs;
}
}
if (lhs.Type == VAR)
{
if (!CurrentScope.HasDeclaredVar(assignmentNode.LeftHand as AstNode))
{
(assignmentNode.LeftHand as VarNode).Declaration = true;
CurrentScope.DeclaredVars.Add((assignmentNode.LeftHand as VarNode).Id);
}
if (assignmentNode.LeftHand.IsType(typeof(VarNode)))
{
if (CurrentScope.FindSymbol(assignmentNode.LeftHand as VarNode).Type == VAR)
{
CurrentScope.UpdateTypedef(assignmentNode.LeftHand as VarNode, rhs, CurrentScope.Name, true);
}
lhs = CurrentScope.FindSymbol(assignmentNode.LeftHand as VarNode);
}
else if (assignmentNode.LeftHand.IsType(typeof(ArrayAccessNode)))
{
}
}
if (lhs.Type != rhs.Type)
{
if ((lhs.Type != DPIN && lhs.Type != APIN) || (rhs.Type != NUMERIC && rhs.Type != BOOL))
{
new InvalidTypeException($"Type {rhs.Type} is not assignable toType {lhs.Type} at {assignmentNode.Line}:{assignmentNode.Offset}");
}
}
return(null);
}
public override void Visit(ArrayAccessNode node)
{
Console.Write("[");
node.IndexValue.Accept(this);
Console.Write("]");
}
internal abstract void Visit(ArrayAccessNode node);
/// <summary> /// This visits an Array Access node /// </summary> /// <param name="arrayAccess">The visited node</param> /// <returns></returns> public abstract object Visit(ArrayAccessNode arrayAccess);
public void Visit(ArrayAccessNode node)
{
visitor.OnVisit((n, v) => Result = IsSameChildren(n, node));
reference.Visit(visitor);
}
public void Test_ParseTable_ArrayAccess_NotImplementedException_RightHand_Set() // -
{
ArrayAccessNode node = new ArrayAccessNode(new ArrayNode(1, 1), 1, 1);
Assert.Throws <NotImplementedException>(() => node.RightHand = new ExpressionTerm(new ScannerToken(NUMERIC, 1, 1)));
}
public override void Visit(ArrayAccessNode node)
{
CSharpString.Append("[");
node.IndexValue.Accept(this);
CSharpString.Append("]");
}
public void Test_ParseTable_ArrayAccess_NotImplementedException_RightHand_Get() // -
{
ArrayAccessNode node = new ArrayAccessNode(new ArrayNode(1, 1), 1, 1);
Assert.Throws <NotImplementedException>(() => Console.WriteLine(node.RightHand));
}
public abstract void Visit(ArrayAccessNode node);
