public override void Add(string input)
{
if (IsSpecialKey(input))
{
HandleSpecialKey(input);
return;
}
if (!Buffer.IsEmpty)
{
PushBuffer();
TryEvaluate();
}
if (input == "(" || input == ")")
{
AddParentheses(input);
}
else if (OperatorConverter.IsUnary(input))
{
AddUnary(input);
}
else
{
AddBinary(input);
}
TryEvaluate();
}
private static void GenerateUnaryExpression(ScriptGenerator generator, MemberSymbol symbol, UnaryExpression expression)
{
ScriptTextWriter writer = generator.Writer;
PropertyExpression propExpression = expression.Operand as PropertyExpression;
if ((propExpression != null) &&
((expression.Operator == Operator.PreIncrement) || (expression.Operator == Operator.PostIncrement) ||
(expression.Operator == Operator.PreDecrement) || (expression.Operator == Operator.PostDecrement)))
{
Debug.Assert(propExpression.Type == ExpressionType.PropertyGet);
string fudgeOperator;
GenerateExpression(generator, symbol, propExpression.ObjectReference);
writer.Write(".set_");
writer.Write(propExpression.Property.GeneratedName);
writer.Write("(");
GenerateExpression(generator, symbol, propExpression.ObjectReference);
writer.Write(".get_");
writer.Write(propExpression.Property.GeneratedName);
writer.Write("()");
if ((expression.Operator == Operator.PreIncrement) || (expression.Operator == Operator.PostIncrement))
{
writer.WriteTrimmed(" + ");
fudgeOperator = " - ";
}
else
{
writer.WriteTrimmed(" - ");
fudgeOperator = " + ";
}
writer.Write("1");
writer.Write(")");
if ((expression.Operator == Operator.PreIncrement) || (expression.Operator == Operator.PreDecrement))
{
writer.WriteTrimmed(fudgeOperator);
writer.Write("1");
}
return;
}
if ((expression.Operator == Operator.PreIncrement) ||
(expression.Operator == Operator.PreDecrement))
{
ExpressionGenerator.GenerateExpression(generator, symbol, expression.Operand);
writer.Write(OperatorConverter.OperatorToString(expression.Operator));
}
else
{
writer.Write(OperatorConverter.OperatorToString(expression.Operator));
ExpressionGenerator.GenerateExpression(generator, symbol, expression.Operand);
}
}
public void Setup()
{
var operators = new string[] { modulus, minus, power, log, factorial };
var unarys = new HashSet <string>()
{
log, factorial
};
converter = new OperatorConverter(operators, unarys);
}
public void LoadCalculatorAsset()
{
InputBuffer = new InputBuffer();
Operators = new OperatorLookup();
UnitConverter = new AngleConverter();
OperatorConverter = new OperatorConverter(Operators.Operators, Operators.Unary);
Parenthesizer = new Parenthesizer(Operators.Precedence);
ExpressionBuilder = new ExpressionBuilder(Parenthesizer);
ExpressionParser = new ExpressionParser(OperatorConverter);
Evaluator = new Evaluator(UnitConverter, OperatorConverter, Operators);
MemoryStorage = new MemoryStorage();
}
public IEnumerable <KeyValuePair <string, string> > Execute()
{
log.Info(string.Format("Indexed scan operation for '{0}', filter: '{1}' {2} '{3}'.", tableName, filter.Column,
OperatorConverter.ToComboString(filter.Operator).ToString(), filter.Value));
switch (filter.Operator)
{
case Operator.Equal:
var keys = index.Get(filter.Value);
foreach (var key in keys)
{
yield return(new KeyValuePair <string, string>(key, repository.Get(databaseFile, table.Name, key)));
}
break;
case Operator.NotEqual:
foreach (var row in GetNotEqual())
{
yield return(row);
}
break;
case Operator.Less:
foreach (var row in GetLess())
{
yield return(row);
}
break;
case Operator.LessOrEqual:
foreach (var row in GetLessOrEqual())
{
yield return(row);
}
break;
case Operator.Greater:
foreach (var row in GetGreater())
{
yield return(row);
}
break;
case Operator.GreaterOrEqual:
foreach (var row in GetGreaterOrEqual())
{
yield return(row);
}
break;
}
}
private static void GenerateUnaryExpression(ScriptGenerator generator, MemberSymbol symbol, UnaryExpression expression)
{
ScriptTextWriter writer = generator.Writer;
if ((expression.Operator == Operator.PreIncrement) ||
(expression.Operator == Operator.PreDecrement))
{
ExpressionGenerator.GenerateExpression(generator, symbol, expression.Operand);
writer.Write(OperatorConverter.OperatorToString(expression.Operator));
}
else
{
writer.Write(OperatorConverter.OperatorToString(expression.Operator));
ExpressionGenerator.GenerateExpression(generator, symbol, expression.Operand);
}
}
private ICollection <Filter> GetFilters()
{
var filters = new List <Filter>();
for (int i = 0; i < filterDataGridView.Rows.Count - 1; i++)
{
var tableName = filterDataGridView.Rows[i].Cells[0].Value.ToString();
var columnName = filterDataGridView.Rows[i].Cells[1].Value.ToString();
var operatorType = OperatorConverter.ToOperator(filterDataGridView.Rows[i].Cells[2].Value.ToString());
var value = filterDataGridView.Rows[i].Cells[3].Value.ToString();
var filter = new Filter(tableName, columnName, operatorType, value);
filters.Add(filter);
}
return(filters);
}
private ICollection <Join> GetJoins()
{
var joins = new List <Join>();
for (int i = 0; i < joinDataGridView.Rows.Count - 1; i++)
{
var leftTableName = joinDataGridView.Rows[i].Cells[0].Value.ToString();
var leftColumnName = joinDataGridView.Rows[i].Cells[1].Value.ToString();
var rightTableName = joinDataGridView.Rows[i].Cells[2].Value.ToString();
var rightColumnName = joinDataGridView.Rows[i].Cells[3].Value.ToString();
var operatorType = OperatorConverter.ToOperator(filterDataGridView.Rows[i].Cells[4].Value.ToString());
var join = new Join(leftTableName, leftColumnName, rightTableName, rightColumnName, operatorType);
joins.Add(join);
}
return(joins);
}
public decimal Evaluate(INode node)
{
if (node == null)
{
return(0);
}
if (node.IsOperand)
{
return(node.Value);
}
return(Calculate(
OperatorConverter.ToOperator((int)node.Value),
Evaluate(node.Left),
Evaluate(node.Right)
));
}
private static void GenerateBinaryExpression(ScriptGenerator generator, MemberSymbol symbol,
BinaryExpression expression)
{
ScriptTextWriter writer = generator.Writer;
if (expression.Operator == Operator.Equals)
{
if (expression.LeftOperand is PropertyExpression propExpression)
{
Debug.Assert(propExpression.Type == ExpressionType.PropertySet);
if (propExpression.ObjectReference is BaseExpression)
{
ClassSymbol classSymbol = (ClassSymbol)symbol.Parent;
writer.Write($"{DSharpStringResources.ScriptExportMember("baseProperty")}(");
writer.Write(classSymbol.FullGeneratedName);
writer.Write(", '");
writer.Write(propExpression.Property.GeneratedName);
writer.Write("').set.call(");
writer.Write(generator.CurrentImplementation.ThisIdentifier);
writer.Write(", ");
GenerateExpression(generator, symbol, expression.RightOperand);
writer.Write(")");
}
else
{
GenerateExpression(generator, symbol, propExpression.ObjectReference);
writer.Write(".");
writer.Write(propExpression.Property.GeneratedName);
writer.Write(" = ");
GenerateExpression(generator, symbol, expression.RightOperand);
}
propExpression.Property.IncrementReferenceCount();
return;
}
if (expression.LeftOperand is IndexerExpression indexExpression)
{
IndexerSymbol indexerSymbol = indexExpression.Indexer;
if (!indexerSymbol.UseScriptIndexer)
{
Debug.Assert(indexExpression.Type == ExpressionType.Indexer);
if (indexExpression.ObjectReference is BaseExpression objectReference)
{
writer.Write(objectReference.EvaluatedType.FullGeneratedName);
writer.Write(".prototype.set_");
writer.Write(indexerSymbol.GeneratedName);
writer.Write(".call(");
writer.Write(generator.CurrentImplementation.ThisIdentifier);
writer.Write(", ");
GenerateExpressionList(generator, symbol, indexExpression.Indices);
writer.Write(", ");
GenerateExpression(generator, symbol, expression.RightOperand);
writer.Write(")");
}
else
{
GenerateExpression(generator, symbol, indexExpression.ObjectReference);
writer.Write(".set_");
writer.Write(indexerSymbol.GeneratedName);
writer.Write("(");
GenerateExpressionList(generator, symbol, indexExpression.Indices);
writer.Write(", ");
GenerateExpression(generator, symbol, expression.RightOperand);
writer.Write(")");
}
indexExpression.Indexer.IncrementReferenceCount();
return;
}
else if (indexerSymbol.Parent is TypeSymbol typeSymbol && !typeSymbol.IsNativeArray)
{
writer.Write($"ss.setItem(");
GenerateExpression(generator, symbol, indexExpression.ObjectReference);
writer.Write(", ");
GenerateExpressionList(generator, symbol, indexExpression.Indices);
writer.Write(", ");
GenerateExpression(generator, symbol, expression.RightOperand);
writer.Write(")");
return;
}
}
}
else if (expression.Operator == Operator.PlusEquals ||
expression.Operator == Operator.MinusEquals ||
expression.Operator == Operator.MultiplyEquals ||
expression.Operator == Operator.DivideEquals ||
expression.Operator == Operator.ModEquals ||
expression.Operator == Operator.BitwiseOrEquals ||
expression.Operator == Operator.BitwiseAndEquals ||
expression.Operator == Operator.BitwiseXorEquals ||
expression.Operator == Operator.ShiftLeftEquals ||
expression.Operator == Operator.ShiftRightEquals ||
expression.Operator == Operator.UnsignedShiftRightEquals)
{
if (expression.LeftOperand is PropertyExpression propExpression)
{
Debug.Assert(propExpression.Type == ExpressionType.PropertyGet);
GenerateExpression(generator, symbol, propExpression.ObjectReference);
writer.Write(".");
writer.Write(propExpression.Property.GeneratedName);
writer.Write(" = ");
GenerateExpression(generator, symbol, propExpression.ObjectReference);
writer.Write(OperatorConverter.OperatorToString(expression.Operator - 1));
GenerateExpression(generator, symbol, expression.RightOperand);
propExpression.Property.IncrementReferenceCount();
return;
}
}
else if (expression.Operator == Operator.Is ||
expression.Operator == Operator.As)
{
TypeExpression typeExpression = expression.RightOperand as TypeExpression;
Debug.Assert(typeExpression != null);
writer.Write(DSharpStringResources.ScriptExportMember(string.Empty));
if (expression.Operator == Operator.Is)
{
writer.Write("canCast(");
}
else
{
writer.Write("safeCast(");
}
GenerateExpression(generator, symbol, expression.LeftOperand);
writer.Write(", ");
writer.Write(typeExpression.AssociatedType.FullGeneratedName);
writer.Write(")");
typeExpression.AssociatedType.IncrementReferenceCount();
return;
}
else if (expression.Operator == Operator.EqualEqualEqual ||
expression.Operator == Operator.NotEqualEqual)
{
if (expression.RightOperand is LiteralExpression literalExpression)
{
// Optimize generated script to perform loose equality checks for false-y values
// (null, false, 0, empty string)
// TODO: This should really be happening at compilation time, rather than generation
// time. Because this is happening at generation time, we get something like
// if (!!x) when if(x) would suffice just so we can get
// foo(!!x) where foo is a method expecting a boolean.
// Doing this at compilation time would allow handling if scenarios specially.
bool optimizable = false;
bool checkForFalse = false;
if (literalExpression.Value is bool compareValue)
{
optimizable = true;
if (compareValue && expression.Operator == Operator.NotEqualEqual ||
!compareValue && expression.Operator == Operator.EqualEqualEqual)
{
checkForFalse = true;
}
}
else if (literalExpression.Value is int i && i == 0)
{
optimizable = true;
checkForFalse = expression.Operator == Operator.EqualEqualEqual;
}
else if (literalExpression.Value is string s && s == string.Empty)
{
optimizable = true;
checkForFalse = expression.Operator == Operator.EqualEqualEqual;
}
if (optimizable)
{
bool parenthesize = false;
writer.Write(checkForFalse ? "!" : "!!");
if (expression.LeftOperand.Parenthesized == false &&
(expression.LeftOperand.Type == ExpressionType.Binary ||
expression.LeftOperand.Type == ExpressionType.Conditional ||
expression.LeftOperand.Type == ExpressionType.InlineScript))
{
parenthesize = true;
writer.Write("(");
}
GenerateExpression(generator, symbol, expression.LeftOperand);
if (parenthesize)
{
writer.Write(")");
}
return;
}
}
}
private static void GenerateBinaryExpression(ScriptGenerator generator, MemberSymbol symbol, BinaryExpression expression)
{
ScriptTextWriter writer = generator.Writer;
if (expression.Operator == Operator.Equals)
{
PropertyExpression propExpression = expression.LeftOperand as PropertyExpression;
if (propExpression != null)
{
Debug.Assert(propExpression.Type == ExpressionType.PropertySet);
if (propExpression.ObjectReference is BaseExpression)
{
Debug.Assert(symbol.Parent is ClassSymbol);
writer.Write(((ClassSymbol)symbol.Parent).FullGeneratedName);
writer.Write(".callBaseMethod(this, 'set_");
writer.Write(propExpression.Property.GeneratedName);
writer.Write("',");
writer.WriteTrimmed(" [ ");
GenerateExpression(generator, symbol, expression.RightOperand);
writer.WriteTrimmed(" ])");
}
else
{
GenerateExpression(generator, symbol, propExpression.ObjectReference);
writer.Write(".set_");
writer.Write(propExpression.Property.GeneratedName);
writer.Write("(");
GenerateExpression(generator, symbol, expression.RightOperand);
writer.Write(")");
}
return;
}
IndexerExpression indexExpression = expression.LeftOperand as IndexerExpression;
if ((indexExpression != null) &&
!indexExpression.Indexer.IsIntrinsic)
{
Debug.Assert(indexExpression.Type == ExpressionType.Indexer);
if (indexExpression.ObjectReference is BaseExpression)
{
Debug.Assert(symbol.Parent is ClassSymbol);
writer.Write(((ClassSymbol)symbol.Parent).FullGeneratedName);
writer.Write(".callBaseMethod(this, 'set_");
writer.Write(indexExpression.Indexer.GeneratedName);
writer.Write("',");
writer.WriteTrimmed(" [ ");
GenerateExpressionList(generator, symbol, indexExpression.Indices);
writer.WriteTrimmed(", ");
GenerateExpression(generator, symbol, expression.RightOperand);
writer.WriteTrimmed(" ])");
}
else
{
IndexerSymbol indexerSymbol = indexExpression.Indexer;
GenerateExpression(generator, symbol, indexExpression.ObjectReference);
writer.Write(".set_");
writer.Write(indexerSymbol.GeneratedName);
writer.Write("(");
GenerateExpressionList(generator, symbol, indexExpression.Indices);
writer.WriteTrimmed(", ");
GenerateExpression(generator, symbol, expression.RightOperand);
writer.Write(")");
}
return;
}
}
else if ((expression.Operator == Operator.PlusEquals) ||
(expression.Operator == Operator.MinusEquals) ||
(expression.Operator == Operator.MultiplyEquals) ||
(expression.Operator == Operator.DivideEquals) ||
(expression.Operator == Operator.ModEquals) ||
(expression.Operator == Operator.BitwiseOrEquals) ||
(expression.Operator == Operator.BitwiseAndEquals) ||
(expression.Operator == Operator.BitwiseXorEquals) ||
(expression.Operator == Operator.ShiftLeftEquals) ||
(expression.Operator == Operator.ShiftRightEquals) ||
(expression.Operator == Operator.UnsignedShiftRightEquals))
{
PropertyExpression propExpression = expression.LeftOperand as PropertyExpression;
if (propExpression != null)
{
Debug.Assert(propExpression.Type == ExpressionType.PropertyGet);
GenerateExpression(generator, symbol, propExpression.ObjectReference);
writer.Write(".set_");
writer.Write(propExpression.Property.GeneratedName);
writer.Write("(");
GenerateExpression(generator, symbol, propExpression.ObjectReference);
writer.Write(".get_");
writer.Write(propExpression.Property.GeneratedName);
writer.WriteTrimmed("()");
writer.WriteTrimmed(OperatorConverter.OperatorToString(expression.Operator - 1));
GenerateExpression(generator, symbol, expression.RightOperand);
writer.Write(")");
return;
}
}
else if ((expression.Operator == Operator.Is) ||
(expression.Operator == Operator.As))
{
TypeExpression typeExpression = expression.RightOperand as TypeExpression;
Debug.Assert(typeExpression != null);
writer.Write("Type.");
if (expression.Operator == Operator.Is)
{
writer.Write("canCast(");
}
else
{
writer.Write("safeCast(");
}
GenerateExpression(generator, symbol, expression.LeftOperand);
writer.WriteTrimmed(", ");
writer.Write(typeExpression.AssociatedType.FullGeneratedName);
writer.Write(")");
return;
}
else if ((expression.Operator == Operator.EqualEqualEqual) ||
(expression.Operator == Operator.NotEqualEqual))
{
LiteralExpression literalExpression = expression.RightOperand as LiteralExpression;
if (literalExpression != null)
{
// Optimize generated script to perform loose equality checks for false-y values
// (null, false, 0, empty string)
// TODO: This should really be happening at compilation time, rather than generation
// time. Because this is happening at generation time, we get something like
// if (!!x) when if(x) would suffice just so we can get
// foo(!!x) where foo is a method expecting a boolean.
// Doing this at compilation time would allow handling if scenarios specially.
bool optimizable = false;
bool checkForFalse = false;
if (literalExpression.Value is bool)
{
optimizable = true;
bool compareValue = (bool)literalExpression.Value;
if ((compareValue && (expression.Operator == Operator.NotEqualEqual)) ||
(!compareValue && (expression.Operator == Operator.EqualEqualEqual)))
{
checkForFalse = true;
}
}
else if ((literalExpression.Value is int) && (((int)literalExpression.Value) == 0))
{
optimizable = true;
checkForFalse = (expression.Operator == Operator.EqualEqualEqual);
}
else if ((literalExpression.Value is string) && ((string)literalExpression.Value == String.Empty))
{
optimizable = true;
checkForFalse = (expression.Operator == Operator.EqualEqualEqual);
}
if (optimizable)
{
bool parenthesize = false;
writer.Write(checkForFalse ? "!" : "!!");
if ((expression.LeftOperand.Parenthesized == false) &&
((expression.LeftOperand.Type == ExpressionType.Binary) ||
(expression.LeftOperand.Type == ExpressionType.Conditional) ||
(expression.LeftOperand.Type == ExpressionType.InlineScript)))
{
parenthesize = true;
writer.Write("(");
}
GenerateExpression(generator, symbol, expression.LeftOperand);
if (parenthesize)
{
writer.Write(")");
}
return;
}
}
}
GenerateExpression(generator, symbol, expression.LeftOperand);
writer.WriteTrimmed(OperatorConverter.OperatorToString(expression.Operator));
GenerateExpression(generator, symbol, expression.RightOperand);
}
public IEnumerable <KeyValuePair <string, string> > Execute()
{
log.Info(string.Format("Filter operation for '{0}', filter: '{1}' {2} '{3}'.", filter.Table, filter.Column,
OperatorConverter.ToComboString(filter.Operator).ToString(), filter.Value));
// Determine where the filtered column is (is it part of the key, or is it part of the value).
var primaryKey = KeyValue.Split(metadata.Key).ToArray();
var columns = KeyValue.Split(metadata.Value).ToArray();
var filteredColumnInKey = primaryKey.Contains(filter.Column);
int filteredColumnIndex = 0;
if (filteredColumnInKey)
{
for (int i = 0; i < primaryKey.Count(); i++)
{
if (filter.Column.Equals(primaryKey[i]))
{
filteredColumnIndex = i;
break;
}
}
}
else
{
for (int i = 0; i < columns.Count(); i++)
{
if (filter.Column.Equals(columns[i]))
{
filteredColumnIndex = i;
break;
}
}
}
foreach (var row in Predecessor.Execute())
{
// Get the value of the column.
var columnValue = string.Empty;
if (filteredColumnInKey)
{
columnValue = KeyValue.Split(row.Key).ToArray()[filteredColumnIndex];
}
else
{
columnValue = KeyValue.Split(row.Value).ToArray()[filteredColumnIndex];
}
// Check if it satisfies the filter condition.
int comparision = columnValue.CompareTo(filter.Value);
switch (filter.Operator)
{
case Operator.Equal:
if (comparision == 0)
{
yield return(row);
}
break;
case Operator.NotEqual:
if (comparision != 0)
{
yield return(row);
}
break;
case Operator.Less:
if (comparision < 0)
{
yield return(row);
}
break;
case Operator.Greater:
if (comparision > 0)
{
yield return(row);
}
break;
case Operator.LessOrEqual:
if (comparision <= 0)
{
yield return(row);
}
break;
case Operator.GreaterOrEqual:
if (comparision >= 0)
{
yield return(row);
}
break;
}
}
}
