public static ParseInformation ParseFile(IProjectContent fileProjectContent, string fileName, string fileContent, bool updateCommentTags) { if (fileName == null) { throw new ArgumentNullException("fileName"); } IParser parser = GetParser(fileName); if (parser == null) { return(null); } ICompilationUnit parserOutput = null; try { if (fileProjectContent == null) { // GetProjectContent is expensive because it compares all file names, so // we accept the project content as optional parameter. fileProjectContent = GetProjectContent(fileName); if (fileProjectContent == null) { fileProjectContent = DefaultProjectContent; } } if (fileContent == null) { if (!File.Exists(fileName)) { return(null); } fileContent = GetParseableFileContent(fileName); } parserOutput = parser.Parse(fileProjectContent, fileName, fileContent); if (parsings.ContainsKey(fileName)) { ParseInformation parseInformation = parsings[fileName]; fileProjectContent.UpdateCompilationUnit(parseInformation.MostRecentCompilationUnit, parserOutput, fileName); } else { fileProjectContent.UpdateCompilationUnit(null, parserOutput, fileName); } if (updateCommentTags) { TaskService.UpdateCommentTags(fileName, parserOutput.TagComments); } return(UpdateParseInformation(parserOutput, fileName, updateCommentTags)); } catch (Exception e) { MessageService.ShowError(e); } return(null); }
/// <summary> /// Builds Visual Basic's "My" namespace for the specified project. /// </summary> public static void BuildNamespace(VBNetProject project, IProjectContent pc) { ICompilationUnit cu = new DefaultCompilationUnit(pc); //cu.FileName = "GeneratedMyNamespace.vb"; // leave FileName null - fixes SD2-854 string ns; if (project.RootNamespace == null || project.RootNamespace.Length == 0) { ns = "My"; } else { ns = project.RootNamespace + ".My"; } IClass myApp = CreateMyApplication(cu, project, ns); IClass myComp = CreateMyComputer(cu, project, ns); cu.Classes.Add(myApp); cu.Classes.Add(myComp); IClass myForms = null; if (project.OutputType == OutputType.WinExe) { myForms = CreateMyForms(cu, project, ns); cu.Classes.Add(myForms); } DefaultClass c = new DefaultClass(cu, ns + ".MyProject"); c.ClassType = ClassType.Module; c.Modifiers = ModifierEnum.Internal | ModifierEnum.Partial | ModifierEnum.Sealed | ModifierEnum.Synthetic; c.Attributes.Add(new DefaultAttribute(CreateTypeRef(cu, "Microsoft.VisualBasic.HideModuleNameAttribute"))); // we need to use GetClassReturnType instead of DefaultReturnType because we need // a reference to the compound class. c.Properties.Add(new DefaultProperty("Application", new GetClassReturnType(pc, myApp.FullyQualifiedName, 0), ModifierEnum.Public | ModifierEnum.Static, DomRegion.Empty, DomRegion.Empty, c)); c.Properties.Add(new DefaultProperty("Computer", new GetClassReturnType(pc, myComp.FullyQualifiedName, 0), ModifierEnum.Public | ModifierEnum.Static, DomRegion.Empty, DomRegion.Empty, c)); if (myForms != null) { c.Properties.Add(new DefaultProperty("Forms", new GetClassReturnType(pc, myForms.FullyQualifiedName, 0), ModifierEnum.Public | ModifierEnum.Static, DomRegion.Empty, DomRegion.Empty, c)); } c.Properties.Add(new DefaultProperty("User", new GetClassReturnType(pc, "Microsoft.VisualBasic.ApplicationServices.User", 0), ModifierEnum.Public | ModifierEnum.Static, DomRegion.Empty, DomRegion.Empty, c)); cu.Classes.Add(c); pc.UpdateCompilationUnit(null, cu, cu.FileName); }
/// <summary> /// Builds Visual Basic's "My" namespace for the specified project. /// </summary> public static void BuildNamespace(VBNetProject project, IProjectContent pc) { if ("custom".Equals(project.GetEvaluatedProperty("MyType"), StringComparison.OrdinalIgnoreCase)) return; ICompilationUnit cu = new DefaultCompilationUnit(pc); //cu.FileName = "GeneratedMyNamespace.vb"; // leave FileName null - fixes SD2-854 string ns; if (project.RootNamespace == null || project.RootNamespace.Length == 0) ns = "My"; else ns = project.RootNamespace + ".My"; IClass myApp = CreateMyApplication(cu, project, ns); IClass myComp = CreateMyComputer(cu, ns); cu.Classes.Add(myApp); cu.Classes.Add(myComp); IClass myForms = null; if (project.OutputType == OutputType.WinExe) { myForms = CreateMyForms(cu, ns); cu.Classes.Add(myForms); } DefaultClass c = new DefaultClass(cu, ns + ".MyProject"); c.ClassType = ClassType.Module; c.Modifiers = ModifierEnum.Internal | ModifierEnum.Partial | ModifierEnum.Sealed | ModifierEnum.Synthetic; c.Attributes.Add(new DefaultAttribute(CreateTypeRef(cu, "Microsoft.VisualBasic.HideModuleNameAttribute"))); // we need to use GetClassReturnType instead of DefaultReturnType because we need // a reference to the compound class. c.Properties.Add(new DefaultProperty("Application", new GetClassReturnType(pc, myApp.FullyQualifiedName, 0), ModifierEnum.Public | ModifierEnum.Static, DomRegion.Empty, DomRegion.Empty, c)); c.Properties.Add(new DefaultProperty("Computer", new GetClassReturnType(pc, myComp.FullyQualifiedName, 0), ModifierEnum.Public | ModifierEnum.Static, DomRegion.Empty, DomRegion.Empty, c)); if (myForms != null) { c.Properties.Add(new DefaultProperty("Forms", new GetClassReturnType(pc, myForms.FullyQualifiedName, 0), ModifierEnum.Public | ModifierEnum.Static, DomRegion.Empty, DomRegion.Empty, c)); } c.Properties.Add(new DefaultProperty("User", new GetClassReturnType(pc, "Microsoft.VisualBasic.ApplicationServices.User", 0), ModifierEnum.Public | ModifierEnum.Static, DomRegion.Empty, DomRegion.Empty, c)); cu.Classes.Add(c); pc.UpdateCompilationUnit(null, cu, cu.FileName); }
public static ParseInformation ParseProjectContents(string fileName, string Content, bool IsOpened) { if (projContentInfo.ContainsKey(fileName) == false) { projContentInfo[fileName] = new ProjectContentItem(fileName, Content, IsOpened); } projContentInfo[fileName].Contents = Content; IParser parser = GetParser(fileName); if (parser == null) { return(null); } ICompilationUnit parserOutput = null; parserOutput = parser.Parse(projectContent, fileName, Content); lastParserError = parser.LastErrors; if (projContentInfo.ContainsKey(fileName)) { ParseInformation parseInformation = projContentInfo[fileName].ParsedContents; if (parseInformation == null) { parseInformation = new ParseInformation(); projContentInfo[fileName].ParsedContents = parseInformation; } projectContent.UpdateCompilationUnit(parseInformation.MostRecentCompilationUnit, parserOutput, fileName); } else { projectContent.UpdateCompilationUnit(null, parserOutput, fileName); } return(UpdateParseInformation(parserOutput, fileName)); }
public static ParseInformation ParseFile(IProjectContent fileProjectContent, string fileName, string fileContent, bool updateCommentTags) { if (fileName == null) { throw new ArgumentNullException("fileName"); } IParser parser = GetParser(fileName); if (parser == null) { return(null); } ICompilationUnit parserOutput = null; try { if (fileProjectContent == null) { // GetProjectContent is expensive because it compares all file names, so // we accept the project content as optional parameter. fileProjectContent = GetProjectContent(fileName); if (fileProjectContent == null) { fileProjectContent = DefaultProjectContent; } } if (fileContent == null) { if (!File.Exists(fileName)) { return(null); } fileContent = GetParseableFileContent(fileName); } parserOutput = parser.Parse(fileProjectContent, fileName, fileContent); parserOutput.Freeze(); ParseInformation parseInformation; lock (parsings) { if (!parsings.TryGetValue(fileName, out parseInformation)) { parsings[fileName] = parseInformation = new ParseInformation(); } } ICompilationUnit oldUnit = parseInformation.MostRecentCompilationUnit; fileProjectContent.UpdateCompilationUnit(oldUnit, parserOutput, fileName); parseInformation.SetCompilationUnit(parserOutput); if (updateCommentTags) { TaskService.UpdateCommentTags(fileName, parserOutput.TagComments); } try { OnParseInformationUpdated(new ParseInformationEventArgs(fileName, fileProjectContent, oldUnit, parserOutput)); } catch (Exception e) { MessageService.ShowError(e); } return(parseInformation); } catch (Exception e) { MessageService.ShowError(e, "Error parsing " + fileName); } return(null); }
public static ParseInformation ParseFile(IProjectContent fileProjectContent, string fileName, string fileContent, bool updateCommentTags) { if (fileName == null) throw new ArgumentNullException("fileName"); IParser parser = GetParser(fileName); if (parser == null) { return null; } ICompilationUnit parserOutput = null; try { if (fileProjectContent == null) { // GetProjectContent is expensive because it compares all file names, so // we accept the project content as optional parameter. fileProjectContent = GetProjectContent(fileName); if (fileProjectContent == null) { fileProjectContent = DefaultProjectContent; } } if (fileContent == null) { if (!File.Exists(fileName)) { return null; } fileContent = GetParseableFileContent(fileName); } parserOutput = parser.Parse(fileProjectContent, fileName, fileContent); if (parsings.ContainsKey(fileName)) { ParseInformation parseInformation = parsings[fileName]; fileProjectContent.UpdateCompilationUnit(parseInformation.MostRecentCompilationUnit, parserOutput, fileName); } else { fileProjectContent.UpdateCompilationUnit(null, parserOutput, fileName); } if (updateCommentTags) { TaskService.UpdateCommentTags(fileName, parserOutput.TagComments); } return UpdateParseInformation(parserOutput, fileName, updateCommentTags); } catch (Exception e) { MessageService.ShowError(e); } return null; }
public static ParseInformation ParseFile(IProjectContent fileProjectContent, string fileName, string fileContent, bool updateCommentTags) { if (fileName == null) throw new ArgumentNullException("fileName"); IParser parser = GetParser(fileName); if (parser == null) { return null; } ICompilationUnit parserOutput = null; try { if (fileProjectContent == null) { // GetProjectContent is expensive because it compares all file names, so // we accept the project content as optional parameter. fileProjectContent = GetProjectContent(fileName); if (fileProjectContent == null) { fileProjectContent = DefaultProjectContent; } } if (fileContent == null) { if (!File.Exists(fileName)) { return null; } fileContent = GetParseableFileContent(fileName); } parserOutput = parser.Parse(fileProjectContent, fileName, fileContent); parserOutput.Freeze(); ParseInformation parseInformation; lock (parsings) { if (!parsings.TryGetValue(fileName, out parseInformation)) { parsings[fileName] = parseInformation = new ParseInformation(); } } ICompilationUnit oldUnit = parseInformation.MostRecentCompilationUnit; fileProjectContent.UpdateCompilationUnit(oldUnit, parserOutput, fileName); parseInformation.SetCompilationUnit(parserOutput); if (updateCommentTags) { TaskService.UpdateCommentTags(fileName, parserOutput.TagComments); } try { OnParseInformationUpdated(new ParseInformationEventArgs(fileName, fileProjectContent, oldUnit, parserOutput)); } catch (Exception e) { MessageService.ShowError(e); } return parseInformation; } catch (Exception e) { MessageService.ShowError(e, "Error parsing " + fileName); } return null; }
public ParseInformation ParseFile(IProjectContent parentProjectContent, ITextBuffer fileContent) { if (parser == null) { return(null); } if (fileContent == null) { // GetParseableFileContent must not be called inside any lock // (otherwise we'd risk deadlocks because GetParseableFileContent must invoke on the main thread) try { fileContent = GetParseableFileContent(fileName); } catch (System.Reflection.TargetInvocationException ex) { // It is possible that the file gets deleted/becomes inaccessible while a background parse // operation is enqueued, so we have to handle IO exceptions. if (ex.InnerException is IOException || ex.InnerException is UnauthorizedAccessException) { return(null); } else { throw; } } catch (IOException) { return(null); } catch (UnauthorizedAccessException) { return(null); } } ITextBufferVersion fileContentVersion = fileContent.Version; List <IProjectContent> projectContents; lock (this) { if (this.disposed) { return(null); } if (fileContentVersion != null && this.bufferVersion != null && this.bufferVersion.BelongsToSameDocumentAs(fileContentVersion)) { if (this.bufferVersion.CompareAge(fileContentVersion) >= 0) { // Special case: (necessary due to parentProjectContent optimization) // Detect when a file belongs to multiple projects but the ParserService hasn't realized // that, yet. In this case, do another parse run to detect all parent projects. if (!(parentProjectContent != null && this.oldUnits.Length == 1 && this.oldUnits[0].ProjectContent != parentProjectContent)) { return(this.parseInfo); } } } if (parentProjectContent != null && (oldUnits.Length == 0 || (oldUnits.Length == 1 && oldUnits[0].ProjectContent == parentProjectContent))) { // Optimization: if parentProjectContent is specified and doesn't conflict with what we already know, // we will use it instead of doing an expensive GetProjectContents call. projectContents = new List <IProjectContent>(); projectContents.Add(parentProjectContent); } else { projectContents = GetProjectContents(fileName); } } // We now leave the lock to do the actual parsing. // This is done to allow IParser implementations to invoke methods on the main thread without // risking deadlocks. // parse once for each project content that contains the file ICompilationUnit[] newUnits = new ICompilationUnit[projectContents.Count]; ICompilationUnit resultUnit = null; for (int i = 0; i < newUnits.Length; i++) { IProjectContent pc = projectContents[i]; try { newUnits[i] = parser.Parse(pc, fileName, fileContent); } catch (Exception ex) { throw new ApplicationException("Error parsing " + fileName, ex); } if (i == 0 || pc == parentProjectContent) { resultUnit = newUnits[i]; } } lock (this) { if (this.disposed) { return(null); } // ensure we never go backwards in time (we need to repeat this check after we've reacquired the lock) if (fileContentVersion != null && this.bufferVersion != null && this.bufferVersion.BelongsToSameDocumentAs(fileContentVersion)) { if (this.bufferVersion.CompareAge(fileContentVersion) >= 0) { if (parentProjectContent != null && parentProjectContent != parseInfo.CompilationUnit.ProjectContent) { ICompilationUnit oldUnit = oldUnits.FirstOrDefault(o => o.ProjectContent == parentProjectContent); if (oldUnit != null) { return(new ParseInformation(oldUnit)); } } return(this.parseInfo); } } ParseInformation newParseInfo = new ParseInformation(resultUnit); for (int i = 0; i < newUnits.Length; i++) { IProjectContent pc = projectContents[i]; // update the compilation unit ICompilationUnit oldUnit = oldUnits.FirstOrDefault(o => o.ProjectContent == pc); pc.UpdateCompilationUnit(oldUnit, newUnits[i], fileName); ParseInformation newUnitParseInfo = (newUnits[i] == resultUnit) ? newParseInfo : new ParseInformation(newUnits[i]); RaiseParseInformationUpdated(new ParseInformationEventArgs(fileName, pc, oldUnit, newUnitParseInfo, newUnits[i] == resultUnit)); } // remove all old units that don't exist anymore foreach (ICompilationUnit oldUnit in oldUnits) { if (!newUnits.Any(n => n.ProjectContent == oldUnit.ProjectContent)) { oldUnit.ProjectContent.RemoveCompilationUnit(oldUnit); RaiseParseInformationUpdated(new ParseInformationEventArgs(fileName, oldUnit.ProjectContent, oldUnit, null, false)); } } this.bufferVersion = fileContentVersion; this.oldUnits = newUnits; this.parseInfo = newParseInfo; return(newParseInfo); } }
public static ParseInformation ParseProjectContents(string fileName, string Content, bool IsOpened) { //try // { lock (s_obs) { if (s_projContentInfo == null) { s_projContentInfo = new Dictionary <string, ProjectContentItem>(); } if (s_projContentInfo.ContainsKey(fileName) == false) { s_projContentInfo[fileName] = new ProjectContentItem(fileName, Content, IsOpened); } s_projContentInfo[fileName].Contents = Content; IParser parser = GetParser(fileName); if (parser == null) { MessageBox.Show("Parser errors.."); return(null); } ICompilationUnit parserOutput = null; parserOutput = parser.Parse(s_projectContent, fileName, Content); if (parserOutput == null) { MessageBox.Show("Parser errors.."); return(null); } s_lastParserError = parser.LastErrors; if (s_projContentInfo.ContainsKey(fileName)) { ParseInformation parseInformation = s_projContentInfo[fileName].ParsedContents; if (parseInformation == null) { parseInformation = new ParseInformation(); s_projContentInfo[fileName].ParsedContents = parseInformation; } s_projectContent.UpdateCompilationUnit(parseInformation.MostRecentCompilationUnit, parserOutput, fileName); } else { s_projectContent.UpdateCompilationUnit(null, parserOutput, fileName); } return(UpdateParseInformation(parserOutput, fileName)); // } //} //catch (Exception ex) //{ //} //finally //{ //} //return null; } }