/// <summary>
/// Get the state of the buffer - the ast, tokens, errors, and position of the cursor
/// </summary>
public static void GetBufferState(out Ast ast, out Token[] tokens, out ParseError[] parseErrors, out int cursor)
{
_singleton.ParseInput();
ast = _singleton._ast;
tokens = _singleton._tokens;
parseErrors = _singleton._parseErrors;
cursor = _singleton._current;
}
/// <summary>
/// Parse input from the specified file.
/// </summary>
/// <param name="fileName">The name of the file to parse.</param>
/// <param name="tokens">Returns the tokens from parsing the script.</param>
/// <param name="errors">Returns errors, if any, discovered while parsing the script.</param>
/// <returns>The <see cref="ScriptBlockAst"/> that represents the input script file.</returns>
public static ScriptBlockAst ParseFile(string fileName, out Token[] tokens, out ParseError[] errors)
{
const string scriptSchemaExtension = ".schema.psm1";
var parseDscResource = false;
// If the file has the 'schema.psm1' extension, then it is a 'DSC module file' however we don't actually load the
// module at parse time so we can't use the normal mechanisms to bind the module name for configuration commands.
// As an alternative, we extract the base name of the module file and use that as the module name for any keywords exported by this file.
var parser = new Parser();
if (!string.IsNullOrEmpty(fileName) && fileName.Length > scriptSchemaExtension.Length && fileName.EndsWith(scriptSchemaExtension, StringComparison.OrdinalIgnoreCase))
{
parser._keywordModuleName = Path.GetFileName(fileName.Substring(0, fileName.Length - scriptSchemaExtension.Length));
parseDscResource = true;
}
string scriptContents;
try
{
var esi = new ExternalScriptInfo(fileName, fileName);
scriptContents = esi.ScriptContents;
}
catch (Exception e)
{
var emptyExtent = new EmptyScriptExtent();
var errorMsg = string.Format(CultureInfo.CurrentCulture, ParserStrings.FileReadError, e.Message);
errors = new[] { new ParseError(emptyExtent, "FileReadError", errorMsg) };
tokens = Utils.EmptyArray<Token>();
return new ScriptBlockAst(emptyExtent, null, new StatementBlockAst(emptyExtent, null, null), false);
}
var tokenList = new List<Token>();
ScriptBlockAst result;
try
{
if (!parseDscResource)
{
DynamicKeyword.Push();
}
result = parser.Parse(fileName, scriptContents, tokenList, out errors, ParseMode.Default);
}
catch (Exception e)
{
throw new ParseException(ParserStrings.UnrecoverableParserError, e);
}
finally
{
if (!parseDscResource)
{
DynamicKeyword.Pop();
}
}
tokens = tokenList.ToArray();
return result;
}
internal static ScriptFileMarker FromParseError(
ParseError parseError)
{
Validate.IsNotNull("parseError", parseError);
return new ScriptFileMarker
{
Message = parseError.Message,
Level = ScriptFileMarkerLevel.Error,
ScriptRegion = ScriptRegion.Create(parseError.Extent)
};
}
public string FormatError(ParseError err)
{
return String.Format(
"{0}({1},{2},{3},{4}): error {5}: {6}",
err.Extent.File,
err.Extent.StartLineNumber,
err.Extent.StartColumnNumber,
err.Extent.EndLineNumber,
err.Extent.EndColumnNumber,
err.ErrorId,
err.Message);
}
public ParseException(ParseError[] errors)
{
if ((errors == null) || (errors.Length == 0))
{
throw new ArgumentNullException("errors");
}
this._errors = errors;
base.SetErrorId(this._errors[0].ErrorId);
base.SetErrorCategory(ErrorCategory.ParserError);
if (errors[0].Extent != null)
{
this.ErrorRecord.SetInvocationInfo(new InvocationInfo(null, errors[0].Extent));
}
}
public void LoadFile(string fileName)
{
Token[] tokens;
ParseError[] localErrors=null;
try
{
var ast = Parser.ParseFile(fileName, out tokens, out localErrors);
errors.AddRange(localErrors);
}
catch (ParseException ex)
{
var pos = new ScriptPosition(fileName,0,0,"");
var err = new ParseError(new ScriptExtent(pos, pos), "FatalParserError", GetNestedMessage(ex));
errors.Add(err);
}
}
internal ScriptBlockAst Parse(string fileName, string input, List<Token> tokenList, out ParseError[] errors)
{
ScriptBlockAst scriptBlockAst;
try
{
scriptBlockAst = this.ParseTask(fileName, input, tokenList, false);
}
finally
{
errors = this._errorList.ToArray();
}
return scriptBlockAst;
}
internal PSParseError(ParseError error)
{
this._message = error.Message;
this._psToken = new PSToken(error.Extent);
}
// This function performs semantic checks for all DSC Resources keywords.
private static ParseError[] CheckMandatoryPropertiesPresent(DynamicKeywordStatementAst kwAst)
{
HashSet<string> mandatoryPropertiesNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
foreach (var pair in kwAst.Keyword.Properties)
{
if (pair.Value.Mandatory)
{
mandatoryPropertiesNames.Add(pair.Key);
}
}
// by design mandatoryPropertiesNames are not empty at this point:
// every resource must have at least one Key property.
HashtableAst hashtableAst = null;
foreach (var ast in kwAst.CommandElements)
{
hashtableAst = ast as HashtableAst;
if (hashtableAst != null)
{
break;
}
}
if (hashtableAst == null)
{
// nothing to validate
return null;
}
foreach (var pair in hashtableAst.KeyValuePairs)
{
object evalResultObject;
if (IsConstantValueVisitor.IsConstant(pair.Item1, out evalResultObject, forAttribute: false, forRequires: false))
{
var presentName = evalResultObject as string;
if (presentName != null)
{
if (mandatoryPropertiesNames.Remove(presentName) && mandatoryPropertiesNames.Count == 0)
{
// optimization, once all mandatory properties are specified, we can safely exit.
return null;
}
}
}
}
if (mandatoryPropertiesNames.Count > 0)
{
ParseError[] errors = new ParseError[mandatoryPropertiesNames.Count];
var extent = kwAst.CommandElements[0].Extent;
int i = 0;
foreach (string name in mandatoryPropertiesNames)
{
errors[i] = new ParseError(extent, "MissingValueForMandatoryProperty",
string.Format(CultureInfo.CurrentCulture, ParserStrings.MissingValueForMandatoryProperty,
kwAst.Keyword.Keyword, kwAst.Keyword.Properties.First(
p => StringComparer.OrdinalIgnoreCase.Equals(p.Value.Name, name)).Value.TypeConstraint, name));
i++;
}
return errors;
}
return null;
}
private void SaveError(IScriptExtent extent, Expression<Func<string>> errorExpr, bool incompleteInput, object[] args)
{
string str = null;
string name = null;
MemberExpression body = errorExpr.Body as MemberExpression;
if (body != null)
{
PropertyInfo member = body.Member as PropertyInfo;
if (member != null)
{
MethodInfo getMethod = member.GetGetMethod(true);
if (getMethod != null && getMethod.IsStatic && getMethod.ReturnType.Equals(typeof(string)))
{
str = (string)getMethod.Invoke(null, null);
name = member.Name;
}
}
}
if (str == null)
{
str = errorExpr.Compile()();
name = "ParserError";
}
if (args != null && args.Any<object>())
{
str = string.Format(CultureInfo.CurrentCulture, str, args);
}
ParseError parseError = new ParseError(extent, name, str, incompleteInput);
this.SaveError(parseError);
}
private void SaveError(ParseError error)
{
Func<ParseError, bool> func = null;
if (this._errorList.Any<ParseError>())
{
List<ParseError> parseErrors = this._errorList;
if (func == null)
{
func = (ParseError err) =>
{
if (!err.ErrorId.Equals(error.ErrorId, StringComparison.Ordinal) || err.Extent.EndColumnNumber != error.Extent.EndColumnNumber || err.Extent.EndLineNumber != error.Extent.EndLineNumber || err.Extent.StartColumnNumber != error.Extent.StartColumnNumber)
{
return false;
}
else
{
return err.Extent.StartLineNumber == error.Extent.StartLineNumber;
}
}
;
}
if (parseErrors.Where<ParseError>(func).Any<ParseError>())
{
return;
}
}
this._errorList.Add(error);
}
internal void ReportError(ParseError error)
{
this.SaveError(error);
}
internal PSParseError(Language.ParseError error)
{
Message = error.Message;
Token = new PSToken(error.Extent);
}
/// <summary>
/// Tokonize the script and get the needed data.
/// </summary>
/// <param name="script">The active script.</param>
/// <param name="tokens">The tokens to get.</param>
/// <param name="errors">The parse errors to get.</param>
/// <returns></returns>
public static Ast Tokenize(string script, out Token[] tokens, out ParseError[] errors)
{
Ast result;
try
{
Ast ast = System.Management.Automation.Language.Parser.ParseInput(script, out tokens, out errors);
result = ast;
}
catch (RuntimeException ex)
{
var parseError = new ParseError(null, ex.ErrorRecord.FullyQualifiedErrorId, ex.Message);
errors = new[] { parseError };
tokens = new Token[0];
result = null;
}
return result;
}
/// <summary>
/// Parses the current file contents to get the AST, tokens,
/// and parse errors.
/// </summary>
private void ParseFileContents()
{
ParseError[] parseErrors = null;
try
{
this.ScriptAst =
Parser.ParseInput(
this.Contents,
out this.scriptTokens,
out parseErrors);
}
catch (RuntimeException ex)
{
var parseError =
new ParseError(
null,
ex.ErrorRecord.FullyQualifiedErrorId,
ex.Message);
parseErrors = new[] { parseError };
this.scriptTokens = new Token[0];
this.ScriptAst = null;
}
// Translate parse errors into syntax markers
this.SyntaxMarkers =
parseErrors
.Select(ScriptFileMarker.FromParseError)
.ToArray();
//Get all dot sourced referenced files and store them
this.ReferencedFiles =
AstOperations.FindDotSourcedIncludes(this.ScriptAst);
}
private void SaveError(IScriptExtent extent, Expression<Func<string>> errorExpr, bool incompleteInput, params object[] args)
{
string errorMsg = null;
string errorId = null;
var memberExpression = errorExpr.Body as MemberExpression;
if (memberExpression != null)
{
var propertyInfo = memberExpression.Member as PropertyInfo;
if (propertyInfo != null)
{
var getter = propertyInfo.GetMethod;
if (getter != null && getter.IsStatic && getter.ReturnType == typeof(string))
{
errorMsg = (string)getter.Invoke(null, null);
errorId = propertyInfo.Name;
}
}
}
if (errorMsg == null)
{
errorMsg = errorExpr.Compile().Invoke();
errorId = "ParserError";
}
if (args != null && args.Any())
{
errorMsg = string.Format(CultureInfo.CurrentCulture, errorMsg, args);
}
ParseError errorToSave = new ParseError(extent, errorId, errorMsg, incompleteInput);
SaveError(errorToSave);
}
private void SaveError(ParseError error)
{
if (ErrorList.Any())
{
// Avoiding adding duplicate errors - can happen when the tokenizer resyncs.
if (ErrorList.Any(err => err.ErrorId.Equals(error.ErrorId, StringComparison.Ordinal)
&& err.Extent.EndColumnNumber == error.Extent.EndColumnNumber
&& err.Extent.EndLineNumber == error.Extent.EndLineNumber
&& err.Extent.StartColumnNumber == error.Extent.StartColumnNumber
&& err.Extent.StartLineNumber == error.Extent.StartLineNumber))
{
return;
}
}
ErrorList.Add(error);
}
internal ScriptBlockAst Parse(string fileName, string input, List<Token> tokenList, out ParseError[] errors, ParseMode parseMode)
{
try
{
return ParseTask(fileName, input, tokenList, false, parseMode);
}
finally
{
errors = ErrorList.ToArray();
}
}
/// <summary>
/// Parse input that does not come from a file.
/// </summary>
/// <param name="input">The input to parse.</param>
/// <param name="fileName">The fileName if present or null.</param>
/// <param name="tokens">Returns the tokens from parsing the script.</param>
/// <param name="errors">Returns errors, if any, discovered while parsing the script.</param>
/// <returns>The <see cref="ScriptBlockAst"/> that represents the input script file.</returns>
public static ScriptBlockAst ParseInput(string input, string fileName, out Token[] tokens, out ParseError[] errors)
{
Parser parser = new Parser();
List<Token> tokenList = new List<Token>();
ScriptBlockAst result;
try
{
result = parser.Parse(fileName, input, tokenList, out errors, ParseMode.Default);
}
catch (Exception e)
{
throw new ParseException(ParserStrings.UnrecoverableParserError, e);
}
tokens = tokenList.ToArray();
return result;
}
public ParseErrorEventArgs(ParseError[] parseErrors)
{
Errors = parseErrors;
}
public static ScriptBlockAst ParseFile(string fileName, out Token[] tokens, out ParseError[] errors)
{
ScriptBlockAst scriptBlockAst;
Parser parser = new Parser();
ExternalScriptInfo externalScriptInfo = new ExternalScriptInfo(fileName, fileName);
List<Token> tokens1 = new List<Token>();
try
{
scriptBlockAst = parser.Parse(fileName, externalScriptInfo.ScriptContents, tokens1, out errors);
}
catch (Exception exception1)
{
Exception exception = exception1;
throw new ParseException(ParserStrings.UnrecoverableParserError, exception);
}
tokens = tokens1.ToArray();
return scriptBlockAst;
}
private void PerformSecurityChecks()
{
var scriptBlockAst = Ast as ScriptBlockAst;
if (scriptBlockAst == null)
{
// Checks are only needed at the top level.
return;
}
// Call the AMSI API to determine if the script block has malicious content
var scriptExtent = scriptBlockAst.Extent;
if (AmsiUtils.ScanContent(scriptExtent.Text, scriptExtent.File) == AmsiUtils.AmsiNativeMethods.AMSI_RESULT.AMSI_RESULT_DETECTED)
{
var parseError = new ParseError(scriptExtent, "ScriptContainedMaliciousContent", ParserStrings.ScriptContainedMaliciousContent);
throw new ParseException(new[] { parseError });
}
if (ScriptBlock.CheckSuspiciousContent(scriptBlockAst) != null)
{
HasSuspiciousContent = true;
}
}
public static ScriptBlockAst ParseInput(string input, out Token[] tokens, out ParseError[] errors)
{
return Parser.ParseInput(input, null, out tokens, out errors);
}
internal static ScriptBlockAst ParseInput(string input, string fileName, out Token[] tokens, out ParseError[] errors)
{
ScriptBlockAst scriptBlockAst;
Parser parser = new Parser();
List<Token> tokens1 = new List<Token>();
try
{
scriptBlockAst = parser.Parse(fileName, input, tokens1, out errors);
}
catch (Exception exception1)
{
Exception exception = exception1;
throw new ParseException(ParserStrings.UnrecoverableParserError, exception);
}
tokens = tokens1.ToArray();
return scriptBlockAst;
}
internal static Ast Tokenize(string script, out Token[] tokens, out ParseError[] errors)
{
Ast result;
try
{
Token[] array;
Ast ast = Parser.ParseInput(script, out array, out errors);
tokens = new Token[array.Length - 1];
Array.Copy(array, tokens, tokens.Length);
result = ast;
}
catch (RuntimeException ex)
{
var parseError = new ParseError(new EmptyScriptExtent(), ex.ErrorRecord.FullyQualifiedErrorId, ex.Message);
errors = new []{parseError};
tokens = new Token[0];
result = null;
}
return result;
}