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));
}
