* Copyright (c) 2002,2003 Palo Alto Research Center, Incorporated (PARC).

*               2004, contributors

* All rights reserved.

* This program and the accompanying materials are made available

* under the terms of the Common Public License v1.0

* which accompanies this distribution and is available at

* http://www.eclipse.org/legal/cpl-v10.html

* 

* Contributors:

*     PARC     initial implementation

*     Adrian Colyer refactored for use in org.aspectj.org.eclipse.jdt.core package

* ******************************************************************/

 

  private static final String ASPECTJ_DECLARATION_FACTORY = "org.aspectj.ajdt.internal.compiler.parser.DeclarationFactory";

  private static IDeclarationFactory declarationFactory;

 

  static {

    try{

      initTables(Parser.class);

      declarationFactory = (IDeclarationFactory) Class.forName(ASPECTJ_DECLARATION_FACTORY).newInstance();

    } catch(java.io.IOException ex){

      throw new ExceptionInInitializerError(ex.getMessage());

    } catch (InstantiationException ex) {

      throw new ExceptionInInitializerError(ex.getMessage());

    } catch (IllegalAccessException ex) {

      throw new ExceptionInInitializerError(ex.getMessage());

    } catch (ClassNotFoundException ex) {

      System.err.println("Warning: AspectJ declaration factory class not found on classpath");

      //throw new ExceptionInInitializerError(ex.getMessage());

    }

  }

      MessageSend createProceed(MessageSend m);

      TypeDeclaration createAspect(CompilationResult result);

      void setPrivileged(TypeDeclaration aspectDecl, boolean isPrivileged);

      void setPerClauseFrom(TypeDeclaration aspectDecl, ASTNode pseudoTokens, Parser parser);

      void setDominatesPatternFrom(TypeDeclaration aspectDecl, ASTNode pseudoTokens, Parser parser);

      ASTNode createPseudoTokensFrom(ASTNode[] tokens, CompilationResult result);

      MethodDeclaration createMethodDeclaration(CompilationResult result);

      ConstructorDeclaration createConstructorDeclaration(CompilationResult result);

      MethodDeclaration createPointcutDeclaration(CompilationResult result);

      MethodDeclaration createAroundAdviceDeclaration(CompilationResult result);

      MethodDeclaration createAfterAdviceDeclaration(CompilationResult result);

      MethodDeclaration createBeforeAdviceDeclaration(CompilationResult result);

      ASTNode createPointcutDesignator(Parser parser, ASTNode pseudoTokens);

      void setPointcutDesignatorOnAdvice(MethodDeclaration adviceDecl, ASTNode des);

      void setPointcutDesignatorOnPointcut(MethodDeclaration adviceDecl, ASTNode des);

      void setExtraArgument(MethodDeclaration adviceDeclaration, Argument arg);

      boolean isAfterAdvice(MethodDeclaration adviceDecl);

      void setAfterThrowingAdviceKind(MethodDeclaration adviceDecl);

      void setAfterReturningAdviceKind(MethodDeclaration adviceDecl);

      MethodDeclaration createDeclareDeclaration(CompilationResult result, ASTNode pseudoTokens, Parser parser);

      MethodDeclaration createDeclareAnnotationDeclaration(CompilationResult result, ASTNode pseudoTokens, Annotation annotation, Parser parser,char kind);

      MethodDeclaration createInterTypeFieldDeclaration(CompilationResult result, TypeReference onType);

      MethodDeclaration createInterTypeMethodDeclaration(CompilationResult result);

      MethodDeclaration createInterTypeConstructorDeclaration(CompilationResult result);

      void setSelector(MethodDeclaration interTypeDecl, char[] selector);

      void setDeclaredModifiers(MethodDeclaration interTypeDecl, int modifiers);

      void setInitialization(MethodDeclaration itdFieldDecl, Expression initialization);

      void setOnType(MethodDeclaration interTypeDecl, TypeReference onType);

      ASTNode createPseudoToken(Parser parser, String value, boolean isIdentifier);

      ASTNode createIfPseudoToken(Parser parser, Expression expr);

      void setLiteralKind(ASTNode pseudoToken, String string);

      boolean shouldTryToRecover(ASTNode node);

      TypeDeclaration createIntertypeMemberClassDeclaration(CompilationResult compilationResult);

      void setOnType(TypeDeclaration interTypeDecl, TypeReference onType);

  }

 

//    throws java.io.IOException {

//

//    final String prefix = FILEPREFIX;

//    int i = 0;

//    lhsStatic = readTable(parserClass, prefix + (++i) + ".rsc"); //$NON-NLS-1$

//    char[] chars = readTable(parserClass, prefix + (++i) + ".rsc"); //$NON-NLS-1$

//    check_tableStatic = new short[chars.length];

//    for (int c = chars.length; c-- > 0;) {

//      check_tableStatic[c] = (short) (chars[c] - 32768);

//    }

//    asbStatic = readTable(parserClass, prefix + (++i) + ".rsc"); //$NON-NLS-1$

//    asrStatic = readTable(parserClass, prefix + (++i) + ".rsc"); //$NON-NLS-1$

//    symbol_indexStatic = readTable(parserClass, prefix + (++i) + ".rsc"); //$NON-NLS-1$

//    actionStatic = lhsStatic;

//  }

  //positions , dimensions , .... (int stacks)

  protected int aspectIntPtr;

  protected int[] aspectIntStack;

  /* (non-Javadoc)

   * @see org.aspectj.org.eclipse.jdt.internal.compiler.parser.TheOriginalJDTParserClass#initialize()

   */

  public void initialize() {

    super.initialize();

    aspectIntPtr = -1;

    aspectIntStack = new int[4];

  }

  public void initialize(boolean initializeNLS) {

    super.initialize(initializeNLS);

    aspectIntPtr = -1;

    aspectIntStack = new int[4];

  }

 

  public void initializeScanner(){

    this.scanner = new Scanner(

      false /*comment*/,

      false /*whitespace*/,

      this.options.getSeverity(CompilerOptions.NonExternalizedString) != ProblemSeverities.Ignore /*nls*/,

      this.options.sourceLevel /*sourceLevel*/,

      this.options.taskTags/*taskTags*/,

      this.options.taskPriorites/*taskPriorities*/,

      this.options.isTaskCaseSensitive/*taskCaseSensitive*/);

  }

 

 

 

  private static final boolean AJ_DEBUG = false;

  void println(Object o) {

    if (AJ_DEBUG) System.out.println(o);

  }

  private void printStack(Object[] s, int p) {

    List list = Arrays.asList(s);

    System.out.println("  " + list.subList(0, p+1));

  }

 

  private void printStack(int[] s, int p) {

    StringBuffer buf = new StringBuffer("[");

    for (int i=0; i<p+1; i++) {

      if (i > 0) buf.append(", ");

      buf.append(Integer.toString(s[i]));

    }

    buf.append("]");

    System.out.println("  " + buf);

  }

     

  private void printStack(long[] s, int p) {

    StringBuffer buf = new StringBuffer("[");

    for (int i=0; i<p+1; i++) {

      if (i > 0) buf.append(", ");

      buf.append(Long.toString(s[i]));

    }

    buf.append("]");

    System.out.println("  " + buf);

  }

     

  private void printStack(char[][] s, int p) {

    StringBuffer buf = new StringBuffer("[");

    for (int i=0; i<p+1; i++) {

      if (i > 0) buf.append(", ");

      buf.append(new String(s[i]));

    }

    buf.append("]");

    System.out.println("  " + buf);

  }

     

  public void display() {

    if (!AJ_DEBUG) return;

    System.out.print("astStack: ");

    printStack(astStack, astPtr);

    System.out.print("astLengthStack: ");

    printStack(astLengthStack, astLengthPtr);

   

    System.out.print("expressionStack: ");

    printStack(expressionStack, expressionPtr);

    System.out.print("expressionLengthStack: ");

    printStack(expressionLengthStack, expressionLengthPtr);

    System.out.print("identifierStack: ");

    printStack(identifierStack, identifierPtr);

    System.out.print("identifierLengthStack: ");

    printStack(identifierLengthStack, identifierLengthPtr);

    System.out.print("identifierPositionStack: ");

    printStack(identifierPositionStack, identifierPtr);

   

    System.out.print("intStack:");

    printStack(intStack, intPtr);

    System.out.println();

  } 

  protected MethodDeclaration createMethodDeclaration(CompilationResult result) {

    return declarationFactory.createMethodDeclaration(result);

  }

 

  protected ConstructorDeclaration createConstructorDeclaration(CompilationResult result) {

    return declarationFactory.createConstructorDeclaration(result);

  }

 

  protected void consumeMethodInvocationName() {

    super.consumeMethodInvocationName();

    MessageSend m = (MessageSend)expressionStack[expressionPtr];

    if (CharOperation.equals(m.selector, "proceed".toCharArray())) {

      expressionStack[expressionPtr] = declarationFactory.createProceed(m);

    }

  }

 

  protected void consumeToken(int type) {