public AspectJTypeFilter(String typePatternExpression, @Nullable ClassLoader classLoader) { this.world = new BcelWorld(classLoader, IMessageHandler.THROW, null); this.world.setBehaveInJava5Way(true); PatternParser patternParser = new PatternParser(typePatternExpression); TypePattern typePattern = patternParser.parseTypePattern(); typePattern.resolve(this.world); IScope scope = new SimpleScope(this.world, new FormalBinding[0]); this.typePattern = typePattern.resolveBindings(scope, Bindings.NONE, false, false); }
String kind = parseIdentifier(); p = parseKindedPointcut(kind); } else if (kind.equals("args")) { p = parseArgsPointcut(); } else if (kind.equals("this")) { p = parseThisOrTargetPointcut(kind); } else if (kind.equals("target")) { p = parseThisOrTargetPointcut(kind); } else if (kind.equals("within")) { p = parseWithinPointcut(); } else if (kind.equals("withincode")) { p = parseWithinCodePointcut(); } else if (kind.equals("cflow")) { p = parseCflowPointcut(false); } else if (kind.equals("cflowbelow")) { p = parseCflowPointcut(true); } else if (kind.equals("adviceexecution")) { eat("("); eat(")"); p = new KindedPointcut(Shadow.AdviceExecution, new SignaturePattern(Member.ADVICE, ModifiersPattern.ANY, TypePattern.ANY, TypePattern.ANY, NamePattern.ANY, TypePatternList.ANY, ThrowsPattern.ANY, AnnotationTypePattern.ANY)); } else if (kind.equals("handler")) { eat("("); TypePattern typePat = parseTypePattern(false, false); eat(")"); p = new HandlerPointcut(typePat); } else if (kind.equals("lock") || kind.equals("unlock")) {
public SignaturePattern parseMethodOrConstructorSignaturePattern() { int startPos = tokenSource.peek().getStart(); AnnotationTypePattern annotationPattern = maybeParseAnnotationPattern(); ModifiersPattern modifiers = parseModifiersPattern(); TypePattern returnType = parseTypePattern(false, false); MemberKind kind; if (maybeEatNew(returnType)) { kind = Member.CONSTRUCTOR; if (returnType.toString().length() == 0) { kind = Member.METHOD; IToken nameToken = tokenSource.peek(); declaringType = parseTypePattern(false, false); if (maybeEat(".")) { nameToken = tokenSource.peek(); name = parseNamePattern(); } else { name = tryToExtractName(declaringType); if (declaringType.toString().equals("")) { declaringType = TypePattern.ANY; TypePatternList parameterTypes = parseArgumentsPattern(true); ThrowsPattern throwsPattern = parseOptionalThrowsPattern(); SignaturePattern ret = new SignaturePattern(kind, modifiers, returnType, declaringType, name, parameterTypes, throwsPattern, annotationPattern);
PatternParser pp = new PatternParser(tokenSource); ISignaturePattern isp = (da.declareAnnotationKind==DeclareAnnotationKind.Method?pp.parseCompoundMethodOrConstructorSignaturePattern(true):pp.parseCompoundFieldSignaturePattern()); deca = new DeclareAnnotation(da.declareAnnotationKind==DeclareAnnotationKind.Method?DeclareAnnotation.AT_METHOD:DeclareAnnotation.AT_FIELD, isp); } else if (da.declareAnnotationKind==DeclareAnnotationKind.Type) { TypePattern tp = pp.parseTypePattern(); deca = new DeclareAnnotation(DeclareAnnotation.AT_TYPE,tp);
public TypePatternList maybeParseTypeParameterList() { if (!maybeEat("<")) { return null; } List<TypePattern> typePats = new ArrayList<TypePattern>(); do { TypePattern tp = parseTypePattern(true, false); typePats.add(tp); } while (maybeEat(",")); eat(">"); TypePattern[] tps = new TypePattern[typePats.size()]; typePats.toArray(tps); return new TypePatternList(tps); }
private TypePattern parseAtomicTypePattern(boolean insideTypeParameters, boolean parameterAnnotationsPossible) { AnnotationTypePattern ap = maybeParseAnnotationPattern(); // might be parameter annotation pattern or type annotation if (maybeEat("!")) { TypePattern tp = parseAtomicTypePattern(insideTypeParameters, parameterAnnotationsPossible); if (!(ap instanceof AnyAnnotationTypePattern)) { p = new NotTypePattern(tp); p = new AndTypePattern(setAnnotationPatternForTypePattern(TypePattern.ANY, ap, false), p); } else { p = new NotTypePattern(tp); if (maybeEat("(")) { int openParenPos = tokenSource.peek(-1).getStart(); TypePattern p = parseTypePattern(insideTypeParameters, false); if ((p instanceof NotTypePattern) && !(ap instanceof AnyAnnotationTypePattern)) { TypePattern tp = setAnnotationPatternForTypePattern(TypePattern.ANY, ap, parameterAnnotationsPossible); p = new AndTypePattern(tp, p); } else { p = setAnnotationPatternForTypePattern(p, ap, parameterAnnotationsPossible); eat(")"); int closeParenPos = tokenSource.peek(-1).getStart(); boolean isVarArgs = maybeEat("..."); if (isVarArgs) { p.setIsVarArgs(isVarArgs); boolean isIncludeSubtypes = maybeEat("+"); if (isIncludeSubtypes) {
public SignaturePattern parseFieldSignaturePattern() { int startPos = tokenSource.peek().getStart(); // TypePatternList followMe = TypePatternList.ANY; AnnotationTypePattern annotationPattern = maybeParseAnnotationPattern(); ModifiersPattern modifiers = parseModifiersPattern(); TypePattern returnType = parseTypePattern(); TypePattern declaringType = parseTypePattern(); NamePattern name; // System.err.println("parsed field: " + declaringType.toString()); if (maybeEat(".")) { name = parseNamePattern(); } else { name = tryToExtractName(declaringType); if (name == null) { throw new ParserException("name pattern", tokenSource.peek()); } if (declaringType.toString().equals("")) { declaringType = TypePattern.ANY; } } SignaturePattern ret = new SignaturePattern(Member.FIELD, modifiers, returnType, declaringType, name, TypePatternList.ANY, ThrowsPattern.ANY, annotationPattern); int endPos = tokenSource.peek(-1).getEnd(); ret.setLocation(sourceContext, startPos, endPos); return ret; }
if (maybeEat("!")) { if (maybeEat("@")) { if (maybeEat("(")) { TypePattern p = parseTypePattern(); ret = new NotAnnotationTypePattern(new WildAnnotationTypePattern(p)); eat(")"); return ret; } else { TypePattern p = parseSingleTypePattern(); if (maybeEatAdjacent("(")) { values = parseAnnotationValues(); eat(")"); ret = new NotAnnotationTypePattern(new WildAnnotationTypePattern(p, values)); } else { if (maybeEat("@")) { if (maybeEat("(")) { TypePattern p = parseTypePattern(); ret = new WildAnnotationTypePattern(p); eat(")"); return ret; } else { int atPos = tokenSource.peek(-1).getStart(); TypePattern p = parseSingleTypePattern(); if (maybeEatAdjacent("(")) { values = parseAnnotationValues(); eat(")"); ret = new WildAnnotationTypePattern(p, values); } else {
public TypeVariablePattern parseTypeVariable() { TypePattern upperBound = null; TypePattern[] additionalInterfaceBounds = null; TypePattern lowerBound = null; String typeVariableName = parseIdentifier(); if (maybeEatIdentifier("extends")) { upperBound = parseTypePattern(); additionalInterfaceBounds = maybeParseAdditionalInterfaceBounds(); } else if (maybeEatIdentifier("super")) { lowerBound = parseTypePattern(); } return new TypeVariablePattern(typeVariableName, upperBound, additionalInterfaceBounds, lowerBound); }
public DeclarePrecedence parseDominates() { List<TypePattern> l = new ArrayList<TypePattern>(); do { l.add(parseTypePattern()); } while (maybeEat(",")); return new DeclarePrecedence(l); }
public TypePattern parseTypePattern(boolean insideTypeParameters, boolean parameterAnnotationsPossible) { TypePattern p = parseAtomicTypePattern(insideTypeParameters, parameterAnnotationsPossible); if (maybeEat("&&")) { p = new AndTypePattern(p, parseNotOrTypePattern(insideTypeParameters, parameterAnnotationsPossible)); } if (maybeEat("||")) { p = new OrTypePattern(p, parseTypePattern(insideTypeParameters, parameterAnnotationsPossible)); } return p; }
private Pointcut parseReferencePointcut() { TypePattern onType = parseTypePattern(); NamePattern name = null; if (onType.typeParameters.size() > 0) { eat("."); name = parseNamePattern(); } else { name = tryToExtractName(onType); } if (name == null) { throw new ParserException("name pattern", tokenSource.peek()); } if (onType.toString().equals("")) { onType = null; } String simpleName = name.maybeGetSimpleName(); if (simpleName == null) { throw new ParserException("(", tokenSource.peek(-1)); } TypePatternList arguments = parseArgumentsPattern(false); return new ReferencePointcut(onType, simpleName, arguments); }
protected Pointcut resolvePointcutExpression(String expression, Class<?> inScope, PointcutParameter[] formalParameters) { try { PatternParser parser = new PatternParser(expression); parser.setPointcutDesignatorHandlers(pointcutDesignators, world); Pointcut pc = parser.parsePointcut(); validateAgainstSupportedPrimitives(pc, expression); IScope resolutionScope = buildResolutionScope((inScope == null ? Object.class : inScope), formalParameters); pc = pc.resolve(resolutionScope); return pc; } catch (ParserException pEx) { throw new IllegalArgumentException(buildUserMessageFromParserException(expression, pEx)); } }
private PerClause parsePerTypeWithin() { parseIdentifier(); eat("("); TypePattern withinTypePattern = parseTypePattern(); eat(")"); return new PerTypeWithin(withinTypePattern); }
int index = tokenSource.getIndex(); try { pointcut = parsePointcut(); } catch (ParserException pe) { try { try { allowHasTypePatterns = true; typePattern = parseTypePattern(); } finally { allowHasTypePatterns = oldValue; eat(":"); String message = parsePossibleStringSequence(true); return new DeclareTypeErrorOrWarning(isError, typePattern, message); } catch (ParserException pe2) { eat(":"); String message = parsePossibleStringSequence(true); return new DeclareErrorOrWarning(isError, pointcut, message);
private TypePattern parseNotOrTypePattern(boolean insideTypeParameters, boolean parameterAnnotationsPossible) { TypePattern p = parseAtomicTypePattern(insideTypeParameters, parameterAnnotationsPossible); if (maybeEat("&&")) { p = new AndTypePattern(p, parseTypePattern(insideTypeParameters, parameterAnnotationsPossible)); } return p; }
public TypePattern parseSingleTypePattern(boolean insideTypeParameters) { if (insideTypeParameters && maybeEat("?")) { return parseGenericsWildcardTypePattern(); if (maybeEatIdentifier("hasmethod")) { return parseHasMethodTypePattern(); if (maybeEatIdentifier("hasfield")) { return parseHasFieldTypePattern(); if (maybeEatIdentifier("is")) { int pos = tokenSource.getIndex() - 1; TypePattern typeIsPattern = parseIsTypePattern(); if (typeIsPattern != null) { return typeIsPattern; List<NamePattern> names = parseDottedNamePattern(); while (maybeEat("[")) { eat("]"); dim++; TypePatternList typeParameters = maybeParseTypeParameterList(); int endPos = tokenSource.peek(-1).getEnd(); boolean includeSubtypes = maybeEat("+"); while (maybeEat("[")) { eat("]"); dim++;
private Declare parseSoft() { TypePattern p = parseTypePattern(); eat(":"); Pointcut pointcut = parsePointcut(); return new DeclareSoft(p, pointcut); }
/** * Method parseWithinPointcut. * * @return Pointcut */ private Pointcut parseWithinPointcut() { // parseIdentifier(); eat("("); TypePattern type = parseTypePattern(); eat(")"); return new WithinPointcut(type); }
public static Pointcut fromString(String str) { PatternParser parser = new PatternParser(str); return parser.parsePointcut(); }