protected override void OnNewFile(LibraryTask task)
{
if (IsNonMemberItem(task.ModuleID.Hierarchy, task.ModuleID.ItemID))
{
return;
}
var project = task.ModuleID.Hierarchy
.GetProject()
.GetPythonProject();
if (project == null)
{
return;
}
AnalysisCompleteHandler handler;
lock (_handlers) {
if (!_handlers.TryGetValue(project, out handler))
{
_handlers[project] = handler = new AnalysisCompleteHandler(this, project);
}
}
handler.AddTask(task);
}
protected override void OnNewFile(LibraryTask task)
{
if (IsNonMemberItem(task.ModuleID.Hierarchy, task.ModuleID.ItemID))
{
return;
}
var analyzer = task.ModuleID.Hierarchy
.GetProject()
.GetPythonProject()
.GetAnalyzer();
AnalysisEntry item;
if (analyzer.GetAnalysisEntryFromPath(task.FileName) == null)
{
analyzer.AnalyzeFileAsync(task.FileName).ContinueWith(x => {
item = x.Result;
if (item != null)
{
// We subscribe to OnNewAnalysis here instead of OnNewParseTree so that
// in the future we can use the analysis to include type information in the
// object browser (for example we could include base type information with
// links elsewhere in the object browser).
item.AnalysisComplete += (sender, args) => {
_package.GetUIThread().InvokeAsync(() => FileParsed(task))
.HandleAllExceptions(_package, GetType())
.DoNotWait();
};
}
});
}
}
protected override void OnNewFile(LibraryTask task)
{
IProjectEntry item;
if (task.TextBuffer != null)
{
item = task.TextBuffer.GetAnalysis();
}
else
{
item = task.ModuleID.Hierarchy.GetProject().GetPythonProject().GetAnalyzer().AnalyzeFile(task.FileName);
}
IPythonProjectEntry pyCode;
if (item != null && (pyCode = item as IPythonProjectEntry) != null)
{
// We subscribe to OnNewAnalysis here instead of OnNewParseTree so that
// in the future we can use the analysis to include type information in the
// object browser (for example we could include base type information with
// links elsewhere in the object browser).
pyCode.OnNewAnalysis += (sender, args) => {
FileParsed(task, new AstScopeNode(pyCode.Tree, pyCode));
};
}
}
protected override void OnNewFile(LibraryTask task)
{
if (IsNonMemberItem(task.ModuleID.Hierarchy, task.ModuleID.ItemID))
{
return;
}
/*
* IProjectEntry item;
* if (task.TextBuffer != null) {
* item = task.TextBuffer.GetAnalysis();
* } else {
* item = task.ModuleID.Hierarchy.GetProject().GetLuaProject().GetAnalyzer().AnalyzeFile(task.FileName);
* }
*
* ILuaProjectEntry pyCode;
* if (item != null && (pyCode = item as ILuaProjectEntry) != null) {
* // We subscribe to OnNewAnalysis here instead of OnNewParseTree so that
* // in the future we can use the analysis to include type information in the
* // object browser (for example we could include base type information with
* // links elsewhere in the object browser).
* pyCode.OnNewAnalysis += (sender, args) => {
* FileParsed(task, new AstScopeNode(pyCode.Tree, pyCode));
* };
* }*/
}
protected override void OnNewFile(LibraryTask task)
{
if (IsNonMemberItem(task.ModuleID.Hierarchy, task.ModuleID.ItemID))
{
return;
}
IPythonProjectEntry item;
if (task.TextBuffer == null || !task.TextBuffer.TryGetPythonProjectEntry(out item))
{
item = task.ModuleID.Hierarchy
.GetProject()
.GetPythonProject()
.GetAnalyzer()
.AnalyzeFile(task.FileName) as IPythonProjectEntry;
}
if (item != null)
{
// We subscribe to OnNewAnalysis here instead of OnNewParseTree so that
// in the future we can use the analysis to include type information in the
// object browser (for example we could include base type information with
// links elsewhere in the object browser).
item.OnNewAnalysis += (sender, args) => {
_package.GetUIThread().InvokeAsync(() => FileParsed(task, new AstScopeNode(item.Tree, item)))
.HandleAllExceptions(_package, GetType())
.DoNotWait();
};
}
}
private void CreateParseRequest(string file, string text, ModuleId id)
{
LibraryTask task = new LibraryTask(file, text);
task.ModuleID = id;
lock (requests) {
requests.Enqueue(task);
}
requestPresent.Set();
}
private void CreateUpdateTreeRequest(string file, XSharpModuleId id)
{
if (XSolution.IsClosing)
{
return;
}
LibraryTask task = new LibraryTask(file, id);
task.ModuleID = id;
lock (requests)
{
requests.Enqueue(task);
}
requestPresent.Set();
}
protected override void OnNewFile(LibraryTask task)
{
//AnalysisItem item;
//if (task.TextBuffer != null) {
// item = task.TextBuffer.GetAnalysis();
//} else {
// item = IronRubyToolsPackage.Instance.Analyzer.AnalyzeFile(task.FileName);
//}
// We subscribe to OnNewAnalysis here instead of OnNewParseTree so that
// in the future we can use the analysis to include type information in the
// object browser (for example we could include base type information with
// links elsewhere in the object browser).
//item.OnNewAnalysis += (sender, args) => {
// FileParsed(task, new AstScopeNode(item.CurrentTree, item.Entry));
//};
}
/// <summary>
/// Called by derived class when a file has been parsed. The caller should
/// provide the LibraryTask received from the OnNewFile call and an IScopeNode
/// which represents the contents of the library.
///
/// It is safe to call this method from any thread.
/// </summary>
protected void FileParsed(LibraryTask task, IScopeNode scope)
{
var project = task.ModuleID.Hierarchy as IProject;
HierarchyNode fileNode = null;
if (project != null)
{
fileNode = ((ProjectSmuggler)project.Project).Project.NodeFromItemId(task.ModuleID.ItemID);
}
LibraryNode module = CreateFileLibraryNode(
fileNode,
System.IO.Path.GetFileName(task.FileName),
task.FileName,
LibraryNodeType.PhysicalContainer
);
// TODO: Creating the module tree should be done lazily as needed
// Currently we replace the entire tree and rely upon the libraries
// update count to invalidate the whole thing. We could do this
// finer grained and only update the changed nodes. But then we
// need to make sure we're not mutating lists which are handed out.
CreateModuleTree(module, module, scope, task.FileName + ":", task.ModuleID);
if (null != task.ModuleID)
{
LibraryNode previousItem = null;
lock (_files) {
if (_files.TryGetValue(task.ModuleID, out previousItem))
{
_files.Remove(task.ModuleID);
}
}
_library.RemoveNode(previousItem);
}
_library.AddNode(module);
if (null != task.ModuleID)
{
lock (_files) {
_files.Add(task.ModuleID, module);
}
}
}
/// <summary>
/// Main function of the parsing thread.
/// This function waits on the queue of the parsing requests and build the parsing tree for
/// a specific file. The resulting tree is built using LibraryNode objects so that it can
/// be used inside the class view or object browser.
/// </summary>
private void ParseThread()
{
const int waitTimeout = 500;
// Define the array of events this function is interest in.
WaitHandle[] eventsToWait = new WaitHandle[] { requestPresent, shutDownStarted };
// Execute the tasks.
while (true)
{
// Wait for a task or a shutdown request.
int waitResult = WaitHandle.WaitAny(eventsToWait, waitTimeout, false);
if (1 == waitResult)
{
// The shutdown of this component is started, so exit the thread.
return;
}
LibraryTask task = null;
lock (requests) {
if (0 != requests.Count)
{
task = requests.Dequeue();
}
if (0 == requests.Count)
{
requestPresent.Reset();
}
}
if (null == task)
{
continue;
}
ScopeNode scope = null;
if (null == task.Text)
{
if (System.IO.File.Exists(task.FileName))
{
scope = ScopeWalker.GetScopesFromFile(task.FileName);
}
}
else
{
scope = ScopeWalker.GetScopesFromText(task.Text);
}
LibraryNode module = new LibraryNode(
System.IO.Path.GetFileName(task.FileName),
LibraryNode.LibraryNodeType.PhysicalContainer);
CreateModuleTree(module, module, scope, "", task.ModuleID);
if (null != task.ModuleID)
{
LibraryNode previousItem = null;
lock (files) {
if (files.TryGetValue(task.ModuleID, out previousItem))
{
files.Remove(task.ModuleID);
}
}
library.RemoveNode(previousItem);
}
library.AddNode(module);
if (null != task.ModuleID)
{
lock (files) {
files.Add(task.ModuleID, module);
}
}
}
}
public void AddTask(LibraryTask task)
{
lock (_tasks) {
_tasks[task.FileName] = task;
}
}
protected override void OnNewFile(LibraryTask task)
{
}
/// <summary>
/// Main function of the parsing thread.
/// This function waits on the queue of the parsing requests and build the parsing tree for
/// a specific file. The resulting tree is built using LibraryNode objects so that it can
/// be used inside the class view or object browser.
/// </summary>
private void UpdateTreeThread()
{
const int waitTimeout = 500;
// Define the array of events this function is interest in.
WaitHandle[] eventsToWait = new WaitHandle[] { requestPresent, shutDownStarted };
// Execute the tasks.
while (true)
{
// Wait for a task or a shutdown request.
int waitResult = WaitHandle.WaitAny(eventsToWait, waitTimeout, false);
if (waitResult == 1)
{
// The shutdown of this component is started, so exit the thread.
return;
}
if (waitResult == WaitHandle.WaitTimeout)
{
continue;
}
//
LibraryTask task = null;
lock (requests)
{
if (0 != requests.Count)
{
task = requests.Dequeue();
}
if (0 == requests.Count)
{
requestPresent.Reset();
}
}
if (null == task)
{
continue;
}
//
XFile scope = null;
if (System.IO.File.Exists(task.FileName))
{
scope = XSharpModel.XSolution.FindFile(task.FileName);
if (scope == null || (!scope.HasCode))
{
continue;
}
}
// If the file already exist
lock (files)
{
// These are the existing Modules
XSharpModuleId[] aTmp = new XSharpModuleId[files.Keys.Count];
files.Keys.CopyTo(aTmp, 0);
// Does this module already exist ?
XSharpModuleId found = Array.Find <XSharpModuleId>(aTmp, (x => x.Equals(task.ModuleID)));
if (found != null)
{
// Doesn't it have the same members?
if (found.ContentHashCode == task.ModuleID.ContentHashCode)
{
continue;
}
//
HashSet <XSharpLibraryNode> values = null;
// Ok, now remove ALL nodes for that key
if (files.TryGetValue(task.ModuleID, out values))
{
foreach (XSharpLibraryNode node in values)
{
if (node.Freeing(task.ModuleID.ItemID) == 0)
{
if (node.parent != null)
{
node.parent.RemoveNode(node);
}
}
}
// and then remove the key
files.Remove(task.ModuleID);
}
}
//
LibraryNode prjNode = this.library.SearchHierarchy(task.ModuleID.Hierarchy);
if (prjNode is XSharpLibraryProject)
{
//
CreateModuleTree((XSharpLibraryProject)prjNode, scope, task.ModuleID);
//
prjNode.updateCount += 1;
//this.prjNode.AddNode(node);
//library.AddNode(node);
this.library.Refresh();
}
}
}
}
/// <summary>
/// Overridden in the base class to receive notifications of when a file should
/// be analyzed for inclusion in the library. The derived class should queue
/// the parsing of the file and when it's complete it should call FileParsed
/// with the provided LibraryTask and an IScopeNode which provides information
/// about the members of the file.
/// </summary>
protected virtual void OnNewFile(LibraryTask task)
{
}
/// <summary>
/// Main function of the parsing thread.
/// This function waits on the queue of the parsing requests and build the parsing tree for
/// a specific file. The resulting tree is built using LibraryNode objects so that it can
/// be used inside the class view or object browser.
/// </summary>
private void ParseThread()
{
const int waitTimeout = 500;
// Define the array of events this function is interest in.
WaitHandle[] eventsToWait = new WaitHandle[] { requestPresent, shutDownStarted };
// Execute the tasks.
while (true)
{
// Wait for a task or a shutdown request.
int waitResult = WaitHandle.WaitAny(eventsToWait, waitTimeout, false);
if (1 == waitResult)
{
// The shutdown of this component is started, so exit the thread.
return;
}
LibraryTask task = null;
lock (requests) {
if (0 != requests.Count)
{
task = requests.Dequeue();
}
if (0 == requests.Count)
{
requestPresent.Reset();
}
}
if (null == task)
{
continue;
}
string sourceText = task.Text;
if (sourceText == null)
{
//should not happen, but to be robust
if (!System.IO.File.Exists(task.FileName))
{
continue;
}
//read file content as string
try {
using (System.IO.StreamReader sr = System.IO.File.OpenText(task.FileName)) {
sourceText = sr.ReadToEnd();
}
}
catch (Exception ex) {
System.Diagnostics.Trace.WriteLine(String.Format("Error when parsing file '{0}': {1}\n{2}", task.FileName, ex.Message, ex.StackTrace));
continue;
}
}
if (string.IsNullOrEmpty(sourceText))
{
continue;
}
CocoParserProxy.CocoParseResult result = CocoParserProxy.Parse(sourceText, task.FileName);
//maybe use coco-library entry (to avoid not-implemented exception in librarynode.getcategory2)
CocoLibraryNode module = new CocoLibraryNode(
System.IO.Path.GetFileName(task.FileName),
1,
1,
1,
task.ModuleID.Hierarchy,
task.ModuleID.ItemID,
LibraryNode.LibraryNodeType.Classes);
CreateLibraryEntry(module, result, task.ModuleID);
if (null != task.ModuleID)
{
LibraryNode previousItem = null;
lock (files) {
if (files.TryGetValue(task.ModuleID, out previousItem))
{
files.Remove(task.ModuleID);
}
}
library.RemoveNode(previousItem);
}
library.AddNode(module);
if (null != task.ModuleID)
{
lock (files) {
files.Add(task.ModuleID, module);
}
}
}
}
/// <summary>
/// Main function of the parsing thread.
/// This function waits on the queue of the parsing requests and build
/// the parsing tree for a specific file. The resulting tree is built
/// using LibraryNode objects so that it can be used inside the class
/// view or object browser.
/// </summary>
void ParseThread()
{
const int waitTimeout = 500;
// Define the array of events this function is interest in.
//
WaitHandle[] eventsToWait = new WaitHandle[] { _requestPresent, _shutDownStarted };
// Execute the tasks.
//
while (true)
{
// Wait for a task or a shutdown request.
//
int waitResult = WaitHandle.WaitAny(eventsToWait, waitTimeout, false);
if (1 == waitResult)
{
// The shutdown of this component is started, so exit the thread.
return;
}
LibraryTask task = null;
lock (_requests)
{
if (_requests.Count != 0)
{
task = _requests.Dequeue();
}
if (_requests.Count == 0)
{
_requestPresent.Reset();
}
}
if (null == task)
{
continue;
}
ScopeNode scope = null;
if (task.Text == null)
{
if (File.Exists(task.FileName))
{
Debug.WriteLine("Parse request (no text): " + task.FileName + " " + task.ModuleID);
return;
}
}
else
{
Debug.WriteLine("Parse request: " + task.FileName + " " + task.ModuleID);
return;
}
LibraryNode module = new LibraryNode(
Path.GetFileName(task.FileName),
LibraryNode.LibraryNodeType.PhysicalContainer);
CreateModuleTree(module, module, scope, "", task.ModuleID);
if (task.ModuleID != null)
{
LibraryNode previousItem;
lock (_files)
if (_files.TryGetValue(task.ModuleID, out previousItem))
{
_files.Remove(task.ModuleID);
}
_library.RemoveNode(previousItem);
}
_library.AddNode(module);
if (task.ModuleID != null)
{
lock (_files)
_files.Add(task.ModuleID, module);
}
}
}
void CreateParseRequest(string file, string text, ModuleID id)
{
LibraryTask task = new LibraryTask(file, text);
task.ModuleID = id;
lock (_requests)
_requests.Enqueue(task);
_requestPresent.Set();
}
public LibraryNode Parse(LibraryTask task)
{
this.filename = task.FileName;
this.moduleId = task.ModuleID;
LibraryNode filenode = new LibraryNode(System.IO.Path.GetFileName(filename), LibraryNode.LibraryNodeType.PhysicalContainer, moduleId);
LibraryNode globalnode = new LibraryNode("(Global Scope)", LibraryNode.LibraryNodeType.Package, moduleId);
start = new SourceLocation(0, 0);
end = new SourceLocation(0, 0);
globalnode.StartLine = start.line;
globalnode.StartCol = start.col;
filenode.AddNode(globalnode);
try
{
if (task.Text == null)
{
lexer.SetSource(File.ReadAllText(filename), 0);
}
else
{
lexer.SetSource(task.Text, 0);
}
Lex();
while (_token > 0 && !lexer.IsEob())
{
try
{
switch (_token)
{
case (int)Token.FUNCTION:
Lex();
if (_token == '(') // ignoring function literals for now - josh
{
MatchBraces('{', '}');
}
else
{
LibraryNode fnode = ParseFunction(false);
if (fnode.NodeType == LibraryNode.LibraryNodeType.Members)
{
globalnode.AddNode(fnode);
}
else
{
filenode.AddNode(fnode);
}
}
break;
case (int)Token.DOUBLE_COLON:
Lex();
continue;
case (int)Token.IDENTIFIER:
LibraryNode inode = ParseClassOrTable(true);
if (inode != null)
{
globalnode.AddNode(inode);
}
/*
* else
* {
* SkipToEndOfTheLine();
* }
*/
break;
case (int)Token.CLASS:
Lex();
filenode.AddNode(ParseClassOrTable(false));
break;
case (int)Token.ENUM:
Lex();
LibraryNode enode = ParseEnum();
globalnode.AddNode(enode);
break;
case (int)Token.LINE_COMMENT:
Lex();
break;
default:
SkipToEndOfTheLine();
break;
}
}
catch (Exception e)
{
if (parselogging)
{
logger.Log(filename + ": " + e.Message);
}
Lex();
}
}
}
catch (Exception e)
{
if (parselogging)
{
logger.Log("cannot read " + filename + ": " + e.Message);
}
}
if (filenode.Children[0].Children.Count == 0)
{
filenode.RemoveNode(filenode.Children[0]);
}
globalnode.EndLine = end.line;
globalnode.EndCol = end.col;
return(filenode);
}
