public string FormattedColumnValue(DataRow dataSheetRow, DataSheetSettings settings) { string result = _StaticValue; if (_Index > -1) { result = dataSheetRow[_Index].ToString().Trim(); } if (_StringOperations.Count > 0) { result = _StringOperations.PerformOperations(result); } if (IsNumeric && !Utilities.Data.Utilities.IsNumeric(result)) { result = "0"; } if (_Calculations.Count > 0) { result = _Calculations.PerformCalculations(double.Parse(result), dataSheetRow, settings).ToString(); } if (ConditionalOperation.ConditionType != ConditionalOperation.ConditionTypes.None) { result = ConditionalOperation.PerformOperation(result, dataSheetRow); } result = HandleDateParsing(result); if (result != null) { result = _PreText + result + _PostText; } return(result); }
private static object EvaluateConditionalOperation(ConditionalOperation conditionalOperation, EvaluationContext context) { return(Operations.Conditional( conditionalOperation.Condition, conditionalOperation.TrueExpression, conditionalOperation.FalseExpression, context)); }
public VisualNovelOperation getOperation() { VisualNovelOperation newOperation = conditionalOperation != null ? conditionalOperation : operation; operation = null; conditionalOperation = null; return(newOperation); }
public ConditionalExpression(ConditionalOperation operation, List <ExpressionBase> conditions) : base(ExpressionType.Conditional) { Operation = operation; _conditions = conditions; Location = new TextRange(conditions[0].Location.Start, conditions[conditions.Count - 1].Location.End); }
protected bool SplitConditions(InterpreterScope scope, ConditionalExpression condition, ConditionalOperation joiningOperation, out ExpressionBase result) { var conditions = new List <ExpressionBase>(); SplitConditions(conditions, condition, condition.Operation); ExpressionBase newChain = null; for (int i = 0; i < conditions.Count; i++) { if (!conditions[i].ReplaceVariables(scope, out result)) { return(false); } bool wrap = true; var functionCallExpression = result as FunctionCallExpression; if (functionCallExpression != null) { var functionDefinition = scope.GetFunction(functionCallExpression.FunctionName.Name); if (functionDefinition is FlagConditionFunction) { wrap = false; } } if (wrap) { // no need to force a logical unit when provided as a parameter. // allows ReplaceVariables to further separate it if necessary. result.IsLogicalUnit = false; result = new FunctionCallExpression(Name.Name, new ExpressionBase[] { result }); if (!result.ReplaceVariables(scope, out result)) { return(false); } } if (newChain == null) { newChain = result; } else if (wrap) { newChain = new ConditionalExpression(newChain, joiningOperation, result); } else { newChain = new ConditionalExpression(newChain, condition.Operation, result); } } result = newChain; CopyLocation(result); return(true); }
public void TestAppendString(ConditionalOperation op, string expected) { ExpressionBase variable = (op == ConditionalOperation.Not) ? null : new VariableExpression("variable"); var value = new IntegerConstantExpression(99); var expr = new ConditionalExpression(variable, op, value); var builder = new StringBuilder(); expr.AppendString(builder); Assert.That(builder.ToString(), Is.EqualTo(expected)); }
internal static string GetOperatorString(ConditionalOperation operation) { switch (operation) { case ConditionalOperation.Not: return("!"); case ConditionalOperation.And: return("&&"); case ConditionalOperation.Or: return("||"); default: return(null); } }
public void Load(XmlNode columnNode) { SetProperties(columnNode); if (Index < 0 && !string.IsNullOrEmpty(ColumnLetter)) { Index = Degatech.Utilities.IO.File.Convertors.Excel.ExcelColumnNameToNumber(ColumnLetter) - 1; } else if (Index > -1 && string.IsNullOrEmpty(ColumnLetter)) { ColumnLetter = Degatech.Utilities.IO.File.Convertors.Excel.GetExcelColumnNameFromNumber(Index + 1); } if (columnNode.Attributes["Name"] != null) { _Name = columnNode.Attributes["Name"].Value; } //Load all filters if (columnNode["Filters"] != null) { _Filters.Load(columnNode["Filters"]); } //Load all calculations if (columnNode["Calculations"] != null) { _Calculations.Load(columnNode["Calculations"]); } //Load all string operations if (columnNode["StringOperations"] != null) { _StringOperations.Load(columnNode["StringOperations"]); } //Load conditional operation if (columnNode["ConditionalOperation"] != null) { ConditionalOperation.Load(columnNode["ConditionalOperation"]); } }
private static void EmitLopPredWrite(EmitterContext context, IOpCodeLop op, Operand result, ConditionalOperation condOp) { if (op is OpCodeLop opLop && !opLop.Predicate48.IsPT) { Operand pRes; if (condOp == ConditionalOperation.False) { pRes = Const(IrConsts.False); } else if (condOp == ConditionalOperation.True) { pRes = Const(IrConsts.True); } else if (condOp == ConditionalOperation.Zero) { pRes = context.ICompareEqual(result, Const(0)); } else /* if (opLop.CondOp == ConditionalOperation.NotZero) */ { pRes = context.ICompareNotEqual(result, Const(0)); } context.Copy(Register(opLop.Predicate48), pRes); } }
public ConditionalExpression(ExpressionBase left, ConditionalOperation operation, ExpressionBase right) : base(left, right, ExpressionType.Conditional) { Operation = operation; }
private static void SplitConditions(List <ExpressionBase> conditions, ExpressionBase expression, ConditionalOperation op) { var condition = expression as ConditionalExpression; if (condition != null && condition.Operation == op) { foreach (var clause in condition.Conditions) { SplitConditions(conditions, clause, op); } } else { conditions.Add(expression); } }
public VisualNovelOperationBuilder(string novelPath) { this.novelPath = novelPath; operation = null; conditionalOperation = null; }
public void parseIf(string[] tokens) { multiline = true; conditionalOperation = new ConditionalOperation(tokens); }
public ConditionalExpression(ExpressionBase left, ConditionalOperation operation, ExpressionBase right) : base(ExpressionType.Conditional) { Operation = operation; if (operation == ConditionalOperation.Not) { Debug.Assert(left == null); Debug.Assert(right != null); _conditions = new List <ExpressionBase>() { right }; } else { Debug.Assert(left != null); Debug.Assert(right != null); int length = 0; var conditionalLeft = left as ConditionalExpression; bool mergeLeft = (conditionalLeft != null && conditionalLeft.Operation == operation); if (mergeLeft) { length += conditionalLeft._conditions.Count; } else { length += 1; } var conditionalRight = right as ConditionalExpression; bool mergeRight = (conditionalRight != null && conditionalRight.Operation == operation); if (mergeRight) { length += conditionalRight._conditions.Count; } else { length += 1; } _conditions = new List <ExpressionBase>(length); if (mergeLeft) { _conditions.AddRange(conditionalLeft.Conditions); } else { _conditions.Add(left); } if (mergeRight) { _conditions.AddRange(conditionalRight.Conditions); } else { _conditions.Add(right); } } if (left != null) { Location = new TextRange(left.Location.Start, right.Location.End); } else { Location = right.Location; } }
private static ExpressionBase ParseConditional(PositionalTokenizer tokenizer, ExpressionBase left, ConditionalOperation operation, int joinerLine, int joinerColumn) { OperationPriority priority; switch (operation) { case ConditionalOperation.And: priority = OperationPriority.And; break; case ConditionalOperation.Or: priority = OperationPriority.Or; break; case ConditionalOperation.Not: priority = OperationPriority.Not; break; default: return(new ParseErrorExpression("Unknown operation: " + operation)); } var right = ParseExpression(tokenizer, priority); switch (right.Type) { case ExpressionType.ParseError: return(right); case ExpressionType.BooleanConstant: case ExpressionType.Comparison: case ExpressionType.Conditional: case ExpressionType.FunctionCall: case ExpressionType.Variable: break; default: var expressionTokenizer = tokenizer as ExpressionTokenizer; if (expressionTokenizer != null) { expressionTokenizer.QueueExpression(right); } right = new KeywordExpression(ConditionalExpression.GetOperatorString(operation), joinerLine, joinerColumn); return(ParseError(tokenizer, "Incompatible logical condition", right)); } return(new ConditionalExpression(left, operation, right)); }
private static ExpressionBase ParseConditional(PositionalTokenizer tokenizer, ExpressionBase left, ConditionalOperation operation, int joinerLine, int joinerColumn) { var right = ExpressionBase.Parse(tokenizer); switch (right.Type) { case ExpressionType.ParseError: return(right); case ExpressionType.Comparison: case ExpressionType.Conditional: case ExpressionType.FunctionCall: case ExpressionType.Variable: break; default: ParseError(tokenizer, "incompatible logical condition", new KeywordExpression(ConditionalExpression.GetOperatorString(operation), joinerLine, joinerColumn)); break; } return(new ConditionalExpression(left, operation, right)); }