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.api.indexing | |
| org.netbeans.modules.parsing.spi |
Supports registration and automatic scheduling of various parser based tasks.
|
| org.netbeans.modules.parsing.spi.indexing | |
| org.netbeans.modules.parsing.spi.indexing.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
EmbeddingIndexer
IndexingManager.refreshAllIndices now accepts names of EmbeddingIndexers
so that embeddings can be reindexed.
QuerySupport to allow composite queries.
Extended the QuerySupport to allow composite queries with bool operators.
QuerySupport.findDependentRoots to find out source roots depending on given source root.
Added a QuerySupport.findDependentRoots method returning the dependent source roots for given source root.
It returns all the source roots which have either direct or transitive dependency on the given source root.
EmbeddingProvider.Registration annotation to register EmbeddingProviders.
Added EmbeddingProvider.Registration annotation to register EmbeddingProviders.
The registration provides a mime type of a generated embedding which allows the infrastructure to correctly
handle embedded indexes.
SuspendStatus service which can be used by indexers to find out if
indexing is suspended.
The indexing is suspended by the infrastructure when high priority request like index query or execution
of UserTask, ParserResultTask is in progress. The SuspendStatus
allows indexers to find out that indexing is suspended or to park while it's suspended.
|
|
The sources for the module are in the NetBeans Mercurial repositories.
XXX no answer for deploy-dependencies
Read more about the implementation in the answers to architecture questions.
Built on May 24 2013. | Portions Copyright 1997-2013 Oracle. All rights reserved.