public static bool CheckSyntax(string expression, out Error[] errors)
{
var p = new CSharpParser();
p.ParseExpression(expression);
errors = p.Errors.ToArray();
return !errors.Any();
}
private static string FormatInternal(string code)
{
var cSharpParser = new CSharpParser();
var expr = cSharpParser.ParseExpression(code);
if (cSharpParser.HasErrors)
{
throw new ArgumentException(string.Join(Environment.NewLine, cSharpParser.Errors.Select(e => e.ErrorType + " " + e.Message + " " + e.Region)));
}
// Wrap expression in parenthesized expression, this is necessary because the transformations
// can't replace the root node of the syntax tree
expr = new ParenthesizedExpression(expr);
// Apply transformations
new IntroduceQueryExpressions().Run(expr);
new CombineQueryExpressions().Run(expr);
new IntroduceParenthesisForNestedQueries().Run(expr);
new RemoveQueryContinuation().Run(expr);
// Unwrap expression
expr = ((ParenthesizedExpression)expr).Expression;
var format = expr.GetText(FormattingOptionsFactory.CreateAllman());
if (format.Substring(0, 3) == "\r\n\t")
{
format = format.Remove(0, 3);
}
format = format.Replace("\r\n\t", "\n");
return(format);
}
string ConvertExpression(string code)
{
CSharpParser parser = new CSharpParser();
var expr = parser.ParseExpression(code);
Assert.IsFalse(parser.HasErrors);
return ConvertExpression(expr);
}
public void GetNodesBetween()
{
var parser = new CSharpParser();
var expr = parser.ParseExpression("a*b+c*d");
var nodes = expr.GetNodesBetween(1, 3, 1, 6).ToList();
Assert.AreEqual(new[] { "b", "+", "c" }, nodes.Select(n => n.ToString()).ToList());
}
public object EvaluateExpression(string expression, CodeContext codeContext, ExpressionParseType parseType = ExpressionParseType.Evaluate)
{
//
var result = parser.ParseExpression(expression);
if (result.ToString() == "Null")
{
IEnumerable <Statement> statements = parser.ParseStatements(expression);
Statement firstStatement = statements.First();
return(EvaluateStatement(firstStatement, codeContext, parseType));
}
else
{
return(EvaluateExpression(result, codeContext, parseType));
}
}
public static AstNode ParseSnippet(this ICSharpCode.NRefactory.CSharp.CSharpParser parser, TextEditorData data)
{
using (var stream = new StreamReader(data.OpenStream())) {
var result = parser.ParseExpression(stream);
if (!parser.HasErrors)
{
return(result);
}
}
parser.ErrorPrinter.Reset();
using (var stream = new StreamReader(data.OpenStream())) {
var result = parser.ParseStatements(stream);
if (!parser.HasErrors)
{
return(result.First());
}
}
parser.ErrorPrinter.Reset();
using (var stream = data.OpenStream()) {
return(parser.Parse(stream));
}
}
public static bool CheckSyntax(string expression)
{
var p = new CSharpParser();
p.ParseExpression(expression);
return !p.Errors.Any();
}
public ResolveResult ResolveSnippet(ParseInformation parseInfo, TextLocation location, string codeSnippet, ICompilation compilation, CancellationToken cancellationToken)
{
var csParseInfo = parseInfo as CSharpFullParseInformation;
if (csParseInfo == null)
throw new ArgumentException("Parse info does not have SyntaxTree");
CSharpAstResolver contextResolver = new CSharpAstResolver(compilation, csParseInfo.SyntaxTree, csParseInfo.UnresolvedFile);
var node = csParseInfo.SyntaxTree.GetNodeAt(location);
CSharpResolver context;
if (node != null)
context = contextResolver.GetResolverStateAfter(node, cancellationToken);
else
context = new CSharpResolver(compilation);
CSharpParser parser = new CSharpParser();
var expr = parser.ParseExpression(codeSnippet);
if (parser.HasErrors)
return new ErrorResolveResult(SpecialType.UnknownType, PrintErrorsAsString(parser.Errors), TextLocation.Empty);
CSharpAstResolver snippetResolver = new CSharpAstResolver(context, expr);
return snippetResolver.Resolve(expr, cancellationToken);
}
public void Run()
{
try {
if (searchMode == SearchMode_Literal) {
if (1 == searchTerm.Length)
{
CSharpParser parser = new CSharpParser();
PrimitiveExpression pe = parser.ParseExpression(searchTerm[0]) as PrimitiveExpression;
if (pe != null && pe.Value != null) {
TypeCode peValueType = Type.GetTypeCode(pe.Value.GetType());
switch (peValueType) {
case TypeCode.Byte:
case TypeCode.SByte:
case TypeCode.Int16:
case TypeCode.UInt16:
case TypeCode.Int32:
case TypeCode.UInt32:
case TypeCode.Int64:
case TypeCode.UInt64:
searchTermLiteralType = TypeCode.Int64;
searchTermLiteralValue = CSharpPrimitiveCast.Cast(TypeCode.Int64, pe.Value, false);
break;
case TypeCode.Single:
case TypeCode.Double:
case TypeCode.String:
searchTermLiteralType = peValueType;
searchTermLiteralValue = pe.Value;
break;
}
}
}
}
foreach (var loadedAssembly in assemblies) {
AssemblyDefinition asm = loadedAssembly.AssemblyDefinition;
if (asm == null)
continue;
CancellationToken cancellationToken = cts.Token;
foreach (TypeDefinition type in asm.MainModule.Types) {
cancellationToken.ThrowIfCancellationRequested();
PerformSearch(type);
}
}
} catch (OperationCanceledException) {
// ignore cancellation
}
// remove the 'Searching...' entry
dispatcher.BeginInvoke(
DispatcherPriority.Normal,
new Action(delegate { this.Results.RemoveAt(this.Results.Count - 1); }));
}
private static string[] Translate(string query)
{
var parser = new CSharpParser();
var block = parser.ParseExpression(query);
var captureQueryParameterNamesVisitor = new CaptureQueryParameterNamesVisitor();
block.AcceptVisitor(captureQueryParameterNamesVisitor, null);
return captureQueryParameterNamesVisitor.QueryParameters.ToArray();
}
public override ValidationResult ValidateExpression (EvaluationContext ctx, string expression)
{
expression = expression.TrimStart ();
if (expression.Length > 0 && expression[0] == '?')
expression = expression.Substring (1).Trim ();
if (expression.StartsWith ("var", StringComparison.Ordinal) && char.IsWhiteSpace (expression[3]))
expression = expression.Substring (4).Trim ();
expression = ReplaceExceptionTag (expression, ctx.Options.CurrentExceptionTag);
// Required as a workaround for a bug in the parser (it won't parse simple expressions like numbers)
if (!expression.EndsWith (";", StringComparison.Ordinal))
expression += ";";
var parser = new CSharpParser ();
parser.ParseExpression (expression);
if (parser.HasErrors)
return new ValidationResult (false, parser.Errors.First ().Message);
return new ValidationResult (true, null);
}
/* public ICSharpCode.OldNRefactory.Parser.Errors LastErrors {
get;
private set;
}*/
public Expression ParseExpression (string expressionText)
{
expressionText = expressionText.Trim ();
var parser = new CSharpParser ();
Expression result = null;
try {
using (var reader = new StringReader (expressionText)) {
result = parser.ParseExpression (reader) as Expression;
result.Remove ();
// LastErrors = parser.Errors;
}
} catch (Exception) {
}
return result;
}
protected string FormatCSharpExpression(string expression)
{
var parser = new CSharpParser();
parser.ParseExpression(expression + ";");
if (parser.HasErrors)
{
var errors = string.Join(Environment.NewLine, parser.Errors.Select(err => err.Message));
throw new TemplateParseException(null, string.Format("{0}{1}{2}", expression, Environment.NewLine, errors));
}
return expression;
}
