See: Description
| Package | Description |
|---|---|
| org.netbeans.modules.parsing.api |
Support for calling of high priority parser based user tasks in multi
language environment.
|
| org.netbeans.modules.parsing.spi |
Supports registration and automatic scheduling of various parser based tasks.
|
| org.netbeans.modules.parsing.spi.support |
Parsing API defines contract between parsers registerred for diferent languages and the rest of IDE. It is language neutral and it supports language embeddings.
The basic Parsing API constructs are Source, Snapshot and Embedding. Source identificates some concrete file or document. There is always at most one Source for one FileObject. Snapshot represents some concrete content of Source, and it is immutable. And Embedding represents some part of Snapshot written in different language. Embedding can contain some virtual code that is not contained in outside language too. Content of Embedding is represented by Snapshot and it can contain another Embeddings, so embeddings are recursive.
Parser is represented by abstract class called
Parser.
The only way how to register a new parser for some concrete mime type
is to implement
ParserFactory,
and register it in your manifest file in folder called
"Editors/" + mimeType. A new instance of Parser is always
created for some concrete Snapshot, or collection of Snapshots. One
instance of parser can be reused for more Snapshots created from the same
Source. Result of parsing (AST, syntax errors, semantic information) is
represented by
Parser.Result
class. Parser creates a new instance of Parser.Result for each Task.
Following example shows how to integrate parser to the NetBeans using
Parsing API:
class FooParserFactory extends ParserFactory {
public Parser createParser (
Collection<Snapshot> snapshots
) {
return new FooParser ();
}
private static class FooParser extends Parser {
private boolean cancelled = false;
private AST ast;
public void parse (
Snapshot snapshot,
Task task,
SchedulerEvent event
) throws ParseException {
cancelled = false;
for (...) {
// parsing snapshot.getText ();
if (cancelled) return;
}
ast = ...;
}
public abstract Result getResult (
Task task,
SchedulerEvent event
) throws ParseException {
return new FooResult (ast);
}
public void cancel () {
cancelled = true;
}
public void addChangeListener (
ChangeListener changeListener
) {
}
public void removeChangeListener (
ChangeListener changeListener
) {
}
}
public static class FooResult extends Result {
private AST ast;
private boolean valid = true;
FooResult (
AST ast
) {
this.ast = ast;
}
public AST getAST () {
if (!valid) throw new InvalidResultException ();
return ast;
}
public void invalidate () {
valid = false;
ast = null;
}
}
}
Parsing API defines two basic kinds of Tasks. High priority UserTasks and SchedulerTasks.
Execution of UserTask is synchnonous and it stops execution of all other tasks. There are two types of UserTask. Simple UserTask that supports some computations based on one block code written in one language. And MultiLanguageUserTask (???) that supports scanning of all blocks of code written in different languages embedded in one Source.
User of Parsing API can register various implementations of SchedulerTask for any language. Each SchedulerTask is registered for some specific Scheduler. Scheduler defines when task shoud be started (for example when current editor is changed, when some nodes are selected in Project View, or when cursor position is changed).
There are two specific tasks that can define language embedding. So task implementator can recognize blocks of embedded languages. Parsing API contains support for high priority ParsingAPI
Adding a new method, Parser.Result.processingFinished, used to mark a result as completely finished, or not completely finished.
SuspendStatus.isSuspendSupported
Added SuspendStatus.isSuspendSupported which test if active indexing task
supports suspending.
QuerySupport.findRoots mapping class paths roots by projects.
Added QuerySupport.findRoots mapping class paths roots by projects.
In the presence of multiple scopes or users, the parsing system needs to access the proper context even though the work is done by different threads. It also has to propagate the proper context back to the user tasks.
Source can now be created with a Lookup that provides such proper context, or automatically uses Lookup.getDefault if no explicit Lookup is given.
QuerySupport.Query.file factory for query searching index documents created for given file.
Added QuerySupport.Query.file factory for query searching index documents created for given file.
|
|
The sources for the module are in the Apache Git repositories or in the GitHub repositories.
XXX no answer for deploy-dependencies
Read more about the implementation in the answers to architecture questions.