package org.eclipse.jdt.internal.core.util;

/*Generated by MPS */

import jetbrains.mps.annotations.GeneratedClass;
import org.eclipse.jdt.internal.compiler.parser.Parser;
import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
import org.eclipse.jdt.internal.compiler.util.Util;
import org.eclipse.jdt.internal.compiler.parser.Scanner;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;

/**
 * *******************************************************************************
 * * Copyright (c) 2000, 2012 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:
 * *     IBM Corporation - initial API and implementation
 * *******************************************************************************
 * 
 * Internal parser used for parsing source to create DOM AST nodes.
 * 
 * @since 3.0
 */
@GeneratedClass(node = "r:40e27d97-dea1-422b-91e0-3b9f3271a7f1(org.eclipse.jdt.internal.core.util)/1218034168005181764", model = "r:40e27d97-dea1-422b-91e0-3b9f3271a7f1(org.eclipse.jdt.internal.core.util)")
public class CommentRecorderParser extends Parser {
  /*package*/ int[] commentStops = new int[10];
  /*package*/ int[] commentStarts = new int[10];
  /*package*/ int commentPtr = -1;
  protected static final int CommentIncrement = 100;
  public CommentRecorderParser(ProblemReporter problemReporter, boolean optimizeStringLiterals) {
    super(problemReporter, optimizeStringLiterals);
  }
  public void checkComment() {
    // discard obsolete comments while inside methods or fields initializer (see bug 74369)
    if (!(this.diet && this.dietInt == 0) && this.scanner.commentPtr >= 0) {
      flushCommentsDefinedPriorTo(this.endStatementPosition);
    }
    boolean deprecated = false;
    boolean checkDeprecated = false;
    int lastCommentIndex = -1;
    // since jdk1.2 look only in the last java doc comment...
    // converted:  for ( expr; ...) {}  ->  { expr; for ( ; ...) {} }
    lastCommentIndex = this.scanner.commentPtr;
nextComment:
    for (; lastCommentIndex >= 0; lastCommentIndex--) {
      // look for @deprecated into the first javadoc comment preceeding the declaration
      int commentSourceStart = this.scanner.commentStarts[lastCommentIndex];
      // javadoc only (non javadoc comment have negative start and/or end positions.)
      if ((commentSourceStart < 0) || (this.modifiersSourceStart != -1 && this.modifiersSourceStart < commentSourceStart) || (this.scanner.commentStops[lastCommentIndex] < 0)) {
        continue nextComment;
      }
      checkDeprecated = true;
      int commentSourceEnd = this.scanner.commentStops[lastCommentIndex] - 1;
      // stop is one over
      // do not report problem before last parsed comment while recovering code...
      if (this.javadocParser.shouldReportProblems) {
        this.javadocParser.reportProblems = this.currentElement == null || commentSourceEnd > this.lastJavadocEnd;
      } else {
        this.javadocParser.reportProblems = false;
      }
      deprecated = this.javadocParser.checkDeprecation(lastCommentIndex);
      this.javadoc = this.javadocParser.docComment;
      if (this.currentElement == null) {
        this.lastJavadocEnd = commentSourceEnd;
      }
      break nextComment;
    }
    if (deprecated) {
      checkAndSetModifiers(ClassFileConstants.AccDeprecated);
    }
    // modify the modifier source start to point at the first comment
    if (lastCommentIndex >= 0 && checkDeprecated) {
      this.modifiersSourceStart = this.scanner.commentStarts[lastCommentIndex];
      if (this.modifiersSourceStart < 0) {
        this.modifiersSourceStart = -this.modifiersSourceStart;
      }
    }
  }
  /**
   * @see org.eclipse.jdt.internal.compiler.parser.Parser#consumeClassHeader()
   */
  protected void consumeClassHeader() {
    pushOnCommentsStack(0, this.scanner.commentPtr);
    super.consumeClassHeader();
  }
  /**
   * @see org.eclipse.jdt.internal.compiler.parser.Parser#consumeEmptyTypeDeclaration()
   */
  protected void consumeEmptyTypeDeclaration() {
    pushOnCommentsStack(0, this.scanner.commentPtr);
    super.consumeEmptyTypeDeclaration();
  }
  /**
   * @see org.eclipse.jdt.internal.compiler.parser.Parser#consumeInterfaceHeader()
   */
  protected void consumeInterfaceHeader() {
    pushOnCommentsStack(0, this.scanner.commentPtr);
    super.consumeInterfaceHeader();
  }
  /**
   * @see org.eclipse.jdt.internal.compiler.parser.Parser#endParse(int)
   */
  protected CompilationUnitDeclaration endParse(int act) {
    CompilationUnitDeclaration unit = super.endParse(act);
    if (unit.comments == null) {
      pushOnCommentsStack(0, this.scanner.commentPtr);
      unit.comments = getCommentsPositions();
    }
    return unit;
  }
  /**
   * Save all source comments currently stored before flushing them.
   * @see org.eclipse.jdt.internal.compiler.parser.Parser#flushCommentsDefinedPriorTo(int)
   */
  public int flushCommentsDefinedPriorTo(int position) {
    int lastCommentIndex = this.scanner.commentPtr;
    if (lastCommentIndex < 0) {
      return position;
    }
    // no comment
    // compute the index of the first obsolete comment
    int index = lastCommentIndex;
    int validCount = 0;
    while (index >= 0) {
      int commentEnd = this.scanner.commentStops[index];
      if (commentEnd < 0) {
        commentEnd = -commentEnd;
      }
      // negative end position for non-javadoc comments
      if (commentEnd <= position) {
        break;
      }
      index--;
      validCount++;
    }
    // if the source at <position> is immediately followed by a line comment, then
    // flush this comment and shift <position> to the comment end.
    if (validCount > 0) {
      int immediateCommentEnd = 0;
      while (index < lastCommentIndex && (immediateCommentEnd = -this.scanner.commentStops[index + 1]) > 0) {
        // only tolerating non-javadoc comments (non-javadoc comment end positions are negative)
        // is there any line break until the end of the immediate comment ? (thus only tolerating line comment)
        immediateCommentEnd--;
        // comment end in one char too far
        if (Util.getLineNumber(position, this.scanner.lineEnds, 0, this.scanner.linePtr) != Util.getLineNumber(immediateCommentEnd, this.scanner.lineEnds, 0, this.scanner.linePtr)) {
          break;
        }
        position = immediateCommentEnd;
        validCount--;
        // flush this comment
        index++;
      }
    }
    if (index < 0) {
      return position;
    }
    // no obsolete comment
    pushOnCommentsStack(0, index);
    // store comment before flushing them
    switch (validCount) {
      case 0:
        // do nothing
        break;
        // move valid comment infos, overriding obsolete comment infos
      case 2:
        this.scanner.commentStarts[0] = this.scanner.commentStarts[index + 1];
        this.scanner.commentStops[0] = this.scanner.commentStops[index + 1];
        this.scanner.commentTagStarts[0] = this.scanner.commentTagStarts[index + 1];
        this.scanner.commentStarts[1] = this.scanner.commentStarts[index + 2];
        this.scanner.commentStops[1] = this.scanner.commentStops[index + 2];
        this.scanner.commentTagStarts[1] = this.scanner.commentTagStarts[index + 2];
        break;
      case 1:
        this.scanner.commentStarts[0] = this.scanner.commentStarts[index + 1];
        this.scanner.commentStops[0] = this.scanner.commentStops[index + 1];
        this.scanner.commentTagStarts[0] = this.scanner.commentTagStarts[index + 1];
        break;
      default:
        System.arraycopy(this.scanner.commentStarts, index + 1, this.scanner.commentStarts, 0, validCount);
        System.arraycopy(this.scanner.commentStops, index + 1, this.scanner.commentStops, 0, validCount);
        System.arraycopy(this.scanner.commentTagStarts, index + 1, this.scanner.commentTagStarts, 0, validCount);
    }
    this.scanner.commentPtr = validCount - 1;
    return position;
  }
  /**
   * Build a n*2 matrix of comments positions.
   * For each position, 0 is for start position and 1 for end position of the comment.
   */
  public int[][] getCommentsPositions() {
    int[][] positions = new int[this.commentPtr + 1][2];
    for (int i = 0; i <= this.commentPtr; i++) {
      positions[i][0] = this.commentStarts[i];
      positions[i][1] = this.commentStops[i];
    }
    return positions;
  }
  /**
   * @see org.eclipse.jdt.internal.compiler.parser.Parser#initialize()
   */
  public void initialize(boolean initializeNLS) {
    super.initialize(initializeNLS);
    this.commentPtr = -1;
  }
  /**
   * @see org.eclipse.jdt.internal.compiler.parser.Parser#initialize()
   */
  public void initialize() {
    super.initialize();
    this.commentPtr = -1;
  }
  /**
   * Create and store a specific comment recorder scanner.
   * @see org.eclipse.jdt.internal.compiler.parser.Parser#initializeScanner()
   */
  public void initializeScanner() {
    // comment
    // whitespace
    // nls
    // sourceLevel
    // taskTags
    // taskPriorities
    // taskCaseSensitive
    this.scanner = new Scanner(false, false, this.options.getSeverity(CompilerOptions.NonExternalizedString) != ProblemSeverities.Ignore, this.options.sourceLevel, this.options.taskTags, this.options.taskPriorities, this.options.isTaskCaseSensitive);
  }
  /**
   * Push all stored comments in stack.
   */
  private void pushOnCommentsStack(int start, int end) {
    for (int i = start; i <= end; i++) {
      // First see if comment hasn't been already stored
      int scannerStart = (this.scanner.commentStarts[i] < 0 ? -this.scanner.commentStarts[i] : this.scanner.commentStarts[i]);
      int commentStart = (this.commentPtr == -1 ? -1 : ((this.commentStarts[this.commentPtr] < 0 ? -this.commentStarts[this.commentPtr] : this.commentStarts[this.commentPtr])));
      if (commentStart == -1 || scannerStart > commentStart) {
        int stackLength = this.commentStarts.length;
        if (++this.commentPtr >= stackLength) {
          System.arraycopy(this.commentStarts, 0, this.commentStarts = new int[stackLength + CommentIncrement], 0, stackLength);
          System.arraycopy(this.commentStops, 0, this.commentStops = new int[stackLength + CommentIncrement], 0, stackLength);
        }
        this.commentStarts[this.commentPtr] = this.scanner.commentStarts[i];
        this.commentStops[this.commentPtr] = this.scanner.commentStops[i];
      }
    }
  }
  /**
   * Save all source comments currently stored before flushing them.
   * this.scanner.commentPtr is expected *not* yet being reset before calling this method.
   * @see org.eclipse.jdt.internal.compiler.parser.Parser#resetModifiers()
   */
  protected void resetModifiers() {
    pushOnCommentsStack(0, this.scanner.commentPtr);
    super.resetModifiers();
  }
}
