public static void AddArrayVariable(Lexem nameIn, Lexem size)
{
var name = nameIn.Content.ToString();
try
{
var arrSize = Convert.ToInt32(size.ToDouble());
var array = new Array(arrSize, name);
AddVariable(nameIn, array);
}
catch (Exception)
{
throw new SyntaxException("Размерность массива должна быть целочисленной", size);
}
}
public static Variable GetVariable(object nameIn, Lexem pos = null)
{
var name = nameIn.ToString();
if (pos == null)
{
return Variables.Single(x => x.Name == name);
}
var position = Convert.ToInt32(pos.ToDouble());
try
{
return (Variables.Single(x => x.Name == name).Value as Array).GetElement(position);
}
catch (Exception ex)
{
throw new SyntaxException(ex.Message, pos);
}
}
public static object Calculate(Lexem oper, Lexem leftValue, Lexem rightValue, ref LexemType lt)
{
var t = PickCorrectType(leftValue, rightValue);
switch (t)
{
case TypeCode.Double:
lt = LexemType.Number;
switch (oper.Content.ToString())
{
case "*":
return leftValue.ToDouble() * rightValue.ToDouble();
case "/":
return leftValue.ToDouble() / rightValue.ToDouble();
case "+":
return leftValue.ToDouble() + rightValue.ToDouble();
case "-":
return leftValue.ToDouble() - rightValue.ToDouble();
case ">":
lt = LexemType.Boolean;
return leftValue.ToDouble() > rightValue.ToDouble();
case "<":
lt = LexemType.Boolean;
return leftValue.ToDouble() < rightValue.ToDouble();
case "!=":
lt = LexemType.Boolean;
return leftValue.ToDouble() != rightValue.ToDouble();
case "==":
lt = LexemType.Boolean;
return leftValue.ToDouble() == rightValue.ToDouble();
case ">=":
lt = LexemType.Boolean;
return leftValue.ToDouble() >= rightValue.ToDouble();
case "<=":
lt = LexemType.Boolean;
return leftValue.ToDouble() <= rightValue.ToDouble();
case "=":
Storage.SetVariableValue(leftValue, rightValue.ToDouble());
if (leftValue.Content is Variable) return (leftValue.Content as Variable).Value;
return Storage.GetVariable(leftValue.Content.ToString());
}
break;
case TypeCode.String:
lt = LexemType.String;
switch (oper.Content.ToString())
{
case "+":
return leftValue.ToString() + rightValue.ToString();
case "!=":
lt = LexemType.Boolean;
return leftValue.ToString() != rightValue.ToString();
case "==":
lt = LexemType.Boolean;
return leftValue.ToString() == rightValue.ToString();
case "=":
Storage.SetVariableValue(leftValue, rightValue.ToString());
if (leftValue.Content is Variable) return (leftValue.Content as Variable).Value;
return Storage.GetVariable(leftValue.Content.ToString());
default:
throw new SyntaxException("Неверная операция", oper);
}
case TypeCode.Boolean:
lt = LexemType.Boolean;
switch (oper.Content.ToString())
{
case "||":
return leftValue.ToBoolean() || rightValue.ToBoolean();
case "&&":
return leftValue.ToBoolean() && rightValue.ToBoolean();
case "==":
return leftValue.ToBoolean() == rightValue.ToBoolean();
case "!=":
return leftValue.ToBoolean() != rightValue.ToBoolean();
case "=":
Storage.SetVariableValue(leftValue, rightValue.ToBoolean());
if (leftValue.Content is Variable) return (leftValue.Content as Variable).Value;
return Storage.GetVariable(leftValue.Content.ToString());
default:
throw new SyntaxException("Неверная операция", oper);
}
}
throw new SyntaxException("Ошибка вычисления оператора", oper);
}
private static TypeCode PickCorrectType(Lexem leftValue, Lexem rightValue)
{
LexemType lType = leftValue.LexemType, rType = rightValue.LexemType;
if (lType == LexemType.Number && rType == LexemType.Number)
{
return TypeCode.Double;
}
if (lType == LexemType.String && rType == LexemType.String)
{
return TypeCode.String;
}
if (lType == LexemType.Variable && rType == LexemType.Number ||
lType == LexemType.String && rType == LexemType.Number)
{
try
{
leftValue.ToDouble();
return TypeCode.Double;
}
catch (Exception)
{
return TypeCode.String;
}
}
if (lType == LexemType.Number && rType == LexemType.Variable ||
lType == LexemType.Number && rType == LexemType.String)
{
try
{
rightValue.ToDouble();
return TypeCode.Double;
}
catch (Exception)
{
return TypeCode.String;
}
}
if (lType == LexemType.Variable && rType == LexemType.String ||
lType == LexemType.String && rType == LexemType.Variable)
{
return TypeCode.String;
}
if (lType == LexemType.Variable && rType == LexemType.Boolean ||
lType == LexemType.Boolean && rType == LexemType.Variable)
{
return TypeCode.Boolean;
}
if (lType == LexemType.Boolean && rType == LexemType.Boolean)
{
return TypeCode.Boolean;
}
if (lType == LexemType.Variable && rType == LexemType.Variable)
{
try
{
leftValue.ToDouble();
return TypeCode.Double;
}
catch (Exception)
{
try
{
leftValue.ToBoolean();
return TypeCode.Boolean;
}
catch (Exception)
{
return TypeCode.String;
}
}
}
throw new SyntaxException("Не удалось определить общий тип", leftValue);
}
