Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2004, 2012 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html Contributors: IBM Corporation - initial API and implementation /
  
  package org.eclipse.jdt.core.dom;
  
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import  org.eclipse.core.runtime.IProgressMonitor;
A Java language parser for creating abstract syntax trees (ASTs).

Example: Create basic AST from source string

 char[] source = ...;
 ASTParser parser = ASTParser.newParser(AST.JLS3);  // handles JDK 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6
 parser.setSource(source);
 // In order to parse 1.5 code, some compiler options need to be set to 1.5
 Map options = JavaCore.getOptions();
 JavaCore.setComplianceOptions(JavaCore.VERSION_1_5, options);
 parser.setCompilerOptions(options);
 CompilationUnit result = (CompilationUnit) parser.createAST(null);
 
Once a configured parser instance has been used to create an AST, the settings are automatically reset to their defaults, ready for the parser instance to be reused.

There are a number of configurable features:

  • Source string from char[], ICompilationUnit, or IClassFile, and limited to a specified subrange.
  • Whether bindings will be created.
  • Which working copy owner to use when resolving bindings.
  • A hypothetical compilation unit file name and Java project for locating a raw source string in the Java model (when resolving bindings)
  • Which compiler options to use. This is especially important to use if the parsing/scanning of the source code requires a different version than the default of the workspace. For example, the workspace defaults are 1.4 and you want to create an AST for a source code that is using 1.5 constructs.
  • Whether to parse just an expression, statements, or body declarations rather than an entire compilation unit.
  • Whether to return a abridged AST focused on the declaration containing a given source position.

Since:
3.0
Noinstantiate:
This class is not intended to be instantiated by clients.
  
  public class ASTParser {

Kind constant used to request that the source be parsed as a single expression.
  
  	public static final int K_EXPRESSION = 0x01;

Kind constant used to request that the source be parsed as a sequence of statements.
 
 	public static final int K_STATEMENTS = 0x02;

Kind constant used to request that the source be parsed as a sequence of class body declarations.
 
 	public static final int K_CLASS_BODY_DECLARATIONS = 0x04;

Kind constant used to request that the source be parsed as a compilation unit.
 
 	public static final int K_COMPILATION_UNIT = 0x08;

Creates a new object for creating a Java abstract syntax tree (AST) following the specified set of API rules.

Parameters:
level the API level; one of the .JLS* level constants declared on AST
Returns:
new ASTParser instance
 
 	public static ASTParser newParser(int level) {
 		return new ASTParser(level);
 	}

Level of AST API desired.
 
 	private final int apiLevel;

Kind of parse requested. Defaults to an entire compilation unit.
 
 	private int astKind;

Compiler options. Defaults to JavaCore.getOptions().
 
 	private Map compilerOptions;

    
The focal point for a partial AST request. Only used when partial is true.
 
 	private int focalPointPosition;

    
Source string.
 
     private char[] rawSource = null;

    
Java model class file or compilation unit supplying the source.
 
     private ITypeRoot typeRoot = null;

    
Character-based offset into the source string where parsing is to begin. Defaults to 0.
 
 	private int sourceOffset = 0;

    
Character-based length limit, or -1 if unlimited. All characters in the source string between offset and offset+length-1 inclusive are parsed. Defaults to -1, which means the rest of the source string.
 
 	private int sourceLength = -1;

    
Working copy owner. Defaults to primary owner.
 
Java project used to resolve names, or null if none. Defaults to none.
 
 	private IJavaProject project = null;

    
Name of the compilation unit for resolving bindings, or null if none. Defaults to none.
 
 	private String unitName = null;

Classpath entries to use to resolve bindings when no java project are available.
 
 	private String[] classpaths;

Sourcepath entries to use to resolve bindings when no java project are available.
 
 	private String[] sourcepaths;

Encoding of the given sourcepaths entries.
 
Bits used to set the different values from CompilationUnitResolver values.
 
 	private int bits;

Creates a new AST parser for the given API level.

N.B. This constructor is package-private.

Parameters:
level the API level; one of the JLS* level constants declared on AST
 
 	ASTParser(int level) {
 		switch(level) {
 			case .:
 				break;
 			default:
 				throw new IllegalArgumentException();
 		}
 		this. = level;
 	}
 
 	private List getClasspath() throws IllegalStateException {
 		Main main = new Main(new PrintWriter(.), new PrintWriter(.), false/*systemExit*/null/*options*/null/*progress*/);
 		ArrayList allClasspaths = new ArrayList();
 		try {
 				org.eclipse.jdt.internal.compiler.util.Util.collectRunningVMBootclasspath(allClasspaths);
 			}
 			if (this. != null) {
 				for (int i = 0, max = this..lengthi < maxi++) {
 					String encoding = this. == null ? null : this.[i];
 							allClasspathsthis.[i], encodingtruefalse);
 				}
 			}
 			if (this. != null) {
 				for (int i = 0, max = this..lengthi < maxi++) {
 							allClasspathsthis.[i], nullfalsefalse);
 				}
 			}
 			ArrayList pendingErrors = main.pendingErrors;
 			if (pendingErrors != null && pendingErrors.size() != 0) {
 				throw new IllegalStateException("invalid environment settings"); //$NON-NLS-1$
 			}
 		} catch (IllegalArgumentException e) {
 			throw new IllegalStateException("invalid environment settings"); //$NON-NLS-1$
 		}
 		return allClasspaths;
 	}
Sets all the setting to their default values.
 
 	private void initializeDefaults() {
 		this. = null;
 		this. = null;
 		this. = 0;
 		this. = -1;
 		this. = 0;
 		this. = null;
 		this. = null;
 		this. = null;
 		this. = null;
 		this. = null;
 		Map options = JavaCore.getOptions();
 		options.remove(.); // no need to parse task tags
 		this. = options;
 	}

Requests that the compiler should perform bindings recovery. When bindings recovery is enabled the compiler returns incomplete bindings.

Default to false.

This should be set to true only if bindings are resolved. It has no effect if there is no binding resolution.

Parameters:
enabled true if incomplete bindings are expected, and false if only complete bindings are expected.
Since:
3.3
See also:
IBinding.isRecovered()
 
 	public void setBindingsRecovery(boolean enabled) {
 		if (enabled) {
 		} else {
 		}
 	}

Sets the environment to be used when no IJavaProject is available.

The user has to make sure that all the required types are included either in the classpath or source paths. All the paths containing binary types must be included in the classpathEntries whereas all paths containing source types must be included in the sourcepathEntries.

All paths in the classpathEntries and sourcepathEntries are absolute paths.

If the source paths contain units using a specific encoding (other than the platform encoding), then the given encodings must be set. When the encodings is set to non null, its length must match the length of sourcepathEntries or an IllegalArgumentException will be thrown.

If encodings is not null, the given sourcepathEntries must not be null.

Parameters:
classpathEntries the given classpath entries to be used to resolve bindings
sourcepathEntries the given sourcepath entries to be used to resolve bindings
encodings the encodings of the corresponding sourcepath entries or null if the platform encoding can be used.
includeRunningVMBootclasspath true if the bootclasspath of the running VM must be prepended to the given classpath and false if the bootclasspath of the running VM should be ignored.
Throws:
IllegalArgumentException if the size of the given encodings is not equals to the size of the given sourcepathEntries
Since:
3.6
 
 	public void setEnvironment(String[] classpathEntriesString[] sourcepathEntriesString[] encodingsboolean includeRunningVMBootclasspath) {
 		this. = classpathEntries;
 		this. = sourcepathEntries;
 		this. = encodings;
 		if (encodings != null) {
 			if (sourcepathEntries == null || sourcepathEntries.length != encodings.length) {
 				throw new IllegalArgumentException(); 
 			}
 		}
 		if (includeRunningVMBootclasspath) {
 		}
 	}
Sets the compiler options to be used when parsing.

Note that setSource(IClassFile), setSource(ICompilationUnit), and setProject(IJavaProject) reset the compiler options based on the Java project. In other cases, compiler options default to JavaCore.getOptions(). In either case, and especially in the latter, the caller should carefully weight the consequences of allowing compiler options to be defaulted as opposed to being explicitly specified for the ASTParser instance. For instance, there is a compiler option called "Source Compatibility Mode" which determines which JDK level the source code is expected to meet. If you specify "1.4", then "assert" is treated as a keyword and disallowed as an identifier; if you specify "1.3", then "assert" is allowed as an identifier. So this particular setting has a major bearing on what is considered syntactically legal. By explicitly specifying the setting, the client control exactly how the parser works. On the other hand, allowing default settings means the parsing behaves like other JDT tools.

Parameters:
options the table of options (key type: String; value type: String), or null to set it back to the default
 
 	public void setCompilerOptions(Map options) {
 		if (options == null) {
 			options = JavaCore.getOptions();
 		} else {
 			// copy client's options so as to not do any side effect on them
 			options = new HashMap(options);
 		}
 		options.remove(.); // no need to parse task tags
 		this. = options;
 	}

Requests that the compiler should provide binding information for the AST nodes it creates.

Default to false (no bindings).

If setResolveBindings(true), the various names and types appearing in the AST can be resolved to "bindings" by calling the resolveBinding methods. These bindings draw connections between the different parts of a program, and generally afford a more powerful vantage point for clients who wish to analyze a program's structure more deeply. These bindings come at a considerable cost in both time and space, however, and should not be requested frivolously. The additional space is not reclaimed until the AST, all its nodes, and all its bindings become garbage. So it is very important to not retain any of these objects longer than absolutely necessary. Bindings are resolved at the time the AST is created. Subsequent modifications to the AST do not affect the bindings returned by resolveBinding methods in any way; these methods return the same binding as before the AST was modified (including modifications that rearrange subtrees by reparenting nodes). If setResolveBindings(false), (the default), the analysis does not go beyond parsing and building the tree, and all resolveBinding methods return null from the outset.

When bindings are requested, instead of considering compilation units on disk only one can supply a WorkingCopyOwner. Working copies owned by this owner take precedence over the underlying compilation units when looking up names and drawing the connections.

Note that working copy owner are used only if the org.eclipse.jdt.core bundle is initialized.

Binding information is obtained from the Java model. This means that the compilation unit must be located relative to the Java model. This happens automatically when the source code comes from either setSource(ICompilationUnit) or setSource(IClassFile). When source is supplied by setSource(char[]), the location must be established explicitly by setting an environment using setProject(IJavaProject) or setEnvironment(String[], String[], String[], boolean) and a unit name setUnitName(String). Note that the compiler options that affect doc comment checking may also affect whether any bindings are resolved for nodes within doc comments.

Parameters:
enabled true if bindings are wanted, and false if bindings are not of interest
 
 	public void setResolveBindings(boolean enabled) {
 		if (enabled) {
 		} else {
 		}
 	}

Requests an abridged abstract syntax tree. By default, complete ASTs are returned.

When the given position is a valid position within the source code of the compilation unit, the resulting AST does not have nodes for the entire compilation unit. Rather, the AST is only fleshed out for the node that include the given source position. This kind of limited AST is sufficient for certain purposes but totally unsuitable for others. In places where it can be used, the limited AST offers the advantage of being smaller and faster to construct.

The AST will include nodes for all of the compilation unit's package, import, and top-level type declarations. It will also always contain nodes for all the body declarations for those top-level types, as well as body declarations for any member types. However, some of the body declarations may be abridged. In particular, the statements ordinarily found in the body of a method declaration node will not be included (the block will be empty) unless the source position falls somewhere within the source range of that method declaration node. The same is true for initializer declarations; the statements ordinarily found in the body of initializer node will not be included unless the source position falls somewhere within the source range of that initializer declaration node. Field declarations are never abridged. Note that the AST for the body of that one unabridged method (or initializer) is 100% complete; it has all its statements, including any local or anonymous type declarations embedded within them. When the given position is not located within the source range of any body declaration of a top-level type, the AST returned will be a skeleton that includes nodes for all and only the major declarations; this kind of AST is still quite useful because it contains all the constructs that introduce names visible to the world outside the compilation unit.

This focal position is not used when the AST is built using createASTs(ICompilationUnit[], String[], ASTRequestor, IProgressMonitor).

Parameters:
position a position into the corresponding body declaration
 
 	public void setFocalPosition(int position) {
 		this. = position;
 	}

Sets the kind of constructs to be parsed from the source. Defaults to an entire compilation unit.

When the parse is successful the result returned includes the ASTs for the requested source:

  • K_COMPILATION_UNIT: The result node is a CompilationUnit.
  • K_CLASS_BODY_DECLARATIONS: The result node is a TypeDeclaration whose bodyDeclarations are the new trees. Other aspects of the type declaration are unspecified.
  • K_STATEMENTS: The result node is a Block whose statements are the new trees. Other aspects of the block are unspecified.
  • K_EXPRESSION: The result node is a subclass of Expression. Other aspects of the expression are unspecified.
The resulting AST node is rooted under (possibly contrived) CompilationUnit node, to allow the client to retrieve the following pieces of information available there:
  • Line number map. Line numbers start at 1 and only cover the subrange scanned (source[offset] through source[offset+length-1]).
  • Compiler messages and detailed problem reports. Character positions are relative to the start of source; line positions are for the subrange scanned.
  • Comment list for the subrange scanned.
The contrived nodes do not have source positions. Other aspects of the CompilationUnit node are unspecified, including the exact arrangement of intervening nodes.

Lexical or syntax errors detected while parsing can result in a result node being marked as MALFORMED. In more severe failure cases where the parser is unable to recognize the input, this method returns a CompilationUnit node with at least the compiler messages.

Each node in the subtree (other than the contrived nodes) carries source range(s) information relating back to positions in the given source (the given source itself is not remembered with the AST). The source range usually begins at the first character of the first token corresponding to the node; leading whitespace and comments are not included. The source range usually extends through the last character of the last token corresponding to the node; trailing whitespace and comments are not included. There are a handful of exceptions (including the various body declarations); the specification for these node type spells out the details. Source ranges nest properly: the source range for a child is always within the source range of its parent, and the source ranges of sibling nodes never overlap.

Binding information is only computed when kind is K_COMPILATION_UNIT.

This kind is not used when the AST is built using createASTs(ICompilationUnit[], String[], ASTRequestor, IProgressMonitor).

Parameters:
kind the kind of construct to parse: one of K_COMPILATION_UNIT, K_CLASS_BODY_DECLARATIONS, K_EXPRESSION, K_STATEMENTS
 
 	public void setKind(int kind) {
 	    if ((kind != )
 		    && (kind != )
 		    && (kind != )
 		    && (kind != )) {
 	    	throw new IllegalArgumentException();
 	    }
 		this. = kind;
 	}

Sets the source code to be parsed.

This source is not used when the AST is built using createASTs(ICompilationUnit[], String[], ASTRequestor, IProgressMonitor).

If this method is used, the user needs to specify compiler options explicitly using setCompilerOptions(Map) as 1.5 code will not be properly parsed without setting the appropriate values for the compiler options: JavaCore.COMPILER_SOURCE, JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, and JavaCore.COMPILER_COMPLIANCE.

Otherwise the default values for the compiler options will be used to parse the given source.

Parameters:
source the source string to be parsed, or null if none
See also:
JavaCore.setComplianceOptions(String, Map)
 
 	public void setSource(char[] source) {
 		this. = source;
 		// clear the type root
 		this. = null;
 	}

Sets the source code to be parsed.

This method automatically sets the project (and compiler options) based on the given compilation unit, in a manner equivalent to setProject(source.getJavaProject()).

This source is not used when the AST is built using createASTs(ICompilationUnit[], String[], ASTRequestor, IProgressMonitor).

Parameters:
source the Java model compilation unit whose source code is to be parsed, or null if none
 
 	public void setSource(ICompilationUnit source) {
 		setSource((ITypeRoot)source);
 	}

Sets the source code to be parsed.

This method automatically sets the project (and compiler options) based on the given compilation unit, in a manner equivalent to setProject(source.getJavaProject()).

If the given class file has no source attachment, the creation of the ast will fail with an IllegalStateException.

This source is not used when the AST is built using createASTs(ICompilationUnit[], String[], ASTRequestor, IProgressMonitor).

Parameters:
source the Java model class file whose corresponding source code is to be parsed, or null if none
 
 	public void setSource(IClassFile source) {
 		setSource((ITypeRoot)source);
 	}

Sets the source code to be parsed.

This method automatically sets the project (and compiler options) based on the given compilation unit of class file, in a manner equivalent to setProject(source.getJavaProject()).

If the source is a class file without source attachment, the creation of the ast will fail with an IllegalStateException.

This source is not used when the AST is built using createASTs(ICompilationUnit[], String[], ASTRequestor, IProgressMonitor).

Parameters:
source the Java model compilation unit or class file whose corresponding source code is to be parsed, or null if none
Since:
3.3
 
 	public void setSource(ITypeRoot source) {
 		this. = source;
 		// clear the raw source
 		this. = null;
 		if (source != null) {
 			this. = source.getJavaProject();
 			Map options = this..getOptions(true);
 			options.remove(.); // no need to parse task tags
 			this. = options;
 		}
 	}

Sets the subrange of the source code to be parsed. By default, the entire source string will be parsed (offset 0 and length -1).

This range is not used when the AST is built using createASTs(ICompilationUnit[], String[], ASTRequestor, IProgressMonitor).

Parameters:
offset the index of the first character to parse
length the number of characters to parse, or -1 if the remainder of the source string is to be parsed
 
 	public void setSourceRange(int offsetint length) {
 		if (offset < 0 || length < -1) {
 			throw new IllegalArgumentException();
 		}
 		this. = offset;
 		this. = length;
 	}

Requests that the compiler should perform statements recovery. When statements recovery is enabled the compiler tries to create statement nodes from code containing syntax errors

Default to false.

Parameters:
enabled true if statements containing syntax errors are wanted, and false if these statements aren't wanted.
Since:
3.2
 
 	public void setStatementsRecovery(boolean enabled) {
 		if (enabled) {
 		} else {
 		}
 	}

Requests an abstract syntax tree without method bodies.

When ignore method bodies is enabled, all method bodies are discarded. This has no impact on the binding resolution.

This setting is not used when the kind used in setKind(int) is either K_EXPRESSION or K_STATEMENTS.

Since:
3.5.2
 
 	public void setIgnoreMethodBodies(boolean enabled) {
 		if (enabled) {
 		} else {
 		}
 	}

    
Sets the working copy owner using when resolving bindings, where null means the primary owner. Defaults to the primary owner.

Parameters:
owner the owner of working copies that take precedence over underlying compilation units, or null if the primary owner should be used
 
 	public void setWorkingCopyOwner(WorkingCopyOwner owner) {
 	    if (owner == null) {
 		} else {
 			this. = owner;
 	 	}
 	}

Sets the name of the compilation unit that would hypothetically contains the source string.

This is used in conjunction with setSource(char[]) and setProject(IJavaProject) to locate the compilation unit relative to a Java project. Defaults to none (null).

The name of the compilation unit must be supplied for resolving bindings. This name should be suffixed by a dot ('.') followed by one of the Java-like extensions and match the name of the main (public) class or interface declared in the source.

This name must represent the full path of the unit inside the given project. For example, if the source declares a public class named "Foo" in a project "P" where the source folder is the project itself, the name of the compilation unit must be "/P/Foo.java". If the source declares a public class name "Bar" in a package "p1.p2" in a project "P" in a source folder "src", the name of the compilation unit must be "/P/src/p1/p2/Bar.java".

This unit name is not used when the AST is built using createASTs(ICompilationUnit[], String[], ASTRequestor, IProgressMonitor).

Parameters:
unitName the name of the compilation unit that would contain the source string, or null if none
 
 	public void setUnitName(String unitName) {
 		this. = unitName;
 	}

Sets the Java project used when resolving bindings.

This method automatically sets the compiler options based on the given project:

 setCompilerOptions(project.getOptions(true));
 

See setCompilerOptions(Map) for a discussion of the pros and cons of using these options vs specifying compiler options explicitly.

This setting is used in conjunction with setSource(char[]). For the purposes of resolving bindings, types declared in the source string will hide types by the same name available through the classpath of the given project.

Defaults to none (null).

Parameters:
project the Java project used to resolve names, or null if none
 
 	public void setProject(IJavaProject project) {
 		this. = project;
 		if (project != null) {
 			Map options = project.getOptions(true);
 			options.remove(.); // no need to parse task tags
 			this. = options;
 		}
 	}

Creates an abstract syntax tree.

A successful call to this method returns all settings to their default values so the object is ready to be reused.

Parameters:
monitor the progress monitor used to report progress and request cancellation, or null if none
Returns:
an AST node whose type depends on the kind of parse requested, with a fallback to a CompilationUnit in the case of severe parsing errors
Throws:
IllegalStateException if the settings provided are insufficient, contradictory, or otherwise unsupported
 
 	public ASTNode createAST(IProgressMonitor monitor) {
 		ASTNode result = null;
 		if (monitor != nullmonitor.beginTask("", 1); //$NON-NLS-1$
 		try {
 			if (this. == null && this. == null) {
 				throw new IllegalStateException("source not specified"); //$NON-NLS-1$
 			}
 			result = internalCreateAST(monitor);
 		} finally {
 			// reset to defaults to allow reuse (and avoid leaking)
 			if (monitor != nullmonitor.done();
 		}
 		return result;
 	}

Creates ASTs for a batch of compilation units.

When bindings are being resolved, processing a batch of compilation units is more efficient because much of the work involved in resolving bindings can be shared.

When bindings are being resolved, all compilation units must come from the same Java project, which must be set beforehand with setProject.

The compilation units are processed one at a time in no specified order. For each of the compilation units in turn,

  • ASTParser.createAST is called to parse it and create a corresponding AST. The calls to ASTParser.createAST all employ the same settings.
  • ASTRequestor.acceptAST is called passing the compilation unit and the corresponding AST to requestor.
Note only ASTs from the given compilation units are reported to the requestor. If additional compilation units are required to resolve the original ones, the corresponding ASTs are not reported to the requestor.

Note also the following parser parameters are used, regardless of what may have been specified:

  • The parser kind is K_COMPILATION_UNIT
  • The source range is (0, -1)
  • The focal position is not set

The bindingKeys parameter specifies bindings keys (IBinding.getKey()) that are to be looked up. These keys may be for elements either inside or outside the set of compilation units being processed. When bindings are being resolved, the keys and corresponding bindings (or null if none) are passed to ASTRequestor.acceptBinding. Note that binding keys for elements outside the set of compilation units being processed are looked up after all ASTRequestor.acceptAST callbacks have been made. Binding keys for elements inside the set of compilation units being processed are looked up and reported right after the corresponding ASTRequestor.acceptAST callback has been made. No ASTRequestor.acceptBinding callbacks are made unless bindings are being resolved.

A successful call to this method returns all settings to their default values so the object is ready to be reused.

Parameters:
compilationUnits the compilation units to create ASTs for
bindingKeys the binding keys to create bindings for
requestor the AST requestor that collects abstract syntax trees and bindings
monitor the progress monitor used to report progress and request cancellation, or null if none
Throws:
IllegalStateException if the settings provided are insufficient, contradictory, or otherwise unsupported
Since:
3.1
 
 	public void createASTs(ICompilationUnit[] compilationUnitsString[] bindingKeysASTRequestor requestor, IProgressMonitor monitor) {
 		try {
 			int flags = 0;
 			if ((this. & .) != 0) {
 			}
 			}
 			if ((this. & .) != 0) {
 				if (this. == null)
 					throw new IllegalStateException("project not specified"); //$NON-NLS-1$
 				if ((this. & .) != 0) {
 				}
 				CompilationUnitResolver.resolve(compilationUnitsbindingKeysrequestorthis.this.this.this.flagsmonitor);
 			} else {
 				CompilationUnitResolver.parse(compilationUnitsrequestorthis.this.flagsmonitor);
 			}
 		} finally {
 			// reset to defaults to allow reuse (and avoid leaking)
 		}
 	}

Creates ASTs for a batch of compilation units. When bindings are being resolved, processing a batch of compilation units is more efficient because much of the work involved in resolving bindings can be shared.

When bindings are being resolved, all compilation units are resolved using the same environment, which must be set beforehand with setEnvironment. The compilation units are processed one at a time in no specified order. For each of the compilation units in turn,

  • ASTParser.createAST is called to parse it and create a corresponding AST. The calls to ASTParser.createAST all employ the same settings.
  • FileASTRequestor.acceptAST is called passing the compilation unit path and the corresponding AST to requestor. The compilation unit path is the same path that is passed into the given sourceFilePaths parameter.
Note only ASTs from the given compilation units are reported to the requestor. If additional compilation units are required to resolve the original ones, the corresponding ASTs are not reported to the requestor.

Note also the following parser parameters are used, regardless of what may have been specified:

  • The parser kind is K_COMPILATION_UNIT
  • The source range is (0, -1)
  • The focal position is not set

The bindingKeys parameter specifies bindings keys (IBinding.getKey()) that are to be looked up. These keys may be for elements either inside or outside the set of compilation units being processed. When bindings are being resolved, the keys and corresponding bindings (or null if none) are passed to FileASTRequestor.acceptBinding. Note that binding keys for elements outside the set of compilation units being processed are looked up after all ASTRequestor.acceptAST callbacks have been made. Binding keys for elements inside the set of compilation units being processed are looked up and reported right after the corresponding FileASTRequestor.acceptAST callback has been made. No FileASTRequestor.acceptBinding callbacks are made unless bindings are being resolved.

A successful call to this method returns all settings to their default values so the object is ready to be reused.

The given encodings are used to properly parse the given source units. If the platform encoding is sufficient, then the given encodings can be set to null.

Parameters:
sourceFilePaths the compilation units to create ASTs for
encodings the given encoding for the source units
bindingKeys the binding keys to create bindings for
requestor the AST requestor that collects abstract syntax trees and bindings
monitor the progress monitor used to report progress and request cancellation, or null if none
Throws:
IllegalStateException if the settings provided are insufficient, contradictory, or otherwise unsupported
Since:
3.6
 
 	public void createASTs(String[] sourceFilePathsString[] encodingsString[] bindingKeys,
 			FileASTRequestor requestor, IProgressMonitor monitor) {
 		try {
 			int flags = 0;
 			if ((this. & .) != 0) {
 			}
 			}
 			if ((this. & .) != 0) {
 				if (this. == null && this. == null && ((this. & .) == 0)) {
 					throw new IllegalStateException("no environment is specified"); //$NON-NLS-1$
 				}
 				if ((this. & .) != 0) {
 				}
 				CompilationUnitResolver.resolve(sourceFilePathsencodingsbindingKeysrequestorthis.this.getClasspath(), flagsmonitor);
 			} else {
 				CompilationUnitResolver.parse(sourceFilePathsencodingsrequestorthis.this.flagsmonitor);
 			}
 		} finally {
 			// reset to defaults to allow reuse (and avoid leaking)
 		}
 	}
Creates bindings for a batch of Java elements.

These elements are either enclosed in ICompilationUnits or in IClassFiles.

All enclosing compilation units and class files must come from the same Java project, which must be set beforehand with setProject.

All elements must exist. If one doesn't exist, an IllegalStateException is thrown.

The returned array has the same size as the given elements array. At a given position it contains the binding of the corresponding Java element, or null if no binding could be created.

Note also the following parser parameters are used, regardless of what may have been specified:

  • The binding resolution flag is true
  • The parser kind is K_COMPILATION_UNIT
  • The source range is (0, -1)
  • The focal position is not set

A successful call to this method returns all settings to their default values so the object is ready to be reused.

Parameters:
elements the Java elements to create bindings for
Returns:
the bindings for the given Java elements, possibly containing nulls if some bindings could not be created
Throws:
IllegalStateException if the settings provided are insufficient, contradictory, or otherwise unsupported
Since:
3.1
	public IBinding[] createBindings(IJavaElement[] elements, IProgressMonitor monitor) {
		try {
			if (this. == null)
				throw new IllegalStateException("project or classpath not specified"); //$NON-NLS-1$
			int flags = 0;
			return CompilationUnitResolver.resolve(elementsthis.this.this.this.flagsmonitor);
finally {
			// reset to defaults to allow reuse (and avoid leaking)
	private ASTNode internalCreateAST(IProgressMonitor monitor) {
		boolean needToResolveBindings = (this. & .) != 0;
		switch(this.) {
				if (this. == null) {
					if (this. != null) {
						// get the source from the type root
						if (this. instanceof ICompilationUnit) {
							this. = sourceUnit.getContents();
else if (this. instanceof IClassFile) {
							try {
								String sourceString = this..getSource();
								if (sourceString != null) {
									this. = sourceString.toCharArray();
catch(JavaModelException e) {
								// an error occured accessing the java element
								StringWriter stringWriter = new StringWriter();
								PrintWriter writer = null;
								try {
									writer = new PrintWriter(stringWriter);
finally {
									if (writer != nullwriter.close();
								throw new IllegalStateException(String.valueOf(stringWriter.getBuffer()));
				if (this. != null) {
					if (this. + this. > this..length) {
				break;
				CompilationUnitDeclaration compilationUnitDeclaration = null;
				try {
					NodeSearcher searcher = null;
					if (this. instanceof ICompilationUnit) {
							/*
							 * this.compilationUnitSource is an instance of org.eclipse.jdt.internal.core.CompilationUnit that implements
							 * both org.eclipse.jdt.core.ICompilationUnit and org.eclipse.jdt.internal.compiler.env.ICompilationUnit
							 */
							/*
							 * use a BasicCompilation that caches the source instead of using the compilationUnitSource directly
							 * (if it is a working copy, the source can change between the parse and the AST convertion)
							 * (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=75632)
							 */
							sourceUnit = new BasicCompilationUnit(sourceUnit.getContents(), sourceUnit.getPackageName(), new String(sourceUnit.getFileName()), this.);
							wcOwner = ((ICompilationUnitthis.).getOwner();
else if (this. instanceof IClassFile) {
						try {
							String sourceString = this..getSource();
							if (sourceString == null) {
							PackageFragment packageFragment = (PackageFragmentthis..getParent();
							IBinaryType binaryType = (IBinaryTypetype.getElementInfo();
							// file name is used to recreate the Java element, so it has to be the toplevel .class file name
							char[] fileName = binaryType.getFileName();
							int firstDollar = CharOperation.indexOf('$'fileName);
							if (firstDollar != -1) {
								char[] suffix = .;
								int suffixLength = suffix.length;
								char[] newFileName = new char[firstDollar + suffixLength];
								System.arraycopy(fileName, 0, newFileName, 0, firstDollar);
								System.arraycopy(suffix, 0, newFileNamefirstDollarsuffixLength);
								fileName = newFileName;
							sourceUnit = new BasicCompilationUnit(sourceString.toCharArray(), Util.toCharArrays(packageFragment.names), new String(fileName), this.);
catch(JavaModelException e) {
							// an error occured accessing the java element
							StringWriter stringWriter = new StringWriter();
							PrintWriter writer = null;
							try {
								writer = new PrintWriter(stringWriter);
finally {
								if (writer != nullwriter.close();
							throw new IllegalStateException(String.valueOf(stringWriter.getBuffer()));
else if (this. != null) {
						needToResolveBindings = 
							&& this. != null
							&& (this. != null
									|| this. != null
									|| this. != null
							&& this. != null;
						sourceUnit = new BasicCompilationUnit(this.nullthis. == null ? "" : this.this.); //$NON-NLS-1$
else {
					if ((this. & .) != 0) {
						searcher = new NodeSearcher(this.);
					int flags = 0;
					if (searcher == null && ((this. & .) != 0)) {
					if (needToResolveBindings) {
						try {
							// parse and resolve
							compilationUnitDeclaration =
								CompilationUnitResolver.resolve(
									sourceUnit,
									searcher,
									flags,
									monitor);
catch (JavaModelException e) {
							compilationUnitDeclaration = CompilationUnitResolver.parse(
									sourceUnit,
									searcher,
									flags);
							needToResolveBindings = false;
else {
						compilationUnitDeclaration = CompilationUnitResolver.parse(
								sourceUnit,
								searcher,
								flags);
						needToResolveBindings = false;
					CompilationUnit result = CompilationUnitResolver.convert(
						compilationUnitDeclaration,
						sourceUnit.getContents(),
						needToResolveBindings,
						wcOwner,
						needToResolveBindings ? new DefaultBindingResolver.BindingTables() : null,
						flags,
						monitor,
						this. != null);
					result.setTypeRoot(this.);
					return result;
finally {
					if (compilationUnitDeclaration != null
							&& ((this. & .) != 0)) {
						compilationUnitDeclaration.cleanUp();
	}

Parses the given source between the bounds specified by the given offset (inclusive) and the given length and creates and returns a corresponding abstract syntax tree.

When the parse is successful the result returned includes the ASTs for the requested source:

  • K_CLASS_BODY_DECLARATIONS: The result node is a TypeDeclaration whose bodyDeclarations are the new trees. Other aspects of the type declaration are unspecified.
  • K_STATEMENTS: The result node is a Block whose statements are the new trees. Other aspects of the block are unspecified.
  • K_EXPRESSION: The result node is a subclass of Expression. Other aspects of the expression are unspecified.
The resulting AST node is rooted under an contrived CompilationUnit node, to allow the client to retrieve the following pieces of information available there:
  • Line number map. Line numbers start at 1 and only cover the subrange scanned (source[offset] through source[offset+length-1]).
  • Compiler messages and detailed problem reports. Character positions are relative to the start of source; line positions are for the subrange scanned.
  • Comment list for the subrange scanned.
The contrived nodes do not have source positions. Other aspects of the CompilationUnit node are unspecified, including the exact arrangment of intervening nodes.

Lexical or syntax errors detected while parsing can result in a result node being marked as MALFORMED. In more severe failure cases where the parser is unable to recognize the input, this method returns a CompilationUnit node with at least the compiler messages.

Each node in the subtree (other than the contrived nodes) carries source range(s) information relating back to positions in the given source (the given source itself is not remembered with the AST). The source range usually begins at the first character of the first token corresponding to the node; leading whitespace and comments are not included. The source range usually extends through the last character of the last token corresponding to the node; trailing whitespace and comments are not included. There are a handful of exceptions (including the various body declarations); the specification for these node type spells out the details. Source ranges nest properly: the source range for a child is always within the source range of its parent, and the source ranges of sibling nodes never overlap.

This method does not compute binding information; all resolveBinding methods applied to nodes of the resulting AST return null.

Returns:
an AST node whose type depends on the kind of parse requested, with a fallback to a CompilationUnit in the case of severe parsing errors
See also:
ASTNode.getStartPosition()
ASTNode.getLength()
		final ASTConverter converter = new ASTConverter(this.falsenull);
		converter.compilationUnitSource = this.;
		converter.compilationUnitSourceLength = this..length;
		converter.scanner.setSource(this.);
		AST ast = AST.newAST(this.);
		converter.setAST(ast);
		CompilationUnit compilationUnit = ast.newCompilationUnit();
		if (this. == -1) {
			this. = this..length;
		switch(this.) {
				ConstructorDeclaration constructorDeclaration = codeSnippetParsingUtil.parseStatements(
						true,
				RecoveryScannerData data = constructorDeclaration.compilationResult.recoveryScannerData;
				if(data != null) {
					Scanner scanner = converter.scanner;
					converter.scanner = new RecoveryScanner(scannerdata.removeUnused());
					converter.docParser.scanner = converter.scanner;
					converter.scanner.setSource(scanner.source);
					compilationUnit.setStatementsRecoveryData(data);
				RecordedParsingInformation recordedParsingInformation = codeSnippetParsingUtil.recordedParsingInformation;
				int[][] comments = recordedParsingInformation.commentPositions;
				if (comments != null) {
					converter.buildCommentsTable(compilationUnitcomments);
				compilationUnit.setLineEndTable(recordedParsingInformation.lineEnds);
				Block block = ast.newBlock();
				org.eclipse.jdt.internal.compiler.ast.Statement[] statements = constructorDeclaration.statements;
				if (statements != null) {
					int statementsLength = statements.length;
					for (int i = 0; i < statementsLengthi++) {
						if (statements[iinstanceof org.eclipse.jdt.internal.compiler.ast.LocalDeclaration) {
							converter.checkAndAddMultipleLocalDeclaration(statementsiblock.statements());
else {
							Statement statement = converter.convert(statements[i]);
							if (statement != null) {
								block.statements().add(statement);
				rootNodeToCompilationUnit(astcompilationUnitblockrecordedParsingInformationdata);
				return block;
				org.eclipse.jdt.internal.compiler.ast.Expression expression = codeSnippetParsingUtil.parseExpression(this.this.this.this.true);
				recordedParsingInformation = codeSnippetParsingUtil.recordedParsingInformation;
				comments = recordedParsingInformation.commentPositions;
				if (comments != null) {
					converter.buildCommentsTable(compilationUnitcomments);
				compilationUnit.setLineEndTable(recordedParsingInformation.lineEnds);
				if (expression != null) {
					Expression expression2 = converter.convert(expression);
					rootNodeToCompilationUnit(expression2.getAST(), compilationUnitexpression2codeSnippetParsingUtil.recordedParsingInformationnull);
					return expression2;
else {
					CategorizedProblem[] problems = recordedParsingInformation.problems;
					if (problems != null) {
						compilationUnit.setProblems(problems);
					return compilationUnit;
					codeSnippetParsingUtil.parseClassBodyDeclarations(
							true,
				recordedParsingInformation = codeSnippetParsingUtil.recordedParsingInformation;
				comments = recordedParsingInformation.commentPositions;
				if (comments != null) {
					converter.buildCommentsTable(compilationUnitcomments);
				compilationUnit.setLineEndTable(recordedParsingInformation.lineEnds);
				if (nodes != null) {
					// source has no syntax error or the statement recovery is enabled
					TypeDeclaration typeDeclaration = converter.convert(nodes);
					typeDeclaration.setSourceRange(this.this. + this.);
					rootNodeToCompilationUnit(typeDeclaration.getAST(), compilationUnittypeDeclarationcodeSnippetParsingUtil.recordedParsingInformationnull);
					return typeDeclaration;
else {
					// source has syntax error and the statement recovery is disabled
					CategorizedProblem[] problems = recordedParsingInformation.problems;
					if (problems != null) {
						compilationUnit.setProblems(problems);
					return compilationUnit;
	private void propagateErrors(ASTNode astNodeCategorizedProblem[] problemsRecoveryScannerData data) {
		astNode.accept(new ASTSyntaxErrorPropagator(problems));
		if (data != null) {
			astNode.accept(new ASTRecoveryPropagator(problemsdata));
	private void rootNodeToCompilationUnit(AST astCompilationUnit compilationUnitASTNode nodeRecordedParsingInformation recordedParsingInformationRecoveryScannerData data) {
		final int problemsCount = recordedParsingInformation.problemsCount;
		switch(node.getNodeType()) {
			case . :
					Block block = (Blocknode;
					if (problemsCount != 0) {
						// propagate and record problems
						final CategorizedProblem[] problems = recordedParsingInformation.problems;
						propagateErrors(blockproblemsdata);
						compilationUnit.setProblems(problems);
					TypeDeclaration typeDeclaration = ast.newTypeDeclaration();
					Initializer initializer = ast.newInitializer();
					initializer.setBody(block);
					typeDeclaration.bodyDeclarations().add(initializer);
					compilationUnit.types().add(typeDeclaration);
				break;
					TypeDeclaration typeDeclaration = (TypeDeclarationnode;
					if (problemsCount != 0) {
						// propagate and record problems
						final CategorizedProblem[] problems = recordedParsingInformation.problems;
						propagateErrors(typeDeclarationproblemsdata);
						compilationUnit.setProblems(problems);
					compilationUnit.types().add(typeDeclaration);
				break;
			default :
				if (node instanceof Expression) {
					Expression expression = (Expressionnode;
					if (problemsCount != 0) {
						// propagate and record problems
						final CategorizedProblem[] problems = recordedParsingInformation.problems;
						propagateErrors(expressionproblemsdata);
						compilationUnit.setProblems(problems);
					ExpressionStatement expressionStatement = ast.newExpressionStatement(expression);
					Block block = ast.newBlock();
					block.statements().add(expressionStatement);
					Initializer initializer = ast.newInitializer();
					initializer.setBody(block);
					TypeDeclaration typeDeclaration = ast.newTypeDeclaration();
					typeDeclaration.bodyDeclarations().add(initializer);
					compilationUnit.types().add(typeDeclaration);
New to GrepCode? Check out our FAQ X