void SetArrayVariableValue(VariableNameToken variableNameToken, ValueTokenArray indicies, ValueToken value)
{
switch (variableNameToken.VariableType)
{
case VariableValueType.String:
var stringValueToken = (StringValueToken)value;
SetStringArrayVariableValue(variableNameToken, indicies, stringValueToken);
break;
case VariableValueType.RealNumber:
if (value is IntegerValueToken integerValueToken)
{
value = new RealValueToken(integerValueToken.RealValue);
}
SetRealNumberArrayVariableValue(variableNameToken, indicies, (RealValueToken)value);
break;
case VariableValueType.IntegerNumber:
if (value is RealValueToken realValueToken)
{
IntegerValueToken.CheckValueBounds(realValueToken.RealValue);
value = new IntegerValueToken((Int16)realValueToken.IntValue);
}
SetIntegerNumberArrayVariableValue(variableNameToken, indicies, (IntegerValueToken)value);
break;
}
}
public UserDefinedFunction GetUserDefinedFunction(VariableNameToken functionName)
{
UserDefinedFunction function = null;
userDefinedFunctions.TryGetValue(functionName.Name, out function);
return(function);
}
void SetStringArrayVariableValue(VariableNameToken variableNameToken, ValueTokenArray indicies, StringValueToken value)
{
if (stringVariableArray.TryGetValue(variableNameToken.Name, out var stringArray) == false)
{
stringArray = CreateStringArrayVariable(variableNameToken,
ConvertTokensArrayToIntArray(indicies, AdjustDimensionForUndimensionedCreate));
}
stringArray.SetValue(ConvertTokensArrayToIntArray(indicies), value);
}
void SetIntegerNumberArrayVariableValue(VariableNameToken variableNameToken, ValueTokenArray indicies, IntegerValueToken value)
{
if (integerVariableArray.TryGetValue(variableNameToken.Name, out var numberArray) == false)
{
numberArray = CreateIntegerNumberArrayVariable(variableNameToken,
ConvertTokensArrayToIntArray(indicies, AdjustDimensionForUndimensionedCreate));
}
numberArray.SetValue(ConvertTokensArrayToIntArray(indicies), value);
}
void SetStringValue(VariableNameToken nameToken, ValueToken valueToken)
{
if (valueToken is StringValueToken stringToken)
{
stringVariables[nameToken.Name] = stringToken;
return;
}
throw new Exceptions.TypeMismatchException();
}
public void SetVariableValue(VariableNameToken variableNameToken, ValueTokenArray indicies, ValueToken value)
{
if (indicies == null)
{
SetVariableValue(variableNameToken, value);
}
else
{
SetArrayVariableValue(variableNameToken, indicies, value);
}
}
public ForNextLoopState(StatementMarker startMarker, VariableNameToken _variableNameToken, NumericValueToken _startValue,
NumericValueToken _endValue, NumericValueToken _stepValue)
{
LoopMarker = startMarker;
VariableNameToken = _variableNameToken;
StartValue = _startValue;
EndValue = _endValue;
StepValue = _stepValue;
CurrentValue = StartValue;
ImmediateModeStatementIndex = -1;
}
public ForNextLoopState(int _immediateModeStatementIndex, VariableNameToken _variableNameToken, NumericValueToken _startValue,
NumericValueToken _endValue, NumericValueToken _stepValue)
{
ImmediateModeStatementIndex = _immediateModeStatementIndex;
VariableNameToken = _variableNameToken;
StartValue = _startValue;
EndValue = _endValue;
StepValue = _stepValue;
CurrentValue = StartValue;
LoopMarker = null;
}
ArrayVariable <IntegerValueToken> CreateIntegerNumberArrayVariable(VariableNameToken variableNameToken, int[] dimensions)
{
if (integerVariableArray.TryGetValue(variableNameToken.Name, out ArrayVariable <IntegerValueToken> integerValueToken) == true)
{
throw new Exceptions.RedimException();
}
var integerValueArray = new ArrayVariable <IntegerValueToken>(variableNameToken, dimensions);
integerVariableArray.Add(variableNameToken.Name, integerValueArray);
return(integerValueArray);
}
ArrayVariable <StringValueToken> CreateStringArrayVariable(VariableNameToken variableNameToken, int[] dimensions)
{
if (stringVariableArray.TryGetValue(variableNameToken.Name, out ArrayVariable <StringValueToken> stringValueToken) == true)
{
throw new Exceptions.RedimException();
}
var stringArray = new ArrayVariable <StringValueToken>(variableNameToken, dimensions);
stringVariableArray.Add(variableNameToken.Name, stringArray);
return(stringArray);
}
ArrayVariable <RealValueToken> CreateRealNumberArrayVariable(VariableNameToken variableNameToken, int[] dimensions)
{
if (realNumberVariableArray.TryGetValue(variableNameToken.Name, out ArrayVariable <RealValueToken> realNumberValueToken) == true)
{
throw new Exceptions.RedimException();
}
var realValueArray = new ArrayVariable <RealValueToken>(variableNameToken, dimensions);
realNumberVariableArray.Add(variableNameToken.Name, realValueArray);
return(realValueArray);
}
IntegerValueToken GetIntegerVariableValue(VariableNameToken variableNameToken)
{
IntegerValueToken numberToken;
integerVariables.TryGetValue(variableNameToken.Name, out numberToken);
if (numberToken == null)
{
numberToken = interpreter.TokensProvider.CreateIntegerValueToken(0);
}
return(numberToken);
}
StringValueToken GetStringVariableValue(VariableNameToken variableNameToken)
{
StringValueToken stringToken;
stringVariables.TryGetValue(variableNameToken.Name, out stringToken);
// String variables that don't exist return an empty string token
if (stringToken == null)
{
stringToken = interpreter.TokensProvider.CreateStringValueToken(string.Empty);
}
return(stringToken);
}
ValueToken GetIntegerArrayValue(VariableNameToken variableNameToken, ValueTokenArray indicies)
{
if (integerVariableArray.TryGetValue(variableNameToken.Name, out var numberArray) == false)
{
numberArray = CreateIntegerNumberArrayVariable(variableNameToken,
ConvertTokensArrayToIntArray(indicies, AdjustDimensionForUndimensionedCreate));
}
var result = numberArray.GetValue(ConvertTokensArrayToIntArray(indicies));
if (result == null)
{
result = interpreter.TokensProvider.CreateIntegerValueToken(0);
}
return(result);
}
ValueToken GetStringArrayValue(VariableNameToken variableNameToken, ValueTokenArray indicies)
{
if (stringVariableArray.TryGetValue(variableNameToken.Name, out var stringArray) == false)
{
stringArray = CreateStringArrayVariable(variableNameToken,
ConvertTokensArrayToIntArray(indicies, AdjustDimensionForUndimensionedCreate));
}
var result = stringArray.GetValue(ConvertTokensArrayToIntArray(indicies));
if (result == null)
{
result = interpreter.TokensProvider.CreateStringValueToken(string.Empty);
}
return(result);
}
public void SetVariableValue(VariableNameToken variableNameToken, ValueToken value)
{
switch (variableNameToken.VariableType)
{
case VariableValueType.String:
SetStringValue(variableNameToken, value);
break;
case VariableValueType.RealNumber:
SetRealNumberValue(variableNameToken, value);
break;
case VariableValueType.IntegerNumber:
SetIntegerNumberValue(variableNameToken, value);
break;
}
}
void CreateArrayVariable(VariableNameToken variableNameToken, int[] dimensions)
{
switch (variableNameToken.VariableType)
{
case VariableValueType.String:
CreateStringArrayVariable(variableNameToken, dimensions);
break;
case VariableValueType.RealNumber:
CreateRealNumberArrayVariable(variableNameToken, dimensions);
break;
case VariableValueType.IntegerNumber:
CreateIntegerNumberArrayVariable(variableNameToken, dimensions);
break;
}
}
public ValueToken GetArrayVariableValue(VariableNameToken variableNameToken, ValueTokenArray indicies)
{
switch (variableNameToken.VariableType)
{
case VariableValueType.String:
return(GetStringArrayValue(variableNameToken, indicies));
case VariableValueType.RealNumber:
return(GetRealArrayValue(variableNameToken, indicies));
case VariableValueType.IntegerNumber:
return(GetIntegerArrayValue(variableNameToken, indicies));
default:
throw new NotImplementedException();
}
}
public ValueToken GetVariableValue(VariableNameToken variableNameToken)
{
switch (variableNameToken.VariableType)
{
case VariableValueType.String:
return(GetStringVariableValue(variableNameToken));
case VariableValueType.RealNumber:
return(GetRealNumberVariableValue(variableNameToken));
case VariableValueType.IntegerNumber:
return(GetIntegerVariableValue(variableNameToken));
default:
throw new NotImplementedException();
}
}
void SetRealNumberValue(VariableNameToken nameToken, ValueToken valueToken)
{
if (valueToken is StringValueToken)
{
throw new Exceptions.TypeMismatchException();
}
var numberToken = (NumericValueToken)valueToken;
if (numberToken is RealValueToken realToken)
{
realNumberVariables[nameToken.Name] = realToken;
}
else
{
realNumberVariables[nameToken.Name] = new RealValueToken(numberToken.RealValue);
}
}
public VariableNameToken GetOrCreateVariableNameToken(string name, VariableValueType _variableType)
{
#if false
VariableNameToken token = null;
var key = new ValueTuple <string, VariableValueType>(name, _variableType);
if (variableNameTokens.TryGetValue(key, out token))
{
return(token);
}
#endif
var token = new VariableNameToken(name, _variableType);
#if false
variableNameTokens.Add(key, token);
#endif
return(token);
}
void SetIntegerNumberValue(VariableNameToken nameToken, ValueToken valueToken)
{
if (valueToken is StringValueToken)
{
throw new Exceptions.TypeMismatchException();
}
var numberToken = (NumericValueToken)valueToken;
if (numberToken is IntegerValueToken integerToken)
{
integerVariables[nameToken.Name] = integerToken;
return;
}
var realToken = (RealValueToken)valueToken;
IntegerValueToken.CheckValueBounds(realToken.Value);
integerVariables[nameToken.Name] = new IntegerValueToken((Int16)realToken.Value);
}
bool ProcessForNextState(Interpreter interpreter, ForNextLoopState forNextState, VariableNameToken variableNameToken = null)
{
// For NEXT with a variable name, check the variable name matches the one stored in the stack
// if (variableNameToken != null && (forNextState.VariableNameToken.Name != variableNameToken.Name))
// throw new Exceptions.NextWithoutForException();
if (variableNameToken != null && (forNextState.VariableNameToken.Name != variableNameToken.Name))
{
/* Get Calendar from David Ahl's BASIC Computer Games to work without producing
* a NEXT WITHOUT FOR error. If the variable in NEXT [x] is not on top of the stack
* like it should be, then pop variables off the stack until a name match is found.
* If still no match, only then produce a NEXT WITHOUT FOR error. This supports the case
* where the program GOTOs out of an inner loop to an outer loop.
*/
interpreter.ForNextLoops.Pop();
while (interpreter.ForNextLoops.Count > 0)
{
forNextState = interpreter.ForNextLoops.Peek();
if (forNextState.VariableNameToken.Name == variableNameToken.Name)
{
break;
}
// Discard this loop and try matching the next one
interpreter.ForNextLoops.Pop();
}
if (interpreter.ForNextLoops.Count == 0)
{
throw new Exceptions.NextWithoutForException();
}
}
var newValue = forNextState.CurrentValue.RealValue + forNextState.StepValue.RealValue;
bool forNextLoopIsDone = false;
if (forNextState.StepValue.RealValue >= 0)
{
forNextLoopIsDone = (newValue > forNextState.EndValue.RealValue);
}
else
{
forNextLoopIsDone = (newValue < forNextState.EndValue.RealValue);
}
if (forNextLoopIsDone)
{
interpreter.ForNextLoops.Pop();
return(true);
}
#if false
// If done, pop the stack and return true
if (forNextState.StartValue.RealValue <= forNextState.EndValue.RealValue)
{
if (newValue > forNextState.EndValue.RealValue)
{
interpreter.ForNextLoops.Pop();
return(true);
}
}
else
{
var endValue = forNextState.EndValue.RealValue;
bool isLessThan = (newValue < endValue);
if (newValue > forNextState.EndValue.RealValue)
{
interpreter.ForNextLoops.Pop();
return(true);
}
}
#endif
// Keep going, set the NEXT variable and goto the first statement after the FOR
forNextState.CurrentValue = interpreter.TokensProvider.CreateRealValueToken(newValue);
interpreter.VariablesEnvironment.SetVariableValue(forNextState.VariableNameToken, forNextState.CurrentValue);
if (forNextState.LoopMarker != null)
{
// If in immediate mode, there may be no valid statement to loop to.
if (forNextState.LoopMarker.Valid)
{
var forNextStatement = new StatementMarker(forNextState.LoopMarker);
interpreter.NextStatementMarker = forNextStatement;
}
}
else
{
var index = forNextState.ImmediateModeStatementIndex;
interpreter.CurrentImmediateModeStatementMarker.MoveTo(index);
}
// Not done
return(false);
}
public UserDefinedFunction(VariableNameToken _variableNameToken, Statement _statement) : base("_", FunctionArgumentFlags.Number | FunctionArgumentFlags.Required)
{
variableNameToken = _variableNameToken;
statement = _statement;
expressionEvaluator = null;
}
bool AssignInputToVariable(Interpreter interpreter, VariableNameToken variableNameToken, ValueTokenArray indicies, string parsedInput)
{
switch (variableNameToken.VariableType)
{
case VariableValueType.String:
StringValueToken stringValueToken;
// Strip the quotes before setting the value to the variable.
if (parsedInput.StartsWith('\"'))
{
int endIndex = parsedInput.Length;
if (parsedInput[endIndex - 1] == '\"')
{
endIndex -= 1;
}
stringValueToken = interpreter.TokensProvider.CreateStringValueToken(parsedInput.Substring(1, endIndex - 1 - 1));
}
else
{
stringValueToken = interpreter.TokensProvider.CreateStringValueToken(parsedInput);
}
interpreter.VariablesEnvironment.SetVariableValue(variableNameToken, indicies, stringValueToken);
return(true);
case VariableValueType.RealNumber:
// If the string starts with a quote, it's an error.
// ... even if what's in quotes can parse to a number
if (parsedInput[0] == '\"')
{
return(false);
}
// If the conversion fails, it's an error.
if (float.TryParse(parsedInput, out float realValue) == false)
{
return(false);
}
var realValueToken = interpreter.TokensProvider.CreateRealValueToken(realValue);
interpreter.VariablesEnvironment.SetVariableValue(variableNameToken, indicies, realValueToken);
break;
case VariableValueType.IntegerNumber:
// If the string starts with a quote, it's an error.
// ... even if what's in quotes can parse to a number
if (parsedInput[0] == '\"')
{
return(false);
}
// If the conversion fails, it's an error.
if (Int16.TryParse(parsedInput, out Int16 intValue) == false)
{
return(false);
}
var intValueToken = interpreter.TokensProvider.CreateIntegerValueToken(intValue);
interpreter.VariablesEnvironment.SetVariableValue(variableNameToken, indicies, intValueToken);
break;
}
return(true);
}
public void DimensionArrayVariable(VariableNameToken variableNameToken, ValueTokenArray valueTokens)
{
var dimensions = ConvertTokensArrayToIntArray(valueTokens, 1);
CreateArrayVariable(variableNameToken, dimensions);
}
public void CreateUserDefinedFunction(VariableNameToken functionName, UserDefinedFunction function)
{
// A second definition will happily replace any previous one.
userDefinedFunctions[functionName.Name] = function;
}
