| /******************************************************************************* |
| * Copyright (c) 2004 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: |
| * Luzius Meisser - initial implementation |
| *******************************************************************************/ |
| package org.eclipse.ajdt.core.codeconversion; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Set; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| import org.aspectj.asm.IProgramElement; |
| import org.aspectj.asm.IRelationship; |
| import org.aspectj.org.eclipse.jdt.core.compiler.CharOperation; |
| import org.aspectj.org.eclipse.jdt.core.compiler.InvalidInputException; |
| import org.aspectj.org.eclipse.jdt.internal.compiler.parser.Scanner; |
| import org.aspectj.org.eclipse.jdt.internal.compiler.parser.TerminalTokens; |
| import org.eclipse.ajdt.core.AspectJPlugin; |
| import org.eclipse.ajdt.core.model.AJProjectModelFacade; |
| import org.eclipse.ajdt.core.model.AJProjectModelFactory; |
| import org.eclipse.ajdt.core.model.AJRelationshipManager; |
| import org.eclipse.ajdt.core.model.AJRelationshipType; |
| import org.eclipse.ajdt.internal.core.ras.NoFFDC; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.jdt.core.ICompilationUnit; |
| import org.eclipse.jdt.core.IJavaElement; |
| import org.eclipse.jdt.core.IType; |
| import org.eclipse.jdt.core.JavaModelException; |
| |
| /** |
| * The purpose of this parser is to convert AspectJ code into similar Java code |
| * which allows us to reuse for example for jdt formatting or comment |
| * generation. |
| * |
| * Depending on the ConversionOptions it gets called with, it does: - replace |
| * the keyword "aspect" by "class " - replace all the '.'s in intertype |
| * declarations by an '$'s to make them look like an ordinary declarations. - |
| * erase the keywords "returning", "throwing", "privileged", "issingleton" e.g.: |
| * "after() throwing (Exception e)" -> "after( Exception e)" - erase pointcut |
| * designators (includes "percflow" & co.) - add dummy references to all erased |
| * class references to end of buffer to make "organize imports" work correctly - |
| * add a reference to the target class inside intertype method declarations to |
| * simulate the context switch necessary to get proper code completion. |
| * (A detailed description of how code completion works in AJDT can be found in |
| * bug 74419.) |
| * |
| * Restrictions: - class names inside pointcut designators must begin with a |
| * capital letter to be recognised as such |
| * |
| * |
| * @author Luzius Meisser |
| */ |
| public class AspectsConvertingParser implements TerminalTokens, NoFFDC { |
| |
| private static final String IMPLEMENTS = "implements"; |
| |
| private static final String EXTENDS = "extends"; |
| |
| private static final char[] throwing = "throwing".toCharArray(); //$NON-NLS-1$ |
| |
| private static final char[] returning = "returning".toCharArray(); //$NON-NLS-1$ |
| |
| private static final char[] percflow = "percflow".toCharArray(); //$NON-NLS-1$ |
| |
| private static final char[] percflowbelow = "percflowbelow".toCharArray(); //$NON-NLS-1$ |
| |
| private static final char[] perthis = "perthis".toCharArray(); //$NON-NLS-1$ |
| |
| private static final char[] pertarget = "pertarget".toCharArray(); //$NON-NLS-1$ |
| |
| private static final char[] issingleton = "issingleton".toCharArray(); //$NON-NLS-1$ |
| |
| private static final char[] pertypewithin = "pertypewithin".toCharArray(); //$NON-NLS-1$ |
| |
| private static final char[] classs = "class ".toCharArray(); //$NON-NLS-1$ |
| |
| private static final char[] privileged = " ".toCharArray(); //$NON-NLS-1$ |
| |
| private static final String thizString = "thiz"; //$NON-NLS-1$ |
| |
| private final static char[] tjpRefs2 = "org.aspectj.lang.JoinPoint thisJoinPoint; org.aspectj.lang.JoinPoint.StaticPart thisJoinPointStaticPart; org.aspectj.lang.JoinPoint.StaticPart thisEnclosingJoinPointStaticPart;" //$NON-NLS-1$ |
| .toCharArray(); |
| |
| private final static char[] endThrow = new char[] { '(', ':' }; |
| |
| private final static Pattern perClausePattern = Pattern.compile("(percflow)|(percflowbelow)|(pertarget)|(pertypewithin)|(perthis)|(issingleton)"); |
| |
| public class Replacement { |
| //the position in the original char[] |
| public int posBefore; |
| |
| //the position in the new char[], or -1 if not yet applied |
| public int posAfter; |
| |
| //the number of chars that get replaced |
| public int length; |
| |
| //the content to be inserted |
| public char[] text; |
| |
| //the number of additional chars (lengthAdded == text.length - length) |
| public int lengthAdded; |
| |
| public Replacement(int pos, int length, char[] text) { |
| this.posBefore = pos; |
| this.posAfter = -1; |
| this.length = length; |
| this.text = text; |
| lengthAdded = text.length - length; |
| } |
| |
| } |
| |
| public AspectsConvertingParser(char[] content) { |
| this.content = content; |
| this.typeReferences = new HashSet(); |
| this.usedIdentifiers = new HashSet(); |
| replacements = new ArrayList(5); |
| } |
| |
| public char[] content; |
| |
| private Set typeReferences; |
| |
| private Set usedIdentifiers; |
| |
| private ConversionOptions options; |
| |
| /** |
| * can be null. used for determining ITDs |
| */ |
| private ICompilationUnit unit; |
| |
| //list of replacements |
| //by convetion: sorted by posBefore in ascending order |
| private ArrayList replacements; |
| |
| protected Scanner scanner; |
| |
| private boolean inPointcutDesignator; |
| |
| private boolean inAspect; |
| |
| private boolean inAspectDeclaration; |
| |
| private boolean inClassDeclaration; |
| |
| private boolean inInterfaceDeclaration; |
| |
| private int posColon; |
| |
| public void setUnit(ICompilationUnit unit) { |
| this.unit = unit; |
| } |
| |
| |
| //returns a list of Insertions to let the client now what has been inserted |
| //into the buffer so he can translate positions from the old into the new |
| //buffer |
| public ArrayList convert(ConversionOptions options) { |
| this.options = options; |
| boolean insertIntertypeDeclarations = options |
| .isThisJoinPointReferencesEnabled(); |
| boolean addReferencesForOrganizeImports = options |
| .isDummyTypeReferencesForOrganizeImportsEnabled(); |
| boolean isSimulateContextSwitchNecessary = (options.getTargetType() != null); |
| |
| scanner = new Scanner(); |
| scanner.setSource(content); |
| |
| inPointcutDesignator = false; |
| inAspect = false; |
| inAspectDeclaration = false; |
| inClassDeclaration = false; |
| inInterfaceDeclaration = false; |
| |
| // Bug 93248: Count question marks so as to ignore colons that are part of conditional statements |
| int questionMarkCount = 0; |
| |
| // count paren levels so that we know if we are in a intertype declaration name or not |
| int parenLevel = 0; |
| |
| // Bug 110751: Ignore colons that are part of enhanced "for" loop in Java 5 |
| boolean insideFor = false; |
| |
| char[] currentTypeName = null; |
| |
| replacements.clear(); |
| typeReferences.clear(); |
| usedIdentifiers.clear(); |
| |
| int tok; |
| int pos; |
| int typeDeclStart = 0; |
| while (true) { |
| |
| try { |
| tok = scanner.getNextToken(); |
| } catch (InvalidInputException e) { |
| continue; |
| } |
| if (tok == TokenNameEOF) |
| break; |
| |
| switch (tok) { |
| case TokenNameIdentifier: |
| if (!inAspect && !inTypeDeclaration()) |
| break; |
| |
| char[] name = scanner.getCurrentIdentifierSource(); |
| |
| if (inTypeDeclaration() && !inPointcutDesignator) { |
| |
| // only do this if we are not adding ITDs |
| if (inAspectDeclaration && !insertIntertypeDeclarations) { |
| if (CharOperation.equals(percflow, name)) { |
| startPointcutDesignator(); |
| } else if (CharOperation.equals(percflowbelow, name)) { |
| startPointcutDesignator(); |
| } else if (CharOperation.equals(perthis, name)) { |
| startPointcutDesignator(); |
| } else if (CharOperation.equals(pertarget, name)) { |
| startPointcutDesignator(); |
| } else if (CharOperation.equals(issingleton, name)) { |
| startPointcutDesignator(); |
| } else if (CharOperation.equals(pertypewithin, name)) { |
| startPointcutDesignator(); |
| } |
| } |
| // store the type name if not already found |
| if (currentTypeName == null) { |
| currentTypeName = name; |
| } |
| } |
| |
| if (CharOperation.equals(throwing, name)) |
| consumeRetOrThrow(); |
| else if (CharOperation.equals(returning, name)) |
| consumeRetOrThrow(); |
| else if (inPointcutDesignator |
| && Character.isUpperCase(name[0]) |
| && (content[scanner.getCurrentTokenStartPosition()-1]!='.')) { |
| typeReferences.add(new String(name)); |
| } |
| |
| if (isSimulateContextSwitchNecessary) { |
| usedIdentifiers.add(new String(name)); |
| } |
| break; |
| case TokenNamefor: |
| insideFor=true; |
| break; |
| case TokenNameLPAREN: |
| parenLevel++; |
| break; |
| case TokenNameRPAREN: |
| insideFor=false; |
| parenLevel--; |
| break; |
| case TokenNameCOLON: |
| if (!inAspect) |
| break; |
| if (insideFor) |
| break; |
| if (questionMarkCount > 0) { |
| questionMarkCount--; |
| break; |
| } |
| startPointcutDesignator(); |
| break; |
| |
| case TokenNameQUESTION: |
| questionMarkCount++; |
| break; |
| |
| case TokenNameSEMICOLON: |
| if (inPointcutDesignator) |
| endPointcutDesignator(); |
| break; |
| |
| |
| |
| case TokenNameDOT: |
| if (!inAspect) { |
| break; |
| } else if (inPointcutDesignator) { |
| break; |
| } else if (parenLevel > 0) { |
| // don't want to convert '.' to '$' inside the parameter declaration |
| break; |
| } |
| processPotentialIntertypeDeclaration(); |
| break; |
| |
| case TokenNameLBRACE: |
| if (inPointcutDesignator) { |
| endPointcutDesignator(); |
| //must be start of advice body -> insert tjp reference |
| if (insertIntertypeDeclarations && !inTypeDeclaration()) { |
| addReplacement(scanner.getCurrentTokenStartPosition() + 1, 0, |
| tjpRefs2); |
| } |
| } |
| |
| // determine if we should add intertype declarations |
| if (insertIntertypeDeclarations && inTypeDeclaration()) { |
| |
| char[] implementsExtends = createImplementExtendsITDs(currentTypeName); |
| if (implementsExtends != null) { |
| addReplacement(typeDeclStart, scanner.getCurrentTokenStartPosition()-typeDeclStart, implementsExtends); |
| } else { |
| // not able to add ITDs since no compilation unit available |
| // may have to replace "aspect" with "class " since we didn't do that before |
| |
| if (hasWordAtPosition("aspect", typeDeclStart)) { |
| addReplacement(typeDeclStart, classs.length, classs); |
| } |
| } |
| char[] interTypeDecls = getInterTypeDecls(currentTypeName); |
| if (interTypeDecls.length > 0) { |
| addReplacement(scanner.getCurrentTokenStartPosition() + 1, 0, interTypeDecls); |
| } |
| } |
| |
| |
| inAspectDeclaration = false; |
| inClassDeclaration = false; |
| inInterfaceDeclaration = false; |
| currentTypeName = null; |
| |
| // insideBlockCount ++; |
| break; |
| case TokenNameRBRACE: |
| // insideBlockCount ++; |
| if (inPointcutDesignator) { |
| // bug 129367: if we've hit a } here, we must be |
| // in the middle of an unterminated pointcut |
| endPointcutDesignator(); |
| } |
| break; |
| case TokenNameaspect: |
| inAspect = true; |
| inAspectDeclaration = true; |
| typeDeclStart = pos = scanner.getCurrentTokenStartPosition(); |
| |
| // only do this if not inserting ITDs |
| // if inserting ITDs, this replacement occurs in createImplementExtendsITDs() |
| if (!insertIntertypeDeclarations) { |
| addReplacement(pos, classs.length, classs); |
| } |
| |
| break; |
| |
| case TokenNameclass: |
| typeDeclStart = pos = scanner.getCurrentTokenStartPosition(); |
| inClassDeclaration = true; |
| break; |
| |
| case TokenNameinterface: // interface and @interface |
| typeDeclStart = pos = scanner.getCurrentTokenStartPosition(); |
| inInterfaceDeclaration = true; |
| break; |
| |
| case TokenNameprivileged: |
| pos = scanner.getCurrentTokenStartPosition(); |
| addReplacement(pos, privileged.length, privileged); |
| break; |
| |
| } |
| |
| } |
| |
| if (inPointcutDesignator) { |
| // bug 129367: if we've hit the end of the buffer, we must |
| // be in the middle of an unterminated pointcut |
| endPointcutDesignator(); |
| } |
| |
| if (addReferencesForOrganizeImports) |
| addReferences(); |
| |
| if (isSimulateContextSwitchNecessary) |
| simulateContextSwitch(options.getCodeCompletePosition(), options |
| .getTargetType()); |
| |
| applyReplacements(); |
| |
| //System.out.println(new String(content)); |
| return replacements; |
| } |
| |
| /** |
| * |
| * @param typeName name of the type |
| * @return new type declaration string to replace the original |
| * that contains all of the types that are declared parents of this one |
| * returns null if could not find the super types and super interfaces |
| */ |
| protected char[] createImplementExtendsITDs(char[] typeName) { |
| |
| if (unit != null) { |
| IType type = unit.getType(new String(typeName)); |
| if (type.exists()) { |
| try { |
| StringBuffer sb = new StringBuffer(); |
| sb.append(type.isInterface() ? "interface " : "class "); |
| sb.append(typeName); |
| |
| List[] declares = getDeclareExtendsImplements(type); |
| List declareExtends = declares[0]; |
| List declareImplements = declares[1]; |
| if (! type.isInterface()) { |
| String superClass = type.getSuperclassName(); |
| if (declareExtends.size() > 0) { |
| superClass = (String) declareExtends.get(0); |
| superClass = superClass.replace('$', '.'); |
| } |
| if (superClass != null) { |
| sb.append(" " + EXTENDS + " " + superClass); |
| } |
| } |
| |
| String[] superInterfaces = type.getSuperInterfaceNames(); |
| for (int i = 0; i < superInterfaces.length; i++) { |
| declareImplements.add(superInterfaces[i]); |
| } |
| |
| if (declareImplements.size() > 0) { |
| |
| if (type.isInterface()) { |
| sb.append(" " + EXTENDS + " "); |
| } else { |
| sb.append(" " + IMPLEMENTS + " "); |
| } |
| |
| for (Iterator interfaceIter = declareImplements.iterator(); interfaceIter |
| .hasNext();) { |
| String interName = (String) interfaceIter.next(); |
| interName = interName.replace('$', '.'); |
| sb.append(" " + interName); |
| if (interfaceIter.hasNext()) { |
| sb.append(","); |
| } |
| } |
| } |
| return sb.toString().toCharArray(); |
| } catch (JavaModelException e) { |
| AspectJPlugin.getDefault().getLog().log(new Status(Status.ERROR, AspectJPlugin.PLUGIN_ID, e.getMessage(), e)); |
| return null; |
| } |
| } |
| } |
| return null; |
| } |
| |
| |
| |
| |
| /** |
| * @param type type to look for declare extends on |
| * @return list of all declare extends that apply to this type |
| * in fully qualified strings |
| */ |
| protected List/*String*/[] getDeclareExtendsImplements(IType type) { |
| List declareExtends = new ArrayList(); |
| List declareImplements = new ArrayList(); |
| if (type != null && type.exists()) { |
| AJProjectModelFacade model = AJProjectModelFactory.getInstance().getModelForJavaElement(type); |
| if (model.hasModel()) { |
| List /*IJavaElement*/ rels = model.getRelationshipsForElement(type, AJRelationshipManager.ASPECT_DECLARATIONS); |
| for (Iterator eltIter = rels.iterator(); eltIter.hasNext();) { |
| IJavaElement je = (IJavaElement) eltIter.next(); |
| IProgramElement pe = model.javaElementToProgramElement(je); |
| if (pe.getKind() == IProgramElement.Kind.DECLARE_PARENTS) { |
| List/*String*/ parentTypes = pe.getParentTypes(); |
| String details = pe.getDetails(); |
| if (details.startsWith(EXTENDS)) { |
| declareExtends.addAll(parentTypes); |
| } else if (details.startsWith(IMPLEMENTS)) { |
| declareImplements.add(parentTypes); |
| } |
| } |
| } |
| } |
| } |
| return new List[] { declareExtends, declareImplements }; |
| } |
| |
| protected char[] getInterTypeDecls(char[] currentTypeName) { |
| if (unit != null) { |
| AJProjectModelFacade model = AJProjectModelFactory.getInstance().getModelForJavaElement(unit); |
| if (model.hasModel()) { |
| IType type = unit.getType(new String(currentTypeName)); |
| if (type.exists()) { |
| List /*IJavaElement*/ rels = model.getRelationshipsForElement(type, AJRelationshipManager.ASPECT_DECLARATIONS); |
| StringBuffer sb = new StringBuffer("\n\t"); |
| for (Iterator relIter = rels.iterator(); relIter.hasNext();) { |
| IJavaElement je = (IJavaElement) relIter.next(); |
| IProgramElement declareElt = model.javaElementToProgramElement(je); |
| if (declareElt != null && declareElt.getParent() != null && declareElt.getKind().isInterTypeMember()) { // checks to see if this element is valid |
| // should be fully qualified type and simple name |
| |
| int lastDot = declareElt.getName().lastIndexOf('.'); |
| String name = declareElt.getName().substring(lastDot+1); |
| |
| if (declareElt.getKind() == IProgramElement.Kind.INTER_TYPE_FIELD) { |
| sb.append(declareElt.getCorrespondingType(true) + " " + name + ";\n"); |
| } else if (declareElt.getKind() == IProgramElement.Kind.INTER_TYPE_METHOD || |
| declareElt.getKind() == IProgramElement.Kind.INTER_TYPE_CONSTRUCTOR) { |
| // need to add a return statement? |
| if (declareElt.getKind() == IProgramElement.Kind.INTER_TYPE_METHOD) { |
| sb.append(declareElt.getCorrespondingType(true) + " " + name); |
| } else { |
| sb.append(currentTypeName); |
| } |
| sb.append("("); |
| List/*String*/ names = declareElt.getParameterNames(); |
| List/*String*/ types = declareElt.getParameterTypes(); |
| for (Iterator typeIter = types.iterator(), nameIter = names.iterator(); |
| typeIter.hasNext();) { |
| String paramType = new String((char[]) typeIter.next()); |
| String paramName = (String) nameIter.next(); |
| sb.append(paramType + " " + paramName); |
| if (typeIter.hasNext()) { |
| sb.append(", "); |
| } |
| } |
| sb.append(") { }\n"); |
| } |
| } |
| } |
| return sb.toString().toCharArray(); |
| } |
| } |
| } |
| |
| return new char[0]; |
| } |
| |
| private boolean inTypeDeclaration() { |
| return (inAspectDeclaration || |
| inClassDeclaration || |
| inInterfaceDeclaration); |
| } |
| |
| /** |
| * Inserts a reference to targetType at the given position. Thanks to this, |
| * we can simulate the context switch necessary in intertype method |
| * declarations. |
| * |
| * Transformations: - Insertion of local variable 'TargetType thiz' (or, if |
| * thiz is already used, a number is added to thiz to make it unique) at |
| * start of method mody |
| * - if code completion on code like 'this.methodcall().more...', 'this |
| * gets replaced by thiz |
| * - if code completion on code like 'methodcall().more...', 'thiz.' gets |
| * added in front. |
| * |
| * How the correct place for insertion is found: - |
| * |
| * |
| */ |
| private void simulateContextSwitch(int position, char[] targetType) { |
| int pos = findInsertionPosition(position - 1) + 1; |
| //if code completion on 'this' -> overwrite the this keyword |
| int len = 0; |
| if ((content[pos] == 't') && (content[pos + 1] == 'h') |
| && (content[pos + 2] == 'i') && (content[pos + 3] == 's') |
| && !Character.isJavaIdentifierPart(content[pos + 4])) |
| len = 4; |
| |
| String ident = findFreeIdentifier(); |
| char[] toInsert = (new String(targetType) + ' ' + ident + ';' + ident + '.') |
| .toCharArray(); |
| addReplacement(pos, len, toInsert); |
| |
| } |
| |
| /** |
| * @return An unused identifier |
| */ |
| private String findFreeIdentifier() { |
| int i = 0; |
| String ident = thizString + i; |
| while (usedIdentifiers.contains(ident)) { |
| i++; |
| ident = thizString + i; |
| } |
| return ident; |
| } |
| |
| /** |
| * @param pos - |
| * a code position |
| * @return the position that defines the context of the current one at the |
| * highest level |
| * |
| * e.g. ' this.doSomthing().get' with pos on the last 't' returns the |
| * position of the char before the first 't' |
| */ |
| private int findInsertionPosition(int pos) { |
| char ch = content[pos]; |
| int currentPos = pos; |
| |
| if (Character.isWhitespace(ch)) { |
| currentPos = findPreviousNonSpace(pos); |
| if (currentPos == -1) |
| return pos; |
| |
| ch = content[currentPos]; |
| if (ch == '.') |
| return findInsertionPosition(--currentPos); |
| return pos; |
| } |
| |
| if (Character.isJavaIdentifierPart(ch)) { |
| while (Character.isJavaIdentifierPart(ch)) { |
| currentPos--; |
| ch = content[currentPos]; |
| } |
| return findInsertionPosition(currentPos); |
| } |
| |
| if (ch == '.') { |
| return findInsertionPosition(--pos); |
| } |
| |
| if (ch == ')') { |
| currentPos--; |
| int bracketCounter = 1; |
| while (currentPos >= 0) { |
| ch = content[currentPos]; |
| if (bracketCounter == 0) |
| break; |
| if (ch == ')') |
| bracketCounter++; |
| if (ch == '(') { |
| bracketCounter--; |
| if (bracketCounter < 0) |
| return -1; |
| } |
| currentPos--; |
| } |
| return findInsertionPosition(currentPos); |
| } |
| |
| return pos; |
| } |
| |
| private void applyReplacements() { |
| Iterator iter = replacements.listIterator(); |
| int offset = 0; |
| while (iter.hasNext()) { |
| Replacement ins = (Replacement) iter.next(); |
| ins.posAfter = ins.posBefore + offset; |
| replace(ins.posAfter, ins.length, ins.text); |
| offset += ins.lengthAdded; |
| } |
| } |
| |
| private void replace(int pos, int origLength, char[] text) { |
| if (origLength != text.length) { |
| int lengthDiff = text.length - origLength; |
| int oldEnd = pos + origLength; |
| int newEnd = pos + text.length; |
| char[] temp = new char[content.length + lengthDiff]; |
| |
| System.arraycopy(content, 0, temp, 0, pos); |
| System.arraycopy(content, oldEnd, temp, newEnd, content.length |
| - oldEnd); |
| content = temp; |
| } |
| System.arraycopy(text, 0, content, pos, text.length); |
| } |
| |
| private void startPointcutDesignator() { |
| if (inPointcutDesignator) |
| return; |
| inPointcutDesignator = true; |
| posColon = scanner.getCurrentTokenStartPosition(); |
| } |
| |
| /** |
| * |
| */ |
| private void endPointcutDesignator() { |
| inPointcutDesignator = false; |
| int posSemi = scanner.getCurrentTokenStartPosition(); |
| int len = posSemi - posColon; |
| char[] empty = new char[len]; |
| for (int i = 0; i < empty.length; i++) { |
| empty[i] = ' '; |
| } |
| addReplacement(posColon, len, empty); |
| } |
| |
| //identifies intertype declaration of form 'type qualifier.membername' |
| //and replaces every '.' by '$'. |
| //e.g. "int tracing.Circle.x;" -> "int tracing$Circle$x;" |
| private void processPotentialIntertypeDeclaration() { |
| |
| //pos points to the '.' |
| int pos = scanner.getCurrentTokenStartPosition(); |
| |
| //check if valid identifier char on left side of dot |
| //(to sort out construct like '(new Object()).' ) |
| int nonspace1 = findPreviousNonSpace(pos - 1); |
| if (nonspace1 == -1) |
| return; |
| if (!Character.isJavaIdentifierPart(content[nonspace1])) |
| return; |
| |
| //check if there is another java identifier before qualifier, |
| //if no, return (to sort out method calls and the like) |
| int space = findPreviousSpace(nonspace1); |
| if (space == -1) { |
| return; |
| } |
| int nonspace2 = findPreviousNonSpace(space); |
| if (nonspace2 == -1) { |
| return; |
| } |
| if (!Character.isJavaIdentifierPart(content[nonspace2]) && |
| content[nonspace2] != '>') { // could be a parameterized type |
| // but still could be part of a "new" ITD |
| int nextNonSpace = findNextNonSpace(pos+1); |
| if (!hasWordAtPosition("new", nextNonSpace)) { |
| // XXX problem here is that this doesn't account for comments |
| return; |
| } |
| } |
| //check if rightmost part of qualifier starts with Capital letter, |
| //and if yes, assume it is a Class name -> intertype declaration |
| int spaceordot = findPreviousWhitespaceOr(',', nonspace1); |
| if (spaceordot == -1) |
| return; |
| if (Character.isUpperCase(content[spaceordot + 1])) { |
| |
| //assume intertype declaration and replace all '.' by '$' |
| char[] rep = new char[] { '$' }; |
| addReplacement(pos, 1, rep); |
| |
| if (content[spaceordot] == ' ') { |
| String type = new String(content, space + 1, pos - space - 1); |
| boolean validIdentifier = true; |
| for (int i = 0; validIdentifier && (i < type.length()); i++) { |
| char c = type.charAt(i); |
| if (i==0) { |
| if (!Character.isJavaIdentifierStart(c)) { |
| validIdentifier = false; |
| } |
| } else if (!Character.isJavaIdentifierPart(c)) { |
| validIdentifier = false; |
| } |
| } |
| if (validIdentifier) { |
| typeReferences.add(type); |
| } |
| } else { |
| do { |
| addReplacement(spaceordot, 1, rep); |
| spaceordot = findPreviousWhitespaceOr(',', --spaceordot); |
| } while (content[spaceordot] == '.'); |
| } |
| |
| //if requested, add ajc$ in front of intertype declaration |
| //e.g. "public int Circle$x;" -> "public int ajc$Circle$x;" |
| if (options.isAddAjcTagToIntertypesEnabled()) { |
| addReplacement(spaceordot + 1, 0, "ajc$".toCharArray()); //$NON-NLS-1$ |
| } |
| |
| } |
| } |
| |
| private boolean hasWordAtPosition(String string, int pos) { |
| char[] word = string.toCharArray(); |
| for (int i = 0; i < word.length; i++) { |
| if (word[i] != content[pos+i] ) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| |
| public int findPrevious(char ch, int pos) { |
| while (pos >= 0) { |
| if (content[pos] == ch) |
| return pos; |
| pos--; |
| } |
| return -1; |
| } |
| |
| public int findPreviousWhitespaceOr(char ch, int pos) { |
| while (pos >= 0) { |
| if (content[pos] == ch || Character.isWhitespace(content[pos])) { |
| return pos; |
| } |
| pos--; |
| } |
| return -1; |
| } |
| |
| |
| |
| public int findPrevious(char[] chs, int pos) { |
| while (pos >= 0) { |
| for (int i = 0; i < chs.length; i++) { |
| if (content[pos] == chs[i]) |
| return pos; |
| } |
| pos--; |
| } |
| return -1; |
| } |
| |
| public int findPreviousSpace(int pos) { |
| while (pos >= 0) { |
| if (Character.isWhitespace(content[pos])) |
| return pos; |
| pos--; |
| } |
| return -1; |
| } |
| |
| public int findPreviousNonSpace(int pos) { |
| while (pos >= 0) { |
| if (!Character.isWhitespace(content[pos])) |
| return pos; |
| pos--; |
| } |
| return -1; |
| } |
| |
| public int findNextNonSpace(int pos) { |
| while (pos < content.length) { |
| if (!Character.isWhitespace(content[pos])) |
| return pos; |
| pos++; |
| } |
| return -1; |
| } |
| |
| public int findNext(char[] chs, int pos) { |
| while (pos < content.length) { |
| for (int i = 0; i < chs.length; i++) { |
| if (content[pos] == chs[i]) |
| return pos; |
| } |
| pos++; |
| } |
| return -1; |
| } |
| |
| private void consumeRetOrThrow() { |
| int pos = scanner.getCurrentTokenStartPosition(); |
| char[] content = scanner.source; |
| |
| int end = findNext(endThrow, pos); |
| if (end == -1) |
| return; |
| |
| char[] temp = null; |
| if (content[end] == endThrow[0]) { |
| pos = findPrevious(')', pos); |
| if (pos == -1) |
| return; |
| int advicebracket = findPrevious('(', pos); |
| if (advicebracket == -1) |
| return; |
| temp = new char[end - pos + 1]; |
| if (bracketsContainSomething(advicebracket) |
| && bracketsContainSomething(end)) |
| temp[0] = ','; |
| else |
| temp[0] = ' '; |
| for (int i = 1; i < temp.length; i++) { |
| temp[i] = ' '; |
| } |
| } else { |
| temp = new char[end - pos]; |
| for (int i = 0; i < temp.length; i++) { |
| temp[i] = ' '; |
| } |
| } |
| addReplacement(pos, temp.length, temp); |
| } |
| |
| /** |
| * @param end |
| * @return |
| */ |
| private boolean bracketsContainSomething(int start) { |
| while (++start < content.length) { |
| if (content[start] == ')') |
| return false; |
| if (Character.isJavaIdentifierPart(content[start])) |
| return true; |
| } |
| return false; |
| } |
| |
| private int findLast(char ch) { |
| int pos = content.length; |
| while (--pos >= 0) { |
| if (content[pos] == ch) |
| break; |
| } |
| return pos; |
| } |
| |
| //adds references to all used type -> organize imports will work |
| private void addReferences() { |
| if (typeReferences == null) |
| return; |
| |
| //char[] decl = new char[] { ' ', 'x', ';' }; |
| int pos = findLast('}'); |
| if (pos < 0) |
| return; |
| StringBuffer temp = new StringBuffer(typeReferences.size() * 10); |
| Iterator iter = typeReferences.iterator(); |
| int varCount=1; |
| while (iter.hasNext()) { |
| String ref = (String) iter.next(); |
| temp.append(ref); |
| temp.append(" x"); //$NON-NLS-1$ |
| temp.append(varCount++); |
| temp.append(';'); |
| } |
| char[] decls = new char[temp.length()]; |
| temp.getChars(0, decls.length, decls, 0); |
| addReplacement(pos, 0, decls); |
| } |
| |
| //adds a replacement to list |
| //pre: list sorted, post: list sorted |
| private void addReplacement(int pos, int length, char[] text) { |
| int last = replacements.size() - 1; |
| while (last >= 0) { |
| if (((Replacement) replacements.get(last)).posBefore < pos) |
| break; |
| last--; |
| } |
| replacements.add(last + 1, new Replacement(pos, length, text)); |
| } |
| |
| public static boolean conflictsWithAJEdit(int offset, int length, |
| ArrayList replacements) { |
| Replacement ins; |
| for (int i = 0; i < replacements.size(); i++) { |
| ins = (Replacement) replacements.get(i); |
| if ((offset >= ins.posAfter) && (offset < ins.posAfter + ins.length)) { |
| return true; |
| } |
| if ((offset < ins.posAfter) && (offset + length > ins.posAfter)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| //translates a position from after to before changes |
| //if the char at that position did not exist before, it returns the |
| // position before the inserted area |
| public static int translatePositionToBeforeChanges(int posAfter, |
| ArrayList replacements) { |
| Replacement ins; |
| int offset = 0, i; |
| |
| for (i = 0; i < replacements.size(); i++) { |
| ins = (Replacement) replacements.get(i); |
| if (ins.posAfter > posAfter) |
| break; |
| offset += ins.lengthAdded; |
| } |
| if (i > 0) { |
| ins = (Replacement) replacements.get(i - 1); |
| if (ins.posAfter + ins.text.length > posAfter) { |
| //diff must be > 0 |
| int diff = posAfter - ins.posAfter; |
| if (diff > ins.length) |
| //we are in inserted area -> return pos directly before |
| // that area |
| offset += diff - ins.length; |
| } |
| } |
| |
| return posAfter - offset; |
| } |
| |
| //translates a position from before to after changes |
| public static int translatePositionToAfterChanges(int posBefore, |
| ArrayList replacements) { |
| for (int i = 0; i < replacements.size(); i++) { |
| Replacement ins = (AspectsConvertingParser.Replacement) replacements |
| .get(i); |
| if (ins.posAfter <= posBefore) |
| posBefore += ins.lengthAdded; |
| else |
| return posBefore; |
| } |
| return posBefore; |
| } |
| |
| } |
