Logo Search packages:      
Sourcecode: aspectj version File versions  Download package

PseudoTokens.java

/* *******************************************************************
 * Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC).
 * 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: 
 *     PARC     initial implementation 
 * ******************************************************************/


package org.aspectj.ajdt.internal.compiler.ast;

import org.aspectj.weaver.IHasPosition;
import org.aspectj.weaver.ISourceContext;
import org.aspectj.weaver.patterns.BasicTokenSource;
import org.aspectj.weaver.patterns.Declare;
import org.aspectj.weaver.patterns.IToken;
import org.aspectj.weaver.patterns.ParserException;
import org.aspectj.weaver.patterns.PatternParser;
import org.aspectj.weaver.patterns.PerClause;
import org.aspectj.weaver.patterns.PerSingleton;
import org.aspectj.weaver.patterns.Pointcut;
import org.aspectj.weaver.patterns.TypePattern;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.MethodDeclaration;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.aspectj.org.eclipse.jdt.internal.compiler.parser.Parser;
import org.aspectj.org.eclipse.jdt.internal.compiler.parser.TerminalTokens;


public class PseudoTokens extends ASTNode {
      BasicTokenSource tokenSource;
      PseudoToken[] tokens;  //XXX this is redundant with the field above
      String endToken;
      

      public PseudoTokens(PseudoToken[] tokens, ISourceContext sourceContext) {
            super();
            this.tokens = tokens;
            this.tokenSource = new BasicTokenSource(tokens, sourceContext);
            endToken = tokens[tokens.length-1].getString();
            sourceStart = tokens[0].sourceStart;
            sourceEnd = tokens[tokens.length-2].sourceEnd;
      }
      
      public Pointcut parsePointcut(Parser parser) {
            PatternParser patternParser = new PatternParser(tokenSource);
            try {
                  Pointcut ret = patternParser.parsePointcut();
                  checkEof(parser);
                  return ret;
            } catch (ParserException pe) {
                  reportError(parser, pe);
                  return Pointcut.makeMatchesNothing(Pointcut.SYMBOLIC);
            }
      }

      private void checkEof(Parser parser) {
            IToken last = tokenSource.next();
            if (tokenSource.next() != IToken.EOF) {
                  parser.problemReporter().parseError(last.getStart(), last.getEnd(),
                                                                  TerminalTokens.TokenNameIdentifier,
                                                last.getString().toCharArray(),
                                                last.getString(),
                                                new String[] {endToken});
            }
      }

      
      private void reportError(Parser parser, ParserException pe) {
            IHasPosition tok = pe.getLocation();
            int start, end;
            if (tok == IToken.EOF) {
                  start = sourceEnd+1;
                  end = sourceEnd+1;
            } else {
                  start = tok.getStart();
                  end = tok.getEnd();
            }
            String found = "<unknown>";
            if (tok instanceof IToken) {
                  found = ((IToken)tok).getString();
            }
            
            parser.problemReporter().parseError(start, end,
                                                                  TerminalTokens.TokenNameIdentifier,
                                                found.toCharArray(),
                                                found,
                                                new String[] {pe.getMessage()});
      }
      
      
      public TypePattern maybeParseDominatesPattern(Parser parser) {
            PatternParser patternParser = new PatternParser(tokenSource);
            try {
                  if (patternParser.maybeEatIdentifier("dominates")) {
                        // there is no eof check here
                        return patternParser.parseTypePattern();
                  } else {
                        return null;
                  }
            } catch (ParserException pe) {
                  reportError(parser, pe);
                  return null;
            }
      }           
      
      
      public PerClause parsePerClause(Parser parser) {
            PatternParser patternParser = new PatternParser(tokenSource);
            try {
                  PerClause ret = patternParser.maybeParsePerClause();
                  checkEof(parser);
                  if (ret == null) return new PerSingleton();
                  else return ret;
            } catch (ParserException pe) {
                  reportError(parser, pe);
                  return new PerSingleton();
            }
            
      }
      
      
//    public TypePattern parseTypePattern(Parser parser) {
//    }
//    
      public Declare parseDeclare(Parser parser) {
            PatternParser patternParser = new PatternParser(tokenSource);
            try {
                  Declare ret = patternParser.parseDeclare();
                  checkEof(parser);
                  return ret;
            } catch (ParserException pe) {
                  reportError(parser, pe);
                  return null;
            }
      }
      
      public Declare parseAnnotationDeclare(Parser parser) {
            PatternParser patternParser = new PatternParser(tokenSource);
            try {
                  Declare ret = patternParser.parseDeclareAnnotation();
                  checkEof(parser);
                  return ret;
            } catch (ParserException pe) {
                  reportError(parser, pe);
                  return null;
            }     }
      
      
      public void postParse(TypeDeclaration typeDec, MethodDeclaration enclosingDec) {
            for (int i=0, len=tokens.length; i < len; i++) {
                  tokens[i].postParse(typeDec, enclosingDec);
            }
      }
      
      /* (non-Javadoc)
       * @see org.eclipse.jdt.internal.compiler.ast.ASTNode#print(int, java.lang.StringBuffer)
       */
      public StringBuffer print(int indent, StringBuffer output) {
            output.append(tokenSource.toString());
            return output;
      }

}

Generated by  Doxygen 1.6.0   Back to index