public static IApiMethodBuilderResult CreateTestExpression(ApiBaseFunction func, ExpressionBuilderParams p, FunctionCallStatement functionCallStatement, TestExpressionCreator createTestExpression) { func.AssertParameters(p, functionCallStatement.Parameters); var result = createTestExpression(p, functionCallStatement); if (p.UsageContext is IfElseStatement) { return(new ApiMethodBuilderRawResult(new ExpressionResult( func.TypeDescriptor, result.Expression, result.Template ))); } p.NonInlinePartWriter.WriteLine(result.Expression); var varName = BashVariableDefinitionStatementTranspiler.WriteLastStatusCodeStoreVariableDefinition( p.Context, p.Scope, p.NonInlinePartWriter, $"{functionCallStatement.Fqn}_Result"); return(new ApiMethodBuilderRawResult(new ExpressionResult( func.TypeDescriptor, $"${varName}", new VariableAccessStatement(varName, functionCallStatement.Info), ExpressionBuilderBase.PinRequiredNotice ))); }
public override IApiMethodBuilderResult Build(ExpressionBuilderParams p, FunctionCallStatement functionCallStatement) { AssertParameters(p, functionCallStatement.Parameters); var param = functionCallStatement.Parameters[0]; var dt = param.GetDataType(p.Context, p.Scope); EvaluationStatement exp; if (dt.IsBoolean() || dt.IsNumber()) { //create an string concatenation expression, ExpressionBuilder has this functionality inside. exp = new ArithmeticEvaluationStatement(param, new AdditionOperator(param.Info), new ConstantValueStatement(TypeDescriptor.String, "", param.Info), param.Info, param.ParentStatement); param.ParentStatement = exp; } else if (dt.IsString()) { exp = param; } else { throw new MethodParameterMismatchCompilerException(Name, functionCallStatement.Info); } var transpiler = p.Context.GetEvaluationTranspilerForStatement(exp); var result = transpiler.GetExpression(p, exp); return(new ApiMethodBuilderRawResult(result)); }
void IStatementVisitor.Visit(FunctionCallStatement statement) { statement.FunctionCall.AcceptInternal(this); if (statement.FunctionCall.ResultType != DataType.None) { generator.Emit(OpCodes.Pop); } }
public override IApiMethodBuilderResult Build(ExpressionBuilderParams p, FunctionCallStatement functionCallStatement) { AssertParameters(p, functionCallStatement.Parameters); var result = CreateVariableAccess(TypeDescriptor, "LANG", functionCallStatement.Info); return(new ApiMethodBuilderRawResult(result)); }
public override IApiMethodBuilderResult Build(ExpressionBuilderParams p, FunctionCallStatement functionCallStatement) { return(BashTestCommand.CreateTestExpression(this, p, functionCallStatement, (p1, fcs) => new ExpressionResult( TypeDescriptor, $"[ $(whoami) == 'root' ]", functionCallStatement ))); }
public override IApiMethodBuilderResult Build(ExpressionBuilderParams p, FunctionCallStatement functionCallStatement) { AssertParameters(p, functionCallStatement.Parameters); var param = functionCallStatement.Parameters[0]; var transpiler = p.Context.GetEvaluationTranspilerForStatement(param); var result = transpiler.GetExpression(p, param); return(new ApiMethodBuilderRawResult(result)); }
public bool IsIdentifierExists(FunctionCallStatement functionCallStatement) { var that = this; do { if (that._identifiers.Contains(functionCallStatement.Fqn)) { return(true); } } while ((that = that.Parent) != null); return(false); }
public override IApiMethodBuilderResult Build(ExpressionBuilderParams p, FunctionCallStatement functionCallStatement) { AssertParameters(p, functionCallStatement.Parameters); var number = functionCallStatement.Parameters[0]; switch (number) { case ConstantValueStatement constantValueStatement: { return(InlineConstant(constantValueStatement.TypeDescriptor, constantValueStatement.Value, constantValueStatement)); } case VariableAccessStatement variableAccessStatement: { if (p.Scope.TryGetVariableInfo(variableAccessStatement, out var varInfo)) { if (varInfo.TypeDescriptor.IsInteger()) { return(new ApiMethodBuilderRawResult(new ExpressionResult( varInfo.TypeDescriptor, $"${{{varInfo.AccessName}#-}}", variableAccessStatement ))); } return(CreateNativeMethodWithUtilityExpressionSelector(this, p, _functionInfo, _absUtilityExpressions, functionCallStatement.Parameters, functionCallStatement.Info)); } if (p.Scope.TryGetConstantInfo(variableAccessStatement, out var constInfo)) { return(InlineConstant(constInfo.TypeDescriptor, constInfo.Value, variableAccessStatement)); } throw new IdentifierNotFoundCompilerException(variableAccessStatement); } default: { return(CreateNativeMethodWithUtilityExpressionSelector(this, p, _functionInfo, _absUtilityExpressions, functionCallStatement.Parameters, functionCallStatement.Info)); } } }
public bool TryGetVariableInfo(FunctionCallStatement functionCallStatement, out VariableInfo variableInfo) { var varInfo = new VariableInfo(functionCallStatement.ClassName, functionCallStatement.FunctionName); var that = this; do { if (that._variables.TryGetValue(varInfo, out variableInfo)) { return(true); } } while ((that = that.Parent) != null); return(false); }
public bool TryGetFunctionInfo(FunctionCallStatement functionCallStatement, out FunctionInfo functionInfo) { var funcInfo = new FunctionInfo(functionCallStatement.ClassName, functionCallStatement.FunctionName); var that = this; do { if (that._functions.TryGetValue(funcInfo, out functionInfo)) { return(true); } } while ((that = that.Parent) != null); return(false); }
public override IApiMethodBuilderResult Build(ExpressionBuilderParams p, FunctionCallStatement functionCallStatement) { AssertParameters(p, functionCallStatement.Parameters); var str = functionCallStatement.Parameters[0]; switch (str) { case ConstantValueStatement constantValueStatement: { return(InlineConstant(constantValueStatement.TypeDescriptor, constantValueStatement.Value, constantValueStatement)); } case VariableAccessStatement variableAccessStatement: { if (p.Scope.TryGetVariableInfo(variableAccessStatement, out var varInfo)) { if (varInfo.TypeDescriptor.IsString()) { return(new ApiMethodBuilderRawResult(new ExpressionResult( TypeDescriptor, $"${{#{varInfo.AccessName}}}", variableAccessStatement ))); } throw new TypeMismatchCompilerException(varInfo.TypeDescriptor, TypeDescriptor.String, variableAccessStatement.Info); } if (p.Scope.TryGetConstantInfo(variableAccessStatement, out var constInfo)) { return(InlineConstant(constInfo.TypeDescriptor, constInfo.Value, variableAccessStatement)); } throw new IdentifierNotFoundCompilerException(variableAccessStatement); } default: { return(WriteNativeMethod(this, p, "echo ${#1}", _functionInfo, functionCallStatement.Parameters, functionCallStatement.Info)); } } }
public override IApiMethodBuilderResult Build(ExpressionBuilderParams p, FunctionCallStatement functionCallStatement) { AssertParameters(p, functionCallStatement.Parameters); var number = functionCallStatement.Parameters[0]; switch (number) { case ConstantValueStatement constantValueStatement: { return(InlineConstant(constantValueStatement.TypeDescriptor, constantValueStatement.Value, constantValueStatement)); } case VariableAccessStatement variableAccessStatement: { if (p.Scope.TryGetVariableInfo(variableAccessStatement, out var varInfo)) { if (varInfo.TypeDescriptor.IsString()) { return(new ApiMethodBuilderRawResult(new ExpressionResult( TypeDescriptor, $"[[ -z ${{{varInfo.AccessName}// }} ]]", variableAccessStatement ))); } } else if (p.Scope.TryGetConstantInfo(variableAccessStatement, out var constInfo)) { return(InlineConstant(constInfo.TypeDescriptor, constInfo.Value, variableAccessStatement)); } throw new IdentifierNotFoundCompilerException(variableAccessStatement); } default: { throw new NotImplementedException(); } } }
public static FunctionInfo GetFunctionInfoFromFunctionCall(Context context, Scope scope, FunctionCallStatement functionCallStatement, out ILanguageObjectInfo sourceObjectInfo) { if (!scope.TryGetFunctionInfo(functionCallStatement, out var funcInfo) && !scope.TryGetPrototypeInfo(functionCallStatement, out funcInfo)) { if (!scope.TryGetVariableInfo(functionCallStatement, out var variableInfo)) { throw new IdentifierNotFoundCompilerException(functionCallStatement.Fqn, functionCallStatement.Info); } sourceObjectInfo = variableInfo; var type = variableInfo.TypeDescriptor; if (type.DataType != DataTypes.Delegate && type.DataType != DataTypes.Lookup || type.Lookup == null) { throw new InvalidStatementStructureCompilerException(functionCallStatement.Fqn, functionCallStatement.Info); } var lookup = type.Lookup.Value; if (!scope.TryGetFunctionInfo(lookup.ClassName, lookup.Name, out funcInfo) && !scope.TryGetPrototypeInfo(lookup.ClassName, lookup.Name, out funcInfo)) { throw new InvalidStatementStructureCompilerException(functionCallStatement.Fqn, functionCallStatement.Info); } } else { sourceObjectInfo = funcInfo; } return(funcInfo); }
public override IApiMethodBuilderResult Build(ExpressionBuilderParams p, FunctionCallStatement functionCallStatement) { AssertParameters(p, functionCallStatement.Parameters); var endpoint = functionCallStatement.Parameters[0]; p.FormatString = false; var transpiler = p.Context.GetEvaluationTranspilerForStatement(endpoint); var result = transpiler.GetExpression(p, endpoint); if (!result.TypeDescriptor.IsString()) { throw ThrowInvalidParameterType(result); } return(new ApiMethodBuilderRawResult(new ExpressionResult( TypeDescriptor, $"`ping {result.Expression}`", result.Template ))); }
public static IApiMethodBuilderResult BuildHelper(Call call, ExpressionBuilderParams p, FunctionCallStatement functionCallStatement) { call.AssertParameters(p, functionCallStatement.Parameters); var parameter = functionCallStatement.Parameters[0]; p.FormatString = false; var transpiler = p.Context.GetEvaluationTranspilerForStatement(parameter); var result = transpiler.GetExpression(p, parameter); if (!result.TypeDescriptor.IsString()) { throw ThrowInvalidParameterType(result); } return(new ApiMethodBuilderRawResult(new ExpressionResult( call.TypeDescriptor, $"`{result.Expression}`", result.Template ))); }
public override IApiMethodBuilderResult Build(ExpressionBuilderParams p, FunctionCallStatement functionCallStatement) { AssertParameters(p, functionCallStatement.Parameters); var p0 = functionCallStatement.Parameters[0]; var p1 = functionCallStatement.Parameters[1]; if (!(p0 is VariableAccessStatement destination)) { throw new InvalidStatementStructureCompilerException(p0, p0.Info); } if (!p.Scope.TryGetVariableInfo(destination, out var dstInfo)) { throw new IdentifierNotFoundCompilerException(destination); } var dstVarName = destination.VariableName; if (p1 is ArrayStatement arrayStatement) { var elements = arrayStatement.Elements; var elementsResults = new List <string>(elements.Length); foreach (var elem in elements) { var transpiler = p.Context.GetEvaluationTranspilerForStatement(elem); var result = transpiler.GetExpression(p, elem); elementsResults.Add(result.Expression); } if ((elementsResults.Sum(s => s.Length + 2) + dstVarName.Length + 3) <= p.Context.Flags.ArrayManipulationColumnCount) { p.NonInlinePartWriter.Write(dstVarName); p.NonInlinePartWriter.Write("=("); p.NonInlinePartWriter.Write(string.Join(' ', elementsResults)); p.NonInlinePartWriter.WriteLine(")"); } else { for (int i = 0; i < elementsResults.Count; i++) { p.NonInlinePartWriter.Write(dstVarName); p.NonInlinePartWriter.Write('['); p.NonInlinePartWriter.Write(i); p.NonInlinePartWriter.Write("]="); p.NonInlinePartWriter.WriteLine(elementsResults[i]); } } } else if (p1 is VariableAccessStatement source) { if (!p.Scope.TryGetVariableInfo(source, out var srcInfo)) { throw new IdentifierNotFoundCompilerException(source); } var srcVarName = source.VariableName; var isQuoteNeeded = srcInfo.TypeDescriptor.IsString(); //for i in ${!a[@]}; do // b[$i]="${a[$i]}" //done //for i in ${!a[@]}; do p.NonInlinePartWriter.Write("for i in ${!"); p.NonInlinePartWriter.Write(srcVarName); p.NonInlinePartWriter.WriteLine("[@]}; do"); //b[$i]="${a[$i]}" p.NonInlinePartWriter.Write(dstVarName); if (isQuoteNeeded) { p.NonInlinePartWriter.Write("[$i]=\"${"); } else { p.NonInlinePartWriter.Write("[$i]=${"); } p.NonInlinePartWriter.Write(srcVarName); if (isQuoteNeeded) { p.NonInlinePartWriter.Write("[$i]}\""); } else { p.NonInlinePartWriter.Write("[$i]}"); } p.NonInlinePartWriter.WriteLine(); p.NonInlinePartWriter.WriteLine("done"); } else if (p1 is FunctionCallStatement funcCallStatement) { if (!p.Scope.TryGetFunctionInfo(funcCallStatement, out var funcInfo)) { throw new IdentifierNotFoundCompilerException(funcCallStatement); } var transpiler = p.Context.GetTranspilerForStatement(funcCallStatement); var srcVarName = p.Context.GetLastFunctionCallStorageVariable(funcInfo.TypeDescriptor, p.MetaWriter); var isQuoteNeeded = funcInfo.TypeDescriptor.IsString(); //for i in ${!a[@]}; do // b[$i]="${a[$i]}" //done //p.NonInlineP //artWriter.Write(funcInfo.AccessName); transpiler.WriteBlock(p.Context, p.Scope, p.NonInlinePartWriter, p.MetaWriter, funcCallStatement); //for i in ${!a[@]}; do p.NonInlinePartWriter.Write("for i in ${!"); p.NonInlinePartWriter.Write(srcVarName); p.NonInlinePartWriter.WriteLine("[@]}; do"); //b[$i]="${a[$i]}" p.NonInlinePartWriter.Write(dstVarName); if (isQuoteNeeded) { p.NonInlinePartWriter.Write("[$i]=\"${"); } else { p.NonInlinePartWriter.Write("[$i]=${"); } p.NonInlinePartWriter.Write(srcVarName); if (isQuoteNeeded) { p.NonInlinePartWriter.Write("[$i]}\""); } else { p.NonInlinePartWriter.Write("[$i]}"); } p.NonInlinePartWriter.WriteLine(); p.NonInlinePartWriter.WriteLine("done"); } else { throw new InvalidStatementStructureCompilerException(p1, p1.Info); } return(new ApiMethodBuilderRawResult(new ExpressionResult(TypeDescriptor.Void, null, null, new IExpressionNotice[] { new PinRequiredNotice() }))); }
public IdentifierNotFoundCompilerException(FunctionCallStatement functionCallStatement) : base(CreateMessage(functionCallStatement.Fqn, functionCallStatement.Info), functionCallStatement.Info) { }
public override IApiMethodBuilderResult Build(ExpressionBuilderParams p, FunctionCallStatement functionCallStatement) { return(CompileResourceMethod(this, p, ResourceName, _functionInfo, functionCallStatement.Parameters, functionCallStatement.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 IApiMethodBuilderResult Build(ExpressionBuilderParams p, FunctionCallStatement functionCallStatement) { throw new System.NotImplementedException(); }
public static EvaluationStatement GetSchemeParameterValueByIndex(Context context, Scope scope, FunctionInfo functionInfo, FunctionCallStatement functionCallStatement, int index) { return(functionCallStatement.Parameters[index]); }
/// <summary> /// Validates the function call by using a schema (<param name="funcInfo">funcInfo</param>). /// </summary> /// <param name="context"></param> /// <param name="scope"></param> /// <param name="funcInfo"></param> /// <param name="functionCallStatement"></param> /// <param name="exception"></param> /// <returns></returns> public static bool ValidateFunctionCall(Context context, Scope scope, FunctionInfo funcInfo, FunctionCallStatement functionCallStatement, out Exception exception) { return(ValidateParameters(context, scope, funcInfo.Parameters, functionCallStatement.Parameters, out exception)); }
public abstract IApiMethodBuilderResult Build(ExpressionBuilderParams p, FunctionCallStatement functionCallStatement);
public override IApiMethodBuilderResult Build(ExpressionBuilderParams p, FunctionCallStatement functionCallStatement) => BashCall.BuildHelper(this, p, functionCallStatement);
public override IApiMethodBuilderResult Build(ExpressionBuilderParams p, FunctionCallStatement functionCallStatement) { return(BashTestCommand.CreateTestExpression(this, p, functionCallStatement, "z")); }