public ParseInformation Parse(FileName fileName, ITextSource fileContent, bool fullParseInformationRequested,
IProject parentProject, CancellationToken cancellationToken)
{
AXmlParser parser = new AXmlParser();
AXmlDocument document;
IncrementalParserState newParserState;
if (fileContent.Version is OnDiskTextSourceVersion)
{
document = parser.Parse(fileContent, cancellationToken);
newParserState = null;
}
else
{
document = parser.ParseIncremental(parserState, fileContent, out newParserState, cancellationToken);
}
parserState = newParserState;
XamlUnresolvedFile unresolvedFile = XamlUnresolvedFile.Create(fileName, fileContent, document);
ParseInformation parseInfo;
if (fullParseInformationRequested)
{
parseInfo = new XamlFullParseInformation(unresolvedFile, document, fileContent.CreateSnapshot());
}
else
{
parseInfo = new ParseInformation(unresolvedFile, fileContent.Version, false);
}
AddTagComments(document, parseInfo, fileContent);
return(parseInfo);
}
public static void Run(string fileName)
{
var textSource = new StringTextSource(File.ReadAllText(fileName));
using (var textReader = textSource.CreateReader())
{
using (var xmlReader = new XmlTextReader(textReader))
{
Run(xmlReader);
}
}
var doc = new AXmlParser().Parse(textSource);
using (var xmlReader = doc.CreateReader())
{
Run(xmlReader);
}
var xmlDocument = new XmlDocument();
xmlDocument.Load(doc.CreateReader());
xmlDocument.Save(Path.Combine(Program.TempPath, "savedXmlDocument.xml"));
var xDocument = XDocument.Load(doc.CreateReader());
xDocument.Save(Path.Combine(Program.TempPath, "savedXDocument.xml"));
}
public static Context CreateContext(AbsoluteFilePath filePath, string code, int offset, SourcePackage package)
{
var parser = new AXmlParser();
var result = parser.Parse(new StringTextSource(code));
var file = new SourceFile(package, filePath.NativePath, code);
return(new Context(file, result, offset));
}
static int TryGetElementIndex(string xml, TextPosition caretPosition)
{
try
{
var normalizedXml = xml.NormalizeLineEndings();
var offset = caretPosition.ToOffset(normalizedXml);
var parser = new AXmlParser();
var tagsoup = parser.ParseTagSoup(new StringTextSource(normalizedXml));
var elements = RemoveJavaScript(tagsoup.OfType <AXmlTag>());
return(elements
.Where(e => !e.IsEndTag && !e.IsComment && e.ClosingBracket != "")
.IndexOfFirst(obj => obj.StartOffset <= offset && offset < obj.EndOffset));
}
catch (Exception)
{
return(-1);
}
}
protected override void OnInitialized(EventArgs e)
{
markerService = new TextMarkerService(editor.TextArea);
editor.TextArea.TextView.MouseMove += new MouseEventHandler(editor_TextArea_TextView_MouseMove);
editor.Document.Changed += delegate(object sender, DocumentChangeEventArgs e2) {
textDirty = true;
changes.Add(e2);
};
parser = new AXmlParser();
DispatcherTimer timer = new DispatcherTimer();
timer.Interval = TimeSpan.FromSeconds(0.5);
timer.Tick += delegate { Button_Click(null, null); };
timer.Start();
base.OnInitialized(e);
}
public static void Run(string fileName)
{
bool includeAttributes = true;
var textSource = new StringTextSource(File.ReadAllText(fileName));
using (var textReader = textSource.CreateReader()) {
using (var xmlReader = new XmlTextReader(textReader)) {
Run(xmlReader, includeAttributes);
}
}
var doc = new AXmlParser().Parse(textSource);
using (var xmlReader = doc.CreateReader()) {
Run(xmlReader, includeAttributes);
}
var xmlDocument = new XmlDocument();
xmlDocument.Load(doc.CreateReader());
xmlDocument.Save(Path.Combine(Program.TempPath, "savedXmlDocument.xml"));
var xDocument = XDocument.Load(doc.CreateReader());
xDocument.Save(Path.Combine(Program.TempPath, "savedXDocument.xml"));
File.WriteAllText(Path.Combine(Program.TempPath, "inputDocument.xml"), textSource.Text);
}
void CheckXmlDocForErrors(SyntaxNode node, ISymbol member)
{
context.CancellationToken.ThrowIfCancellationRequested();
foreach (var triva in node.GetLeadingTrivia())
{
if (triva.IsKind(SyntaxKind.SingleLineDocumentationCommentTrivia))
{
storedXmlComment.Add((DocumentationCommentTriviaSyntax)triva.GetStructure());
new CRefVisistor(this).Visit(triva.GetStructure());
}
}
if (storedXmlComment.Count == 0)
{
return;
}
xml.Clear();
xml.Append(firstline);
var OffsetTable = new List <int>();
foreach (var cmt in storedXmlComment)
{
OffsetTable.Add(xml.Length - firstline.Length);
xml.Append(cmt.Content + "\n");
}
xml.Append("</root>\n");
var doc = new AXmlParser().Parse(SourceText.From(xml.ToString()));
var stack = new Stack <AXmlObject>();
stack.Push(doc);
foreach (var err in doc.SyntaxErrors)
{
AddXmlIssue(CalculateRealStartOffset(OffsetTable, err.StartOffset), err.EndOffset - err.StartOffset, err.Description);
}
while (stack.Count > 0)
{
var cur = stack.Pop();
var el = cur as AXmlElement;
if (el != null)
{
switch (el.Name)
{
case "typeparam":
case "typeparamref":
var name = el.Attributes.FirstOrDefault(attr => attr.Name == "name");
if (name == null || name.ValueSegment.Length < 2)
{
break;
}
if (member != null && member.IsKind(SymbolKind.NamedType))
{
var type = (INamedTypeSymbol)member;
if (!type.TypeArguments.Any(arg => arg.Name == name.Value))
{
AddXmlIssue(CalculateRealStartOffset(OffsetTable, name.ValueSegment.Start + 1), name.ValueSegment.Length - 2, string.Format(GettextCatalog.GetString("Type parameter '{0}' not found"), name.Value));
}
}
break;
case "param":
case "paramref":
name = el.Attributes.FirstOrDefault(attr => attr.Name == "name");
if (name == null || name.ValueSegment.Length < 2)
{
break;
}
var m = member as IMethodSymbol;
if (m != null)
{
if (m.Parameters.Any(p => p.Name == name.Value))
{
break;
}
AddXmlIssue(CalculateRealStartOffset(OffsetTable, name.ValueSegment.Start + 1), name.ValueSegment.Length - 2, string.Format(GettextCatalog.GetString("Parameter '{0}' not found"), name.Value));
break;
}
var prop = member as IPropertySymbol;
if (prop != null)
{
if (prop.Parameters.Any(p => p.Name == name.Value))
{
break;
}
if (name.Value == "value")
{
break;
}
AddXmlIssue(CalculateRealStartOffset(OffsetTable, name.ValueSegment.Start + 1), name.ValueSegment.Length - 2, string.Format(GettextCatalog.GetString("Parameter '{0}' not found"), name.Value));
break;
}
var evt = member as IEventSymbol;
if (evt != null)
{
if (name.Value == "value")
{
break;
}
AddXmlIssue(CalculateRealStartOffset(OffsetTable, name.ValueSegment.Start + 1), name.ValueSegment.Length - 2, string.Format(GettextCatalog.GetString("Parameter '{0}' not found"), name.Value));
break;
}
var named = member as INamedTypeSymbol;
if (named != null)
{
if (named.DelegateInvokeMethod == null)
{
break;
}
if (named.DelegateInvokeMethod.Parameters.Any(p => p.Name == name.Value))
{
break;
}
AddXmlIssue(CalculateRealStartOffset(OffsetTable, name.ValueSegment.Start + 1), name.ValueSegment.Length - 2, string.Format(GettextCatalog.GetString("Parameter '{0}' not found"), name.Value));
break;
}
AddXmlIssue(CalculateRealStartOffset(OffsetTable, name.ValueSegment.Start + 1), name.ValueSegment.Length - 2, string.Format(GettextCatalog.GetString("Parameter '{0}' not found"), name.Value));
break;
}
}
foreach (var child in cur.Children)
{
stack.Push(child);
}
}
storedXmlComment.Clear();
}
void CheckXmlDoc(AstNode node)
{
ResolveResult resolveResult = ctx.Resolve(node);
IEntity member = null;
if (resolveResult is TypeResolveResult)
{
member = resolveResult.Type.GetDefinition();
}
if (resolveResult is MemberResolveResult)
{
member = ((MemberResolveResult)resolveResult).Member;
}
var xml = new StringBuilder();
var firstline = "<root>\n";
xml.Append(firstline);
foreach (var cmt in storedXmlComment)
{
xml.Append(cmt.Content + "\n");
}
xml.Append("</root>\n");
var doc = new AXmlParser().Parse(new StringTextSource(xml.ToString()));
var stack = new Stack <AXmlObject>();
stack.Push(doc);
foreach (var err in doc.SyntaxErrors)
{
AddXmlIssue(err.StartOffset - firstline.Length, err.EndOffset - err.StartOffset, err.Description);
}
while (stack.Count > 0)
{
var cur = stack.Pop();
var el = cur as AXmlElement;
if (el != null)
{
switch (el.Name)
{
case "typeparam":
case "typeparamref":
var name = el.Attributes.FirstOrDefault(attr => attr.Name == "name");
if (name == null)
{
break;
}
if (member.SymbolKind == SymbolKind.TypeDefinition)
{
var type = (ITypeDefinition)member;
if (!type.TypeArguments.Any(arg => arg.Name == name.Value))
{
AddXmlIssue(name.ValueSegment.Offset - firstline.Length + 1, name.ValueSegment.Length - 2, string.Format(ctx.TranslateString("Type parameter '{0}' not found"), name.Value));
}
}
break;
case "param":
case "paramref":
name = el.Attributes.FirstOrDefault(attr => attr.Name == "name");
if (name == null)
{
break;
}
var m = member as IParameterizedMember;
if (m != null && m.Parameters.Any(p => p.Name == name.Value))
{
break;
}
if (name.Value == "value" && (member.SymbolKind == SymbolKind.Property || member.SymbolKind == SymbolKind.Indexer || member.SymbolKind == SymbolKind.Event) && el.Name == "paramref")
{
break;
}
AddXmlIssue(name.ValueSegment.Offset - firstline.Length + 1, name.ValueSegment.Length - 2, string.Format(ctx.TranslateString("Parameter '{0}' not found"), name.Value));
break;
case "exception":
case "seealso":
case "see":
var cref = el.Attributes.FirstOrDefault(attr => attr.Name == "cref");
if (cref == null)
{
break;
}
try {
var trctx = ctx.Resolver.TypeResolveContext;
if (member is IMember)
{
trctx = trctx.WithCurrentTypeDefinition(member.DeclaringTypeDefinition).WithCurrentMember((IMember)member);
}
if (member is ITypeDefinition)
{
trctx = trctx.WithCurrentTypeDefinition((ITypeDefinition)member);
}
var state = ctx.Resolver.GetResolverStateBefore(node);
if (state.CurrentUsingScope != null)
{
trctx = trctx.WithUsingScope(state.CurrentUsingScope);
}
var cdc = new CSharpDocumentationComment(emptySource, trctx);
var entity = cdc.ResolveCref(cref.Value);
if (entity == null)
{
AddXmlIssue(cref.ValueSegment.Offset - firstline.Length + 1, cref.ValueSegment.Length - 2, string.Format(ctx.TranslateString("Cannot find reference '{0}'"), cref.Value));
}
} catch (Exception e) {
AddXmlIssue(cref.ValueSegment.Offset - firstline.Length + 1, cref.ValueSegment.Length - 2, string.Format(ctx.TranslateString("Reference parsing error '{0}'."), e.Message));
}
break;
}
}
foreach (var child in cur.Children)
{
stack.Push(child);
}
}
storedXmlComment.Clear();
}
public static void Run(ITextSource originalXmlFile)
{
int seed;
lock (sharedRnd) {
seed = sharedRnd.Next();
}
Console.WriteLine(seed);
Random rnd = new Random(seed);
AXmlParser parser = new AXmlParser();
StringBuilder b = new StringBuilder(originalXmlFile.Text);
IncrementalParserState parserState = null;
var versionProvider = new TextSourceVersionProvider();
int totalCharactersParsed = 0;
int totalCharactersChanged = originalXmlFile.TextLength;
TimeSpan incrementalParseTime = TimeSpan.Zero;
TimeSpan nonIncrementalParseTime = TimeSpan.Zero;
Stopwatch w = new Stopwatch();
for (int iteration = 0; iteration < 100; iteration++)
{
totalCharactersParsed += b.Length;
var textSource = new StringTextSource(b.ToString(), versionProvider.CurrentVersion);
w.Restart();
var incrementalResult = parser.ParseIncremental(parserState, textSource, out parserState);
w.Stop();
incrementalParseTime += w.Elapsed;
w.Restart();
var nonIncrementalResult = parser.Parse(textSource);
w.Stop();
nonIncrementalParseTime += w.Elapsed;
CompareResults(incrementalResult, nonIncrementalResult);
incrementalResult.AcceptVisitor(new ValidationVisitor(textSource));
// Randomly mutate the file:
List <TextChangeEventArgs> changes = new List <TextChangeEventArgs>();
int modifications = rnd.Next(0, 25);
int offset = 0;
for (int i = 0; i < modifications; i++)
{
if (i == 0 || rnd.Next(0, 10) == 0)
{
offset = rnd.Next(0, b.Length);
}
else
{
offset += rnd.Next(0, Math.Min(10, b.Length - offset));
}
int originalOffset = rnd.Next(0, originalXmlFile.TextLength);
int insertionLength;
int removalLength;
switch (rnd.Next(0, 21) / 10)
{
case 0:
removalLength = 0;
insertionLength = rnd.Next(0, Math.Min(50, originalXmlFile.TextLength - originalOffset));
break;
case 1:
removalLength = rnd.Next(0, Math.Min(20, b.Length - offset));
insertionLength = rnd.Next(0, Math.Min(20, originalXmlFile.TextLength - originalOffset));
break;
default:
removalLength = rnd.Next(0, b.Length - offset);
insertionLength = rnd.Next(0, originalXmlFile.TextLength - originalOffset);
break;
}
string removedText = b.ToString(offset, removalLength);
b.Remove(offset, removalLength);
string insertedText = originalXmlFile.GetText(originalOffset, insertionLength);
b.Insert(offset, insertedText);
versionProvider.AppendChange(new TextChangeEventArgs(offset, removedText, insertedText));
totalCharactersChanged += insertionLength;
}
}
Console.WriteLine("Incremental parse time: " + incrementalParseTime + " for " + totalCharactersChanged + " characters changed");
Console.WriteLine("Non-Incremental parse time: " + nonIncrementalParseTime + " for " + totalCharactersParsed + " characters");
}
