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