public static IExpressionBuilder GetBashConditionalExpressionBuilder(Context context, Scope scope, ref EvaluationStatement evalStt) { evalStt = ProcessEvaluation(context, scope, evalStt); return(BashConditionalExpressionBuilder.Instance); }
public ExpressionResult(TypeDescriptor typeDescriptor, string expression, EvaluationStatement template) { TypeDescriptor = typeDescriptor; Expression = expression; Template = template; Notices = null; }
public IncludeStatement(EvaluationStatement target, StatementInfo info) { Target = target; Info = info; TraversableChildren = StatementHelpers.CreateChildren(target); }
public override bool ShouldBePinnedToFloatingPointVariable( ExpressionBuilderParams p, EvaluationStatement template, ExpressionResult left, ExpressionResult right) { if (left.TypeDescriptor.IsNumericOrFloat() || right.TypeDescriptor.IsNumericOrFloat()) { if (template is LogicalEvaluationStatement) { return(true); } var parent = template.ParentStatement; if (parent is VariableDefinitionStatement) { return(false); } if (parent is ArithmeticEvaluationStatement arithmeticEvaluationStatement && arithmeticEvaluationStatement.Operator is AdditionOperator) { return(arithmeticEvaluationStatement.Left.GetDataType(p.Context, p.Scope).IsString() || arithmeticEvaluationStatement.Right.GetDataType(p.Context, p.Scope).IsString()); } if (parent is FunctionCallStatement) { return(true); } return(!(parent is EvaluationStatement)); } return(false); }
public override PinnedVariableResult PinFloatingPointExpressionToVariable( ExpressionBuilderParams p, TypeDescriptor typeDescriptor, string nameHint, string expression, EvaluationStatement template) { var variableName = p.Scope.NewHelperVariable(typeDescriptor, nameHint); expression = $"`awk \"BEGIN {{print ({expression})}}\"`"; BashVariableDefinitionStatementTranspiler.WriteVariableDefinition( p.Context, p.Scope, p.NonInlinePartWriter, variableName, expression ); template = new VariableAccessStatement(variableName, template.Info); return(new PinnedVariableResult( typeDescriptor, variableName, FormatVariableAccessExpression(p, typeDescriptor, variableName, template ), template)); }
public ReturnStatement(EvaluationStatement result, StatementInfo info) { Result = result; Info = info; TraversableChildren = StatementHelpers.CreateChildren(result); }
public override string FormatVariableAccessExpression(ExpressionBuilderParams p, TypeDescriptor typeDescriptor, string expression, EvaluationStatement template) { //$10 should be surrounded by braces or it will considered $1 followed by a zero var exp = expression.All(char.IsDigit) && expression.Length > 1 ? $"${{{expression}}}" : '$' + expression; if (!typeDescriptor.IsString()) { return(exp); } if (template.ParentStatement is ArithmeticEvaluationStatement arithmeticEvaluationStatement && arithmeticEvaluationStatement.Operator is AdditionOperator) { return(exp); } // if (template.ParentStatement is AssignmentStatement || // template.ParentStatement is VariableDefinitionStatement) // { // return $"\"{base.FormatVariableAccessExpression(p, dataType, expression, template)}\""; // } return(StringHelpers.EnQuote(exp)); }
public override void WriteBlock(Context context, Scope scope, TextWriter writer, TextWriter metaWriter, IStatement statement) { if (!(statement is FunctionCallStatement functionCallStatement)) { throw new InvalidOperationException(); } var blockUsageContext = new BlockStatement(new[] { statement }, statement.Info); EvaluationStatement evalStt = functionCallStatement; var result = GetExpression(context, scope, metaWriter, writer, blockUsageContext, evalStt); if (result.IsEmptyResult) { return; } if (result.TypeDescriptor.IsVoid() && !(result.Template is FunctionCallStatement)) { writer.WriteLine(result.Expression); } else if (result.TypeDescriptor.IsArray()) { writer.WriteLine(result.Expression.Trim('`')); } else { var resultVar = context.GetLastFunctionCallStorageVariable(result.TypeDescriptor, metaWriter); writer.WriteLine($"{resultVar}={result.Expression}"); } scope.IncrementStatements(); }
public static ExpressionResult CreateBashConditionalExpression(ExpressionBuilderParams p, EvaluationStatement evalStt) { evalStt = ProcessEvaluation(p.Context, p.Scope, evalStt); return(BashConditionalExpressionBuilder.Instance.CreateExpression(p, evalStt)); }
public ConditionalBlockStatement(EvaluationStatement condition, IStatement statement, StatementInfo info) { Condition = condition; Statement = statement; Info = info; TraversableChildren = StatementHelpers.CreateChildren(condition, statement); }
public PinnedVariableResult(TypeDescriptor typeDescriptor, string name, string expression, EvaluationStatement template) { TypeDescriptor = typeDescriptor; Name = name; Expression = expression; Template = template; }
public IndexerAccessStatement(EvaluationStatement source, EvaluationStatement indexer, StatementInfo info) { Source = source; Indexer = indexer; Info = info; TraversableChildren = StatementHelpers.CreateChildren(source, indexer); }
public ForEachStatement(IStatement variable, EvaluationStatement iterator, IStatement statement, StatementInfo info) { Variable = variable; Iterator = iterator; Statement = statement; Info = info; TraversableChildren = StatementHelpers.CreateChildren(variable, iterator, statement); }
public override string FormatLogicalExpression(ExpressionBuilderParams p, ExpressionResult left, IOperator op, ExpressionResult right, EvaluationStatement template) { return(FormatLogicalExpression(p, left.TypeDescriptor, left.Expression, op, right.TypeDescriptor, right.Expression, template)); }
public AssignmentStatement(EvaluationStatement leftSide, EvaluationStatement rightSide, StatementInfo info, IStatement parentStatement = null) { LeftSide = leftSide; RightSide = rightSide; Info = info; ParentStatement = parentStatement; TraversableChildren = StatementHelpers.CreateChildren(leftSide, rightSide); }
public override string FormatVariableAccessExpression(ExpressionBuilderParams p, TypeDescriptor typeDescriptor, string expression, EvaluationStatement template) { if (typeDescriptor.IsBoolean() && template.ParentStatement is ConditionalBlockStatement) { return(_formatBoolVariable( base.FormatVariableAccessExpression(p, typeDescriptor, expression, template) )); } return(base.FormatVariableAccessExpression(p, typeDescriptor, expression, template)); }
public override void WriteInline(Context context, Scope scope, TextWriter writer, TextWriter metaWriter, TextWriter nonInlinePartWriter, IStatement statement) { if (!(statement is FunctionCallStatement functionCallStatement)) { throw new InvalidOperationException(); } EvaluationStatement evalStt = functionCallStatement; var result = GetExpression(context, scope, metaWriter, nonInlinePartWriter, null, evalStt); writer.Write(result.Expression); }
public override ExpressionResult CreateExpression(ExpressionBuilderParams p, EvaluationStatement statement) { var result = base.CreateExpression(p, statement); if (result.IsEmptyResult) { throw new InvalidStatementStructureCompilerException(statement, statement.Info); } if (!result.TypeDescriptor.IsBoolean()) { throw new TypeMismatchCompilerException(result.TypeDescriptor, TypeDescriptor.Boolean, statement.Info); } return(result); }
public override string FormatConstantExpression(ExpressionBuilderParams p, TypeDescriptor typeDescriptor, string expression, EvaluationStatement template) { if (template is ConstantValueStatement constantValueStatement) { if (typeDescriptor.IsBoolean()) { if (!StatementHelpers.TryParseBooleanFromString(constantValueStatement.Value, out var boolResult)) { throw new InvalidStatementStructureCompilerException(template, template.Info); } return(boolResult ? "1" : "0"); } if (constantValueStatement.IsString() || constantValueStatement.IsDelegate()) { if (template.ParentStatement is ArithmeticEvaluationStatement arithmeticEvaluationStatement) { if (arithmeticEvaluationStatement.Operator is AdditionOperator) { if (p.FormatString) { return(BashTranspilerHelpers.ToBashString(constantValueStatement.Value, true, false)); } } else { throw new InvalidStatementStructureCompilerException(arithmeticEvaluationStatement, arithmeticEvaluationStatement.Info); } } return(base.FormatConstantExpression(p, typeDescriptor, expression, template)); } } return(base.FormatConstantExpression(p, typeDescriptor, expression, template)); }
public IPlatformEvaluationStatementTranspiler GetEvaluationTranspilerForStatement(EvaluationStatement statement) { var sttType = statement.GetType(); if (_typeTranspilers.TryGetValue(statement.GetType(), out var value)) { return(value as IPlatformEvaluationStatementTranspiler); } if (_fallbackType.TryGetValue(sttType, out sttType)) { if (_typeTranspilers.TryGetValue(sttType, out value)) { return(value as IPlatformEvaluationStatementTranspiler); } } throw new InvalidOperationException(); }
public static InvalidStatementStructureCompilerException InvalidStatementStructure(Scope scope, EvaluationStatement statement) { return(new InvalidStatementStructureCompilerException(statement, statement?.Info)); }
public static bool ReplaceEvaluation(IStatement statement, Predicate <string> predicate, Func <string, EvaluationStatement> replace, out IStatement result) { switch (statement) { case ConstantValueStatement _: { result = statement; return(false); } case VariableAccessStatement variableAccessStatement: { if (predicate(variableAccessStatement.VariableName)) { var replaceValue = replace(variableAccessStatement.VariableName); replaceValue.ParentStatement = variableAccessStatement.ParentStatement; result = replaceValue; return(true); } result = variableAccessStatement; return(false); } case BitwiseEvaluationStatement bitwiseEvaluationStatement: { if (bitwiseEvaluationStatement.Operator is BitwiseNotOperator bitwiseNotOperator) { if (ReplaceEvaluation(bitwiseEvaluationStatement.Right, predicate, replace, out var right)) { result = BitwiseEvaluationStatement.CreateNot(bitwiseNotOperator, (EvaluationStatement)right, bitwiseEvaluationStatement.Info, bitwiseEvaluationStatement.ParentStatement); return(true); } } else { if (ReplaceEvaluation(bitwiseEvaluationStatement.Left, predicate, replace, out var left) | ReplaceEvaluation(bitwiseEvaluationStatement.Right, predicate, replace, out var right)) { result = new BitwiseEvaluationStatement((EvaluationStatement)left, bitwiseEvaluationStatement.Operator, (EvaluationStatement)right, bitwiseEvaluationStatement.Info, bitwiseEvaluationStatement.ParentStatement); return(true); } } break; } case LogicalEvaluationStatement logicalEvaluationStatement: { if (logicalEvaluationStatement.Operator is NotOperator logicalNotOperator) { if (ReplaceEvaluation(logicalEvaluationStatement.Right, predicate, replace, out var right)) { result = LogicalEvaluationStatement.CreateNot(logicalNotOperator, (EvaluationStatement)right, logicalEvaluationStatement.Info, logicalEvaluationStatement.ParentStatement); return(true); } } else { if (ReplaceEvaluation(logicalEvaluationStatement.Left, predicate, replace, out var left) | ReplaceEvaluation(logicalEvaluationStatement.Right, predicate, replace, out var right)) { result = new LogicalEvaluationStatement((EvaluationStatement)left, logicalEvaluationStatement.Operator, (EvaluationStatement)right, logicalEvaluationStatement.Info, logicalEvaluationStatement.ParentStatement); return(true); } } break; } case ArithmeticEvaluationStatement arithmeticEvaluationStatement: { switch (arithmeticEvaluationStatement.Operator) { case NegativeNumberOperator negativeNumberOperator: { if (ReplaceEvaluation(arithmeticEvaluationStatement.Right, predicate, replace, out var right)) { result = ArithmeticEvaluationStatement.CreateNegate(negativeNumberOperator, (EvaluationStatement)right, arithmeticEvaluationStatement.Info, arithmeticEvaluationStatement.ParentStatement); return(true); } break; } case IncrementOperator _: case DecrementOperator _: { EvaluationStatement operand; bool isPostfix; if (arithmeticEvaluationStatement.Left == null) { operand = arithmeticEvaluationStatement.Right; isPostfix = false; } else if (arithmeticEvaluationStatement.Right == null) { operand = arithmeticEvaluationStatement.Left; isPostfix = true; } else { throw new InvalidOperationException(); } if (ReplaceEvaluation(operand, predicate, replace, out var replacedOperand)) { result = isPostfix ? ArithmeticEvaluationStatement.CreatePostfix( arithmeticEvaluationStatement.Operator, (EvaluationStatement)replacedOperand, arithmeticEvaluationStatement.Info, arithmeticEvaluationStatement.ParentStatement) : ArithmeticEvaluationStatement.CreatePrefix(arithmeticEvaluationStatement.Operator, (EvaluationStatement)replacedOperand, arithmeticEvaluationStatement.Info, arithmeticEvaluationStatement.ParentStatement); return(true); } break; } default: { if (ReplaceEvaluation(arithmeticEvaluationStatement.Left, predicate, replace, out var left) | ReplaceEvaluation(arithmeticEvaluationStatement.Right, predicate, replace, out var right)) { result = new ArithmeticEvaluationStatement((EvaluationStatement)left, arithmeticEvaluationStatement.Operator, (EvaluationStatement)right, arithmeticEvaluationStatement.Info, arithmeticEvaluationStatement.ParentStatement); return(true); } break; } } break; } case TypeCastStatement typeCastStatement: { if (ReplaceEvaluation(typeCastStatement.Target, predicate, replace, out var right)) { result = new TypeCastStatement(typeCastStatement.TypeDescriptor, (EvaluationStatement)right, typeCastStatement.Info, typeCastStatement.ParentStatement); return(true); } break; } case AssignmentStatement assignmentStatement: { if (ReplaceEvaluation(assignmentStatement.LeftSide, predicate, replace, out var left) | ReplaceEvaluation(assignmentStatement.RightSide, predicate, replace, out var right)) { result = new AssignmentStatement((EvaluationStatement)left, (EvaluationStatement)right, assignmentStatement.Info, assignmentStatement.ParentStatement); return(true); } break; } case IndexerOperator indexerOperator: { throw new NotImplementedException(); } case ArrayStatement arrayStatement: { throw new NotImplementedException(); } case FunctionCallStatement functionCallStatement: { var parameters = functionCallStatement.Parameters; if (parameters != null) { var isReplaced = false; var newParameters = new EvaluationStatement[parameters.Length]; for (var i = 0; i < parameters.Length; i++) { if (ReplaceEvaluation(parameters[i], predicate, replace, out var newP)) { newParameters[i] = (EvaluationStatement)newP; isReplaced = true; } } if (isReplaced) { result = new FunctionCallStatement(functionCallStatement.ClassName, functionCallStatement.FunctionName, functionCallStatement.TypeDescriptor, newParameters, functionCallStatement.Info, functionCallStatement.ParentStatement); return(true); } } break; } case EchoStatement echoStatement: { var parameters = echoStatement.Parameters; if (parameters != null) { var isReplaced = false; var newParameters = new EvaluationStatement[parameters.Length]; for (var i = 0; i < parameters.Length; i++) { if (ReplaceEvaluation(parameters[i], predicate, replace, out var newP)) { newParameters[i] = (EvaluationStatement)newP; isReplaced = true; } } if (isReplaced) { result = new EchoStatement(newParameters, echoStatement.Info); return(true); } } break; } case ForStatement forStatement: { throw new NotImplementedException(); } case ForEachStatement forEachStatement: { throw new NotImplementedException(); } case WhileStatement whileStatement: { throw new NotImplementedException(); } case DoWhileStatement doWhileStatement: { throw new NotImplementedException(); } case ConditionalBlockStatement conditionalBlockStatement: { if (ReplaceEvaluation(conditionalBlockStatement.Condition, predicate, replace, out var condition) | ReplaceEvaluation(conditionalBlockStatement.Statement, predicate, replace, out var stt)) { result = new ConditionalBlockStatement((EvaluationStatement)condition, stt, conditionalBlockStatement.Info); return(true); } break; } case IfElseStatement ifElseStatement: { var isChanged = ReplaceEvaluation(ifElseStatement.MainIf, predicate, replace, out var mainIf); var elseIfs = new List <ConditionalBlockStatement>(); if (ifElseStatement.ElseIfs != null && ifElseStatement.ElseIfs.Length > 0) { foreach (var ei in ifElseStatement.ElseIfs) { isChanged |= ReplaceEvaluation(ei, predicate, replace, out var newEi); elseIfs.Add((ConditionalBlockStatement)newEi); } } IStatement newElse = null; if (ifElseStatement.Else != null) { isChanged |= ReplaceEvaluation(ifElseStatement.Else, predicate, replace, out newElse); } if (isChanged) { result = new IfElseStatement((ConditionalBlockStatement)mainIf, elseIfs.Count == 0 ? null : elseIfs.ToArray(), newElse, ifElseStatement.Info); return(true); } break; } case ReturnStatement returnStatement: { if (ReplaceEvaluation(returnStatement.Result, predicate, replace, out var newResult)) { result = new ReturnStatement((EvaluationStatement)newResult, returnStatement.Info); return(true); } break; } case VariableDefinitionStatement variableDefinitionStatement: { if (variableDefinitionStatement.DefaultValue != null && ReplaceEvaluation(variableDefinitionStatement.DefaultValue, predicate, replace, out var newResult)) { result = new VariableDefinitionStatement(variableDefinitionStatement.TypeDescriptor, variableDefinitionStatement.Name, variableDefinitionStatement.IsConstant, (EvaluationStatement)newResult, variableDefinitionStatement.Info); return(true); } break; } case SwitchCaseStatement switchCaseStatement: { var isChanged = ReplaceEvaluation(switchCaseStatement.SwitchTarget, predicate, replace, out var switchTarget); var cases = new List <ConditionalBlockStatement>(); if (switchCaseStatement.Cases != null && switchCaseStatement.Cases.Length > 0) { foreach (var sCase in switchCaseStatement.Cases) { isChanged |= ReplaceEvaluation(sCase, predicate, replace, out var newCase); cases.Add((ConditionalBlockStatement)newCase); } } IStatement newDefaultCase = null; if (switchCaseStatement.DefaultCase != null) { isChanged |= ReplaceEvaluation(switchCaseStatement.DefaultCase, predicate, replace, out newDefaultCase); } if (isChanged) { result = new SwitchCaseStatement((EvaluationStatement)switchTarget, cases.Count == 0 ? null : cases.ToArray(), newDefaultCase, switchCaseStatement.Info); return(true); } break; } case BlockStatement blockStatement: { var isChanged = false; var statements = new List <IStatement>(); foreach (var stt in blockStatement.Statements) { isChanged |= ReplaceEvaluation(stt, predicate, replace, out var newStt); statements.Add(newStt); } if (isChanged) { result = new BlockStatement(statements.ToArray(), blockStatement.Info); return(true); } break; } } result = statement; return(false); }
public override string FormatFunctionCallExpression(ExpressionBuilderParams p, TypeDescriptor typeDescriptor, string expression, EvaluationStatement template) { return(expression); //$"{expression}"; }
protected override ExpressionResult CreateExpressionRecursive(ExpressionBuilderParams p, EvaluationStatement statement) { switch (statement) { case LogicalEvaluationStatement logicalEvaluationStatement: { if (p.UsageContext is IfElseStatement) { break; } switch (logicalEvaluationStatement.Operator) { case EqualOperator _: case NotEqualOperator _: { using (var writer = new StringWriter()) { var expressionBuilderParams = new ExpressionBuilderParams(p, writer); var leftResult = CreateExpressionRecursive(expressionBuilderParams, logicalEvaluationStatement.Left); var rightResult = CreateExpressionRecursive(expressionBuilderParams, logicalEvaluationStatement.Right); if (leftResult.TypeDescriptor.IsString() && rightResult.TypeDescriptor.IsString()) { HandleNotices(expressionBuilderParams, ref leftResult, ref rightResult); expressionBuilderParams.NonInlinePartWriter.WriteLine( $"[ {leftResult.Expression} {logicalEvaluationStatement.Operator} {rightResult.Expression} ]"); string varName; if (logicalEvaluationStatement.ParentStatement is AssignmentStatement || logicalEvaluationStatement.ParentStatement is VariableDefinitionStatement) { varName = UnixBashPlatform.LastStatusCodeStoreVariableName; } else { varName = BashVariableDefinitionStatementTranspiler .WriteLastStatusCodeStoreVariableDefinition(expressionBuilderParams.Context, expressionBuilderParams.Scope, expressionBuilderParams.NonInlinePartWriter, "cmp_strings"); } var template = new VariableAccessStatement( varName, logicalEvaluationStatement.Info ); p.NonInlinePartWriter.Write(writer); return(new ExpressionResult( TypeDescriptor.Boolean, $"${varName}", template, PinRequiredNotice )); } } break; } } break; } case ArithmeticEvaluationStatement arithmeticEvaluationStatement: { switch (arithmeticEvaluationStatement.Operator) { case AdditionOperator _: { using (var writer = new StringWriter()) { var expressionBuilderParams = new ExpressionBuilderParams(p, writer); var leftResult = CreateExpressionRecursive(expressionBuilderParams, arithmeticEvaluationStatement.Left); var rightResult = CreateExpressionRecursive(expressionBuilderParams, arithmeticEvaluationStatement.Right); if (leftResult.TypeDescriptor.IsString() || rightResult.TypeDescriptor.IsString()) { HandleNotices(expressionBuilderParams, ref leftResult, ref rightResult); var leftExp = leftResult.Expression; var rightExp = rightResult.Expression; if (leftResult.Template is VariableAccessStatement) { leftExp = FormatStringConcatenationVariableAccess(leftExp); } if (rightResult.Template is VariableAccessStatement) { rightExp = FormatStringConcatenationVariableAccess(rightExp); } if (!leftResult.TypeDescriptor.IsString() && !(leftResult.Template is VariableAccessStatement)) { leftExp = $"$(({leftExp}))"; } if (!rightResult.TypeDescriptor.IsString() && !(rightResult.Template is VariableAccessStatement)) { rightExp = $"$(({rightExp}))"; } var concatExp = $"{leftExp}{rightExp}"; var newTemp = new ArithmeticEvaluationStatement( leftResult.Template, arithmeticEvaluationStatement.Operator, rightResult.Template, arithmeticEvaluationStatement.Info ); leftResult.Template.ParentStatement = newTemp; rightResult.Template.ParentStatement = newTemp; p.NonInlinePartWriter.Write(writer); return(new ExpressionResult( TypeDescriptor.String, concatExp, newTemp )); } } break; } } break; } case ArrayStatement arrayStatement: { string sourceName; if (arrayStatement.ParentStatement is VariableDefinitionStatement variableDefinitionStatement) { sourceName = variableDefinitionStatement.Name; } else if (arrayStatement.ParentStatement is AssignmentStatement assignmentStatement) { if (!(assignmentStatement.LeftSide is VariableAccessStatement variableAccessStatement)) { throw new InvalidStatementStructureCompilerException(assignmentStatement, assignmentStatement.Info); } sourceName = variableAccessStatement.VariableName; } else if (arrayStatement.ParentStatement is ReturnStatement returnStatement) { sourceName = p.Context.GetLastFunctionCallStorageVariable(arrayStatement.Type, p.MetaWriter); } else { sourceName = p.Scope.NewHelperVariable(arrayStatement.Type, "array_helper"); } if (arrayStatement.Elements != null) { for (var i = 0; i < arrayStatement.Elements.Length; i++) { p.NonInlinePartWriter.Write($"{sourceName}[{i}]="); var element = CreateExpression(p, arrayStatement.Elements[i]); p.NonInlinePartWriter.WriteLine(element); } return(ExpressionResult.EmptyResult); } if (arrayStatement.Length != null) { var sourceNameEval = new VariableAccessStatement(sourceName, arrayStatement.Info); return(CallApiFunction <ApiArray.Initialize>(p, new[] { sourceNameEval, arrayStatement.Length }, arrayStatement.ParentStatement, arrayStatement.Info)); } throw new InvalidStatementStructureCompilerException(arrayStatement, arrayStatement.Info); } } return(base.CreateExpressionRecursive(p, statement)); }
public DoWhileStatement(EvaluationStatement condition, IStatement statement, StatementInfo info) : base(condition, statement, info) { }
public override ExpressionResult GetExpression(ExpressionBuilderParams p, EvaluationStatement statement) => CreateBashExpression(p, statement);
public override PinnedVariableResult PinEvaluationToVariable(Context context, Scope scope, TextWriter metaWriter, TextWriter pinCodeWriter, EvaluationStatement statement) { if (statement == null) { throw new ArgumentNullException(nameof(statement)); } var expressionBuilder = GetBashExpressionBuilder(context, scope, ref statement); var parameters = new ExpressionBuilderParams(context, scope, metaWriter, pinCodeWriter, null); var result = expressionBuilder.CreateExpression(parameters, statement); return(expressionBuilder.PinExpressionToVariable(parameters, null, result)); }
// public override string FormatLogicalExpression(ExpressionBuilderParams p, ExpressionResult result) // { // return base.FormatLogicalExpression(p, result); // } public override string FormatLogicalExpression(ExpressionBuilderParams p, TypeDescriptor leftTypeDescriptor, string left, IOperator op, TypeDescriptor rightTypeDescriptor, string right, EvaluationStatement template) { if (!(template is LogicalEvaluationStatement logicalEvaluationStatement)) { throw new InvalidOperationException(); } string opStr; if (leftTypeDescriptor.IsString() || rightTypeDescriptor.IsString()) { return(base.FormatLogicalExpression(p, leftTypeDescriptor, left, op, rightTypeDescriptor, right, template)); } if (leftTypeDescriptor.IsNumericOrFloat() || rightTypeDescriptor.IsNumericOrFloat()) { return(base.FormatLogicalExpression(p, leftTypeDescriptor, left, op, rightTypeDescriptor, right, template)); } var operatorNeedsToEvaluate = false; switch (op) { case EqualOperator _: { opStr = "-eq"; break; } case NotEqualOperator _: { opStr = "-ne"; break; } case GreaterOperator _: { opStr = "-gt"; break; } case GreaterEqualOperator _: { opStr = "-ge"; break; } case LessOperator _: { opStr = "-lt"; break; } case LessEqualOperator _: { opStr = "-le"; break; } default: opStr = op.ToString(); operatorNeedsToEvaluate = true; break; } left = _createBoolExpression(leftTypeDescriptor, left, logicalEvaluationStatement.Left, operatorNeedsToEvaluate); right = _createBoolExpression(rightTypeDescriptor, right, logicalEvaluationStatement.Right, operatorNeedsToEvaluate); return($"{left} {opStr} {right}"); }
public override ExpressionResult GetExpression(Context context, Scope scope, TextWriter metaWriter, TextWriter nonInlinePartWriter, IStatement usageContext, EvaluationStatement statement) => CreateBashExpression( new ExpressionBuilderParams(context, scope, metaWriter, nonInlinePartWriter, usageContext), statement);
public static ApiMethodBuilderInlineResult Inline(EvaluationStatement statement) { return(new ApiMethodBuilderInlineResult(statement)); }