public static ExpressionEvaluationResult RunPipeline(
CommandEvaluationContext context,
PipelineParseResult pipelineParseResult
)
{
ExpressionEvaluationResult r = null;
var workUnitParseResult = pipelineParseResult;
while (workUnitParseResult != null)
{
r = RunWorkUnit(context, workUnitParseResult);
workUnitParseResult = workUnitParseResult.Next;
}
return(r);
}
public static ExpressionEvaluationResult RunWorkUnit(
CommandEvaluationContext context,
PipelineParseResult pipelineParseResult
)
{
var syntaxParsingResult = pipelineParseResult.ParseResult.SyntaxParsingResults.First();
try
{
var outputData = InvokeCommand(context, syntaxParsingResult.CommandSyntax.CommandSpecification, syntaxParsingResult.MatchingParameters);
return(new ExpressionEvaluationResult(null, ParseResultType.Valid, outputData, (int)ReturnCode.OK, null));
}
catch (Exception commandInvokeError)
{
var commandError = commandInvokeError.InnerException ?? commandInvokeError;
Errorln(commandError.Message);
return(new ExpressionEvaluationResult(null, pipelineParseResult.ParseResult.ParseResultType, null, (int)ReturnCode.Error, commandError));
}
}
public static ExpressionEvaluationResult RunWorkUnit(
CommandEvaluationContext context,
PipelineParseResult pipelineParseResult
)
{
var syntaxParsingResult = pipelineParseResult.ParseResult.SyntaxParsingResults.First();
try
{
// capture the err output
context.Err.StartRecording();
var r = InvokeCommand(context, syntaxParsingResult.CommandSyntax.CommandSpecification, syntaxParsingResult.MatchingParameters);
var res = r as ICommandResult;
var err_record = context.Err.StopRecording();
var err = res.ExecErrorText;
// auto assign from Err stream if no error text provided
if (string.IsNullOrEmpty(res.ExecErrorText) && !string.IsNullOrEmpty(err_record))
{
err = err_record;
}
return
((res == null)?
new ExpressionEvaluationResult(pipelineParseResult.Expr, null, ParseResultType.Valid, null, (int)ReturnCode.Error, null, "the command has returned a null result") :
new ExpressionEvaluationResult(pipelineParseResult.Expr, null, ParseResultType.Valid, res.GetOuputData(), res.ReturnCode, null, err));
}
catch (Exception commandInvokeError)
{
// error is catched at shell level
var commandError = commandInvokeError.InnerException ?? commandInvokeError;
context.Errorln(commandError.Message);
return(new ExpressionEvaluationResult(pipelineParseResult.Expr, null, pipelineParseResult.ParseResult.ParseResultType, null, (int)ReturnCode.Error, commandError));
}
finally {
context.Err.StopRecording();
}
}
ExpressionEvaluationResult AnalysisPipelineParseResult(
CommandEvaluationContext context,
PipelineParseResult pipelineParseResult,
string expr,
int outputX,
ParseResult parseResult
)
{
ExpressionEvaluationResult r = null;
var errorText = "";
string[] t;
int idx;
string serr;
switch (parseResult.ParseResultType)
{
case ParseResultType.Empty:
r = new ExpressionEvaluationResult(expr, null, parseResult.ParseResultType, null, (int)ReturnCode.OK, null);
break;
case ParseResultType.NotValid: /* command syntax not valid */
var perComErrs = new Dictionary <string, List <CommandSyntaxParsingResult> >();
foreach (var prs in parseResult.SyntaxParsingResults)
{
if (prs.CommandSyntax != null)
{
if (perComErrs.TryGetValue(prs.CommandSyntax?.CommandSpecification?.Name, out var lst))
{
lst.Add(prs);
}
else
{
perComErrs.Add(prs.CommandSyntax.CommandSpecification.Name, new List <CommandSyntaxParsingResult> {
prs
});
}
}
}
var errs = new List <string>();
var minErrPosition = int.MaxValue;
var errPositions = new List <int>();
foreach (var kvp in perComErrs)
{
var comSyntax = kvp.Value.First().CommandSyntax;
foreach (var prs in kvp.Value)
{
foreach (var perr in prs.ParseErrors)
{
minErrPosition = Math.Min(minErrPosition, perr.Position);
errPositions.Add(perr.Position);
if (!errs.Contains(perr.Description))
{
errs.Add(perr.Description);
}
}
errorText += Br + Red + string.Join(Br + Red, errs);
}
errorText += $"{Br}{Red}for syntax: {comSyntax}{Br}";
}
errPositions.Sort();
errPositions = errPositions.Distinct().ToList();
t = new string[expr.Length + 2];
for (int i = 0; i < t.Length; i++)
{
t[i] = " ";
}
foreach (var errPos in errPositions)
{
t[GetIndex(context, errPos, expr)] = Settings.ErrorPositionMarker + "";
}
serr = string.Join("", t);
Error(" ".PadLeft(outputX + 1) + serr, false, false);
Error(errorText);
r = new ExpressionEvaluationResult(expr, errorText, parseResult.ParseResultType, null, (int)ReturnCode.NotIdentified, null);
break;
case ParseResultType.Ambiguous:
errorText += $"{Red}ambiguous syntaxes:{Br}";
foreach (var prs in parseResult.SyntaxParsingResults)
{
errorText += $"{Red}{prs.CommandSyntax}{Br}";
}
Error(errorText);
r = new ExpressionEvaluationResult(expr, errorText, parseResult.ParseResultType, null, (int)ReturnCode.NotIdentified, null);
break;
case ParseResultType.NotIdentified:
t = new string[expr.Length + 2];
for (int j = 0; j < t.Length; j++)
{
t[j] = " ";
}
var err = parseResult.SyntaxParsingResults.First().ParseErrors.First();
idx = err.Position;
t[idx] = Settings.ErrorPositionMarker + "";
errorText += Red + err.Description;
serr = string.Join("", t);
context.Errorln(" ".PadLeft(outputX) + serr);
context.Errorln(errorText);
r = new ExpressionEvaluationResult(expr, errorText, parseResult.ParseResultType, null, (int)ReturnCode.NotIdentified, null);
break;
case ParseResultType.SyntaxError:
t = new string[expr.Length + 2];
for (int j = 0; j < t.Length; j++)
{
t[j] = " ";
}
var err2 = parseResult.SyntaxParsingResults.First().ParseErrors.First();
idx = err2.Index;
t[idx] = Settings.ErrorPositionMarker + "";
errorText += Red + err2.Description;
serr = string.Join("", t);
context.Errorln(" ".PadLeft(outputX) + serr);
context.Errorln(errorText);
r = new ExpressionEvaluationResult(expr, errorText, parseResult.ParseResultType, null, (int)ReturnCode.NotIdentified, null);
break;
}
return(r);
}