private static void setNewExpectVariable(expectType expect, VariableTypes newType, int lineNumber)
{
if (expect.currentType == VariableTypes.unsigned)
{
expect.currentType = newType;
}
else if (expect.currentType != newType)
{
var firstSumType = TypeToString(expect.currentType);
var secondSumType = TypeToString(newType);
string errorMessage;
if (firstSumType == "" || secondSumType == "")
{
errorMessage = "Misslyckades med att para ihop " + expect.currentType + " med " + newType;
}
else
{
errorMessage = "Kan inte lägga ihop " + firstSumType + " med " + secondSumType + ".";
}
ErrorMessage.sendErrorMessage(lineNumber, errorMessage);
expect.currentType = VariableTypes.unknown;
}
}
private static void handleFunctionCall(Logic[] logicOrder, expectType theExpectedType, int lineNumber, Scope currentScope, int i)
{
FunctionParser.linkFunctionCall((logicOrder [i] as FunctionCall), lineNumber, currentScope);
if ((logicOrder [i] as FunctionCall).targetFunc.isUserFunction)
{
currentScope.getCurrentLine().insertReturnExpect(logicOrder [i]);
(logicOrder [i] as FunctionCall).runFunction(currentScope);
throw new FunctionCallException();
}
else
{
if ((logicOrder [i] as FunctionCall).targetFunc.pauseWalker)
{
CodeWalker.pauseWalker();
}
if ((logicOrder[i] as FunctionCall).targetFunc.name == "input")
{
CodeWalker.linkSubmitInput.Invoke(SubmitInput, currentScope);
Variable returnVariable = (logicOrder[i] as FunctionCall).runFunction(currentScope);
logicOrder[i] = returnVariable;
if (returnVariable.variableType == VariableTypes.boolean)
{
setNewExpectVariable(theExpectedType, VariableTypes.boolean, lineNumber);
}
else if (returnVariable.variableType == VariableTypes.number)
{
setNewExpectVariable(theExpectedType, VariableTypes.number, lineNumber);
}
else if (returnVariable.variableType == VariableTypes.textString)
{
setNewExpectVariable(theExpectedType, VariableTypes.textString, lineNumber);
}
CodeWalker.isWaitingForUserInput = true;
}
else
{
Variable returnVariable = (logicOrder[i] as FunctionCall).runFunction(currentScope);
logicOrder[i] = returnVariable;
if (returnVariable.variableType == VariableTypes.boolean)
{
setNewExpectVariable(theExpectedType, VariableTypes.boolean, lineNumber);
}
else if (returnVariable.variableType == VariableTypes.number)
{
setNewExpectVariable(theExpectedType, VariableTypes.number, lineNumber);
}
else if (returnVariable.variableType == VariableTypes.textString)
{
setNewExpectVariable(theExpectedType, VariableTypes.textString, lineNumber);
}
}
}
}
private static Variable getCalcSum(expectType theExpectedType, Logic[] logicOrder, int lineNumber)
{
if (theExpectedType.currentType == VariableTypes.boolean)
{
Variable sumVar = BooleanSumParser.validBoolSum(logicOrder, lineNumber);
if (sumVar.variableType == VariableTypes.boolean)
{
return(sumVar);
}
}
if (theExpectedType.currentType == VariableTypes.textString)
{
Variable sumVar = TextSumParser.validTextSum(logicOrder, lineNumber);
if (sumVar.variableType == VariableTypes.textString)
{
return(sumVar);
}
}
if (theExpectedType.currentType == VariableTypes.number)
{
Variable sumVar = NumberSumParser.validNumberSum(logicOrder, lineNumber);
if (sumVar.variableType == VariableTypes.number)
{
return(sumVar);
}
}
return(new Variable("CalcVar"));
}
private static void handleVariable(Logic[] logicOrder, expectType theExpectedType, int lineNumber, Scope currentScope, int i)
{
int varPos = currentScope.scopeVariables.containsVariable((logicOrder [i] as Variable).name);
if (varPos >= 0)
{
Variable foundVar = currentScope.scopeVariables.variableList [varPos];
setNewExpectVariable(theExpectedType, foundVar.variableType, lineNumber);
logicOrder [i] = foundVar;
}
else
{
if ((logicOrder [i] as Variable).isCalcVar)
{
setNewExpectVariable(theExpectedType, (logicOrder [i] as Variable).variableType, lineNumber);
}
else
{
if ((logicOrder [i] as Variable).name.Length > 10)
{
ErrorMessage.sendErrorMessage(lineNumber, "Användning av icke deklarerad variabel!");
}
LevenshteinDist.checkForClosesVariable(logicOrder [i].word, lineNumber, currentScope);
ErrorMessage.sendErrorMessage(lineNumber, "Kunde inte hitta variabeln \"" + (logicOrder [i] as Variable).name + "\" i minnet.");
}
}
}
static void setNewExpectVariable(expectType expect, VariableTypes newType, int lineNumber, Logic[] logicOrder)
{
if (expect.currentType == VariableTypes.unknown)
{
return;
}
if (expect.currentType == VariableTypes.unsigned)
{
expect.currentType = newType;
}
else if (expect.currentType != newType)
{
var firstSumType = SumParser.TypeToString(expect.currentType);
var secondSumType = SumParser.TypeToString(newType);
string errorMessage;
if (firstSumType == "" || secondSumType == "")
{
errorMessage = "Misslyckades med att para ihop " + expect.currentType + " med " + newType;
}
else
{
errorMessage = "Kan inte para ihop " + firstSumType + " med " + secondSumType + ".";
}
ErrorMessage.sendErrorMessage(lineNumber, errorMessage);
}
if (expect.currentType == VariableTypes.boolean)
{
BooleanSumParser.validBoolSum(logicOrder, lineNumber);
}
}
public static Variable checkIfValidSum(Logic[] PrelogicOrder, int lineNumber)
{
Logic[] logicOrder = (Logic[])PrelogicOrder.Clone();
UnpackPackages(logicOrder, lineNumber);
logicOrder = BoolCompressExpressions.compressExpression(logicOrder, lineNumber, null, false);
logicOrder = BoolExpressionParser.compressAndOrStatements(logicOrder, lineNumber, null);
if (logicOrder.Length == 0)
{
return(new Variable("No var"));
}
expectType theExpectedType = new expectType();
for (int i = 0; i < logicOrder.Length; i++)
{
if (logicOrder[i].currentType == WordTypes.booleanExpression)
{
setNewExpectVariable(theExpectedType, VariableTypes.boolean, lineNumber, logicOrder);
}
else if (logicOrder [i].currentType == WordTypes.variable)
{
logicOrder [i] = new Variable(logicOrder [i].word);
}
else if (logicOrder [i].currentType == WordTypes.mathOperator)
{
}
else if (logicOrder [i].currentType == WordTypes.number)
{
setNewExpectVariable(theExpectedType, VariableTypes.number, lineNumber, logicOrder);
}
else if (logicOrder [i].currentType == WordTypes.textString)
{
setNewExpectVariable(theExpectedType, VariableTypes.textString, lineNumber, logicOrder);
}
else if (logicOrder [i].currentType == WordTypes.booleanValue)
{
setNewExpectVariable(theExpectedType, VariableTypes.boolean, lineNumber, logicOrder);
}
}
if (theExpectedType.currentType == VariableTypes.unknown)
{
return(new Variable());
}
return(theExpectedType.returnExpectedVariable());
}
public static Variable parseIntoSum(Logic[] logicOrderInput, int lineNumber, Scope currentScope)
{
Logic[] logicOrder = (Logic[])logicOrderInput.Clone();
UnpackPackages(logicOrder, lineNumber, currentScope);
logicOrder = BoolCompressExpressions.compressExpression(logicOrder, lineNumber, currentScope, true);
logicOrder = BoolExpressionParser.compressAndOrStatements(logicOrder, lineNumber, currentScope);
if (logicOrder.Length == 0)
{
return(new Variable("CalcVar"));
}
expectType theExpectedType = new expectType();
calcSumType(logicOrder, theExpectedType, lineNumber, currentScope);
return(getCalcSum(theExpectedType, logicOrder, lineNumber));
}
private static void calcSumType(Logic[] logicOrder, expectType theExpectedType, int lineNumber, Scope currentScope)
{
for (int i = 0; i < logicOrder.Length; i++)
{
switch (logicOrder [i].currentType)
{
#region values
case WordTypes.textString:
setNewExpectVariable(theExpectedType, VariableTypes.textString, lineNumber);
break;
case WordTypes.number:
setNewExpectVariable(theExpectedType, VariableTypes.number, lineNumber);
break;
case WordTypes.booleanValue:
setNewExpectVariable(theExpectedType, VariableTypes.boolean, lineNumber);
break;
#endregion
// booleanExpressions are for example a expression used in an if-statement
case WordTypes.booleanExpression:
logicOrder [i] = (logicOrder [i] as BooleanExpression).parseExpression();
setNewExpectVariable(theExpectedType, VariableTypes.boolean, lineNumber);
break;
case WordTypes.variable:
handleVariable(logicOrder, theExpectedType, lineNumber, currentScope, i);
break;
case WordTypes.functionCall:
handleFunctionCall(logicOrder, theExpectedType, lineNumber, currentScope, i);
break;
}
}
}
