com.oracle.graal.compiler.match.processor

Class MatchProcessor

java.lang.Object

javax.annotation.processing.AbstractProcessor

com.oracle.graal.compiler.match.processor.MatchProcessor

All Implemented Interfaces:

Processor

@SupportedAnnotationTypes(value={"com.oracle.graal.compiler.match.MatchRule","com.oracle.graal.compiler.match.MatchRules","com.oracle.graal.compiler.match.MatchableNode","com.oracle.graal.compiler.match.MatchableNodes"})
public class MatchProcessor
extends AbstractProcessor

Processes classes annotated with MatchRule. A MatchStatementSet service is generated for each top level class containing at least one such field. These service objects can be retrieved as follows:

     Iterable sl = Services.load(MatchStatementSet.class);
     for (MatchStatementSet rules : sl) {
         ...
     }
 

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private static class	MatchProcessor.AnnotationValueVisitorImpl
(package private) class	MatchProcessor.MatchDescriptor
(package private) static class	MatchProcessor.MatchRuleDescriptor
(package private) static class	MatchProcessor.MatchRuleItem Used to generate the MatchStatement constructor invocation.
(package private) static class	MatchProcessor.MethodInvokerItem Used to generate the wrapper class to invoke the code generation method.
private static class	MatchProcessor.RuleParseError
private class	MatchProcessor.RuleParser
(package private) static class	MatchProcessor.TypeDescriptor

Field Summary

Fields

Modifier and Type	Field and Description
private static boolean	DEBUG Set to true to enable logging to a local file during annotation processing.
(package private) Map<String,MatchProcessor.TypeDescriptor>	knownTypes The types which are know for purpose of parsing MatchRule expressions.
private PrintWriter	log
private TypeMirror	matchableNodesTypeMirror
private TypeMirror	matchableNodeTypeMirror
private TypeMirror	matchRulesTypeMirror
private TypeMirror	matchRuleTypeMirror
private Set<Element>	processedMatchableNode
private Set<Element>	processedMatchRule
private static Pattern	tokenizer
private MatchProcessor.TypeDescriptor	valueType

Fields inherited from class javax.annotation.processing.AbstractProcessor

processingEnv

Constructor Summary

Constructors

Constructor and Description
MatchProcessor()

Method Summary

Modifier and Type	Method and Description
private void	createFiles(MatchProcessor.MatchRuleDescriptor info)
private void	createProviderFile(String pkg, String providerClassName, Element... originatingElements)
protected PrintWriter	createSourceFile(String pkg, String relativeName, Filer filer, Element... originatingElements)
private void	declareType(TypeMirror mirror, String shortName, String nodeClass, String nodePackage, String[] inputs, boolean commutative, boolean shareable, Element element)
private void	errorMessage(Element element, AnnotationMirror mirror, String format, Object... args)
private void	errorMessage(Element element, String format, Object... args)
private AnnotationMirror	findAnnotationMirror(Element element, TypeMirror typeMirror)
private void	findMatchableNodes(Element element) Search the super types of element for MatchableNode definitions.
private String	findPackage(Element type)
private String	fullClassName(Element element) Strip the package off a class name leaving the full class name including any outer classes.
private static AnnotationValue	getAnnotationValue(AnnotationMirror mirror, String name)
private static <T> T	getAnnotationValue(Class<T> expectedType, AnnotationMirror mirror, String name)
private static <T> List<T>	getAnnotationValueList(Class<T> expectedListType, AnnotationMirror mirror, String name)
private PrintWriter	getLog() Logging facility for debugging the annotation processor.
SourceVersion	getSupportedSourceVersion()
private void	logException(Throwable t)
private void	logMessage(String format, Object... args)
boolean	process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv)
private void	processMatchableNode(Element element) Build up the type table to be used during parsing of the MatchRule.
private void	processMatchableNode(Element element, TypeElement topDeclaringType, MatchableNode matchable, AnnotationMirror mirror)
private void	processMatchRule(Map<TypeElement,MatchProcessor.MatchRuleDescriptor> map, Element element, AnnotationMirror mirror)
private void	processMethodMatchRule(ExecutableElement method, MatchProcessor.MatchRuleDescriptor info, MatchRule matchRule, AnnotationMirror mirror)
private void	reportExceptionThrow(Element element, Throwable t) Bugs in an annotation processor can cause silent failure so try to report any exception throws as errors.
private static <T> T	resolveAnnotationValue(Class<T> expectedType, AnnotationValue value)
private static TypeElement	topDeclaringType(Element element)
private Types	typeUtils()

Methods inherited from class javax.annotation.processing.AbstractProcessor

getCompletions, getSupportedAnnotationTypes, getSupportedOptions, init, isInitialized

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

processedMatchRule

private final Set<Element> processedMatchRule

processedMatchableNode

private final Set<Element> processedMatchableNode

tokenizer

private static final Pattern tokenizer

DEBUG

private static final boolean DEBUG

Set to true to enable logging to a local file during annotation processing. There's no normal channel for any debug messages and debugging annotation processors requires some special setup.

See Also:

Constant Field Values

log

private PrintWriter log

knownTypes

Map<String,MatchProcessor.TypeDescriptor> knownTypes

The types which are know for purpose of parsing MatchRule expressions.

valueType

private MatchProcessor.TypeDescriptor valueType

matchRulesTypeMirror

private TypeMirror matchRulesTypeMirror

matchRuleTypeMirror

private TypeMirror matchRuleTypeMirror

matchableNodeTypeMirror

private TypeMirror matchableNodeTypeMirror

matchableNodesTypeMirror

private TypeMirror matchableNodesTypeMirror

Constructor Detail

MatchProcessor

public MatchProcessor()

Method Detail

getSupportedSourceVersion

public SourceVersion getSupportedSourceVersion()

Specified by:

getSupportedSourceVersion in interface Processor

Overrides:

getSupportedSourceVersion in class AbstractProcessor

getLog

private PrintWriter getLog()

Logging facility for debugging the annotation processor.

logMessage

private void logMessage(String format,
                        Object... args)

logException

private void logException(Throwable t)

reportExceptionThrow

private void reportExceptionThrow(Element element,
                                  Throwable t)

Bugs in an annotation processor can cause silent failure so try to report any exception throws as errors.

declareType

private void declareType(TypeMirror mirror,
                         String shortName,
                         String nodeClass,
                         String nodePackage,
                         String[] inputs,
                         boolean commutative,
                         boolean shareable,
                         Element element)

findPackage

private String findPackage(Element type)

fullClassName

private String fullClassName(Element element)

Strip the package off a class name leaving the full class name including any outer classes.

createFiles

private void createFiles(MatchProcessor.MatchRuleDescriptor info)

createProviderFile

private void createProviderFile(String pkg,
                                String providerClassName,
                                Element... originatingElements)
                         throws IOException

Throws:

IOException

createSourceFile

protected PrintWriter createSourceFile(String pkg,
                                       String relativeName,
                                       Filer filer,
                                       Element... originatingElements)

topDeclaringType

private static TypeElement topDeclaringType(Element element)

findAnnotationMirror

private AnnotationMirror findAnnotationMirror(Element element,
                                              TypeMirror typeMirror)

process

public boolean process(Set<? extends TypeElement> annotations,
                       RoundEnvironment roundEnv)

Specified by:

process in interface Processor

Specified by:

process in class AbstractProcessor

processMatchableNode

private void processMatchableNode(Element element)

Build up the type table to be used during parsing of the MatchRule.

processMatchableNode

private void processMatchableNode(Element element,
                                  TypeElement topDeclaringType,
                                  MatchableNode matchable,
                                  AnnotationMirror mirror)
                           throws JVMCIError

Throws:

JVMCIError

processMatchRule

private void processMatchRule(Map<TypeElement,MatchProcessor.MatchRuleDescriptor> map,
                              Element element,
                              AnnotationMirror mirror)

findMatchableNodes

private void findMatchableNodes(Element element)

Search the super types of element for MatchableNode definitions. Any superclass or super interface can contain definitions of matchable nodes.

Parameters:

element -

typeUtils

private Types typeUtils()

processMethodMatchRule

private void processMethodMatchRule(ExecutableElement method,
                                    MatchProcessor.MatchRuleDescriptor info,
                                    MatchRule matchRule,
                                    AnnotationMirror mirror)

errorMessage

private void errorMessage(Element element,
                          String format,
                          Object... args)

errorMessage

private void errorMessage(Element element,
                          AnnotationMirror mirror,
                          String format,
                          Object... args)

getAnnotationValueList

private static <T> List<T> getAnnotationValueList(Class<T> expectedListType,
                                                  AnnotationMirror mirror,
                                                  String name)

getAnnotationValue

private static <T> T getAnnotationValue(Class<T> expectedType,
                                        AnnotationMirror mirror,
                                        String name)

resolveAnnotationValue

private static <T> T resolveAnnotationValue(Class<T> expectedType,
                                            AnnotationValue value)

getAnnotationValue

private static AnnotationValue getAnnotationValue(AnnotationMirror mirror,
                                                  String name)