/// <summary>
/// This method visits an expressionterm node
/// First it checks the type on the lefthand side of the expression is either Apin or Dpin
/// If also checks if an input is attempted to be uses as an output
/// The input for Apin or Dpin is then accepted and written to the file
/// Lastly the lefthand side of the expression is accepted
/// </summary>
/// <param name="expressionTermNode">The name of the node</param>
/// <returns>It returns the left side of an expression</returns>
public override object Visit(ExpressionTerm expressionTermNode)
{
string exp = "";
if (expressionTermNode.LeftHand.IsType(typeof(APinNode)) || expressionTermNode.LeftHand.IsType(typeof(DPinNode)))
{
string pin = ((PinNode)expressionTermNode.LeftHand).Value;
if (PinDefs.Any(def => def.Contains(pin) && def.Contains("OUTPUT")))
{
new InvalidCodeException($"Pin {pin} was defined as OUTPUT but is also used as INPUT at {expressionTermNode.Line}:{expressionTermNode.Offset}");
}
if (expressionTermNode.LeftHand.Type == TokenType.APIN)
{
PinDefs.Add($"pinMode({pin}, INPUT);");
exp += $"analogRead({pin})";
}
else
{
PinDefs.Add($"pinMode({pin}, INPUT);");
if (PWM.Contains(pin))
{
exp += $"analogRead({pin})";
}
else
{
exp += $"digitalRead({pin})";
}
}
return(exp);
}
exp += expressionTermNode.LeftHand.Accept(this);
return(exp);
}
/// <summary>
/// This method prints the expressionTermNode and make an indentation
/// Then accepts the lefthand of the expression and then outdent
/// </summary>
/// <param name="expressionTermNode">The node to print.</param>
/// <returns>Returns null</returns>
public override object Visit(ExpressionTerm expressionTermNode)
{
Print("ExpressionTerm");
Indent++;
expressionTermNode.LeftHand.Accept(this);
Indent--;
return(null);
}
/// <summary>
/// This method type checks the ExpressionTerm node in the AST.
/// </summary>
/// <param name="expressionNode">The node to check.</param>
/// <returns>The type context of the term</returns>
public override object Visit(ExpressionTerm expressionNode)
{
TypeContext lhs;
if (expressionNode.LeftHand.IsType(typeof(ArrayAccessNode)))
{
lhs = (TypeContext)CurrentScope.FindArray(((ArrayAccessNode)expressionNode.LeftHand).Actual.ActualId.Id).Accept(this);
return(expressionNode.SymbolType = lhs);
}
lhs = (TypeContext)expressionNode.LeftHand.Accept(this);
if (lhs.Type == VAR)
{
lhs = CurrentScope.FindSymbol(expressionNode.LeftHand as VarNode);
}
return(expressionNode.SymbolType = lhs);
}
/// <summary> /// This visits an ExpressionTerm node /// </summary> /// <param name="expressionTermNode">The visited node</param> /// <returns></returns> public abstract object Visit(ExpressionTerm expressionTermNode);
public List <ITerm> GetParsedExpression(string str)
{
List <ITerm> expression = new List <ITerm>();
bool isNumber = false;
bool isNegativeNumber = false;
int startNumberIndex = 0;
var sign = ArithmeticSign.Sum;
var signExpression = ArithmeticSign.Sum;
int nestedExpressionCount = 0;
bool isNewNestedExpression = false;
for (int i = 0; i < str.Length; i++)
{
var isStartBracket = str[i].IsStartBracket();
var isEndBracket = str[i].IsEndBracket();
var isOperation = (str[i].IsArithmeticSign() || isStartBracket || isEndBracket);
if (isOperation)
{
if (isStartBracket)
{
nestedExpressionCount++;
signExpression = sign;
isNumber = false;
continue;
}
if (isEndBracket && str[i - 1].IsEndBracket())
{
nestedExpressionCount--;
if (nestedExpressionCount == 0)
{
isNewNestedExpression = true;
}
continue;
}
if (isNumber || isEndBracket)
{
if (startNumberIndex == i)
{
startNumberIndex++;
isNegativeNumber = true;
continue;
}
var numberTerm = CreateNumberTerm(str, i, startNumberIndex, sign, isNegativeNumber);
if (nestedExpressionCount == 0)
{
expression.Add(numberTerm);
}
else if (nestedExpressionCount == 1)
{
ExpressionTerm innerExpression = GetOrCreateFirstInnerExpression(expression, signExpression, isNewNestedExpression);
innerExpression.Expression.Add(numberTerm);
isNewNestedExpression = false;
}
else if (nestedExpressionCount > 1)
{
IList <ITerm> innerExpression = GetOrCreateSubsequentInnerExpression(expression, nestedExpressionCount, signExpression);
innerExpression.Add(numberTerm);
isNewNestedExpression = false;
}
if (isEndBracket)
{
nestedExpressionCount--;
if (nestedExpressionCount == 0)
{
isNewNestedExpression = true;
}
i++;
}
isNumber = false;
i--;
}
else
{
isNumber = true;
isNegativeNumber = false;
startNumberIndex = i + 1;
sign = ArithmeticSignHelpers.GetArithmeticSignType(str[i]);
}
}
}
if (str[^ 1].IsEndBracket() == false)
