/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

* SourceIterator can be used to traverse through the source file character at a time

*

*/

package com.nokia.tracecompiler.source;

/**

 * SourceIterator can be used to traverse through the source file character at a

 * time.

 * 

 */

public class SourceIterator {

	/**

	 * The source parser

	 */

	private SourceParser parser;

	/**

	 * Index of next excluded area

	 */

	private int nextExcludedIndex;

	/**

	 * The type of next excluded area

	 */

	private int nextExcludedAreaType;

	/**

	 * Offset to the start of next excluded area

	 */

	private int nextExcludedStart;

	/**

	 * Offset to the end of next excluded area

	 */

	private int nextExcludedEnd;

	/**

	 * Index of next character to be fetched

	 */

	private int nextIndex;

	/**

	 * Index of character returned by latest call to next

	 */

	private int currentIndex;

	/**

	 * Index of character returned by previous call to next

	 */

	private int previousIndex;

	/**

	 * Search flags

	 */

	private int flags;

	/**

	 * Constructor

	 * 

	 * @param parser

	 *            source parser

	 * @param startIndex

	 *            the index where to start

	 * @param flags

	 *            the iterator flags

	 */

	SourceIterator(SourceParser parser, int startIndex, int flags) {

		SourceDocumentInterface source = parser.getSource();

		if (startIndex >= source.getLength()

				&& ((flags & SourceParser.BACKWARD_SEARCH) != 0)) {

			nextIndex = source.getLength() - 1;

		} else {

			nextIndex = startIndex;

		}

		this.parser = parser;

		this.flags = flags;

		if (hasNext()) {

			boolean forward = (flags & SourceParser.BACKWARD_SEARCH) == 0;

			nextExcludedIndex = parser.findExcludedAreaIndex(nextIndex);

			if (nextExcludedIndex < 0) {

				nextExcludedIndex = -1 - nextExcludedIndex;

				if (forward) {

					// Update increments the index, so it must be moved behind

					// the start of search

					nextExcludedIndex--;

				}

			}

			// Increments / decrements the next excluded area according to

			// search direction. If direction is backward, this decrements the

			// index. In that case the above initialization has selected the

			// index after the start of search index. If direction is forward,

			// this increments the index.

			updateExcludedIndex();

			// After the excluded index has been set, the white spaces and

			// comments are skipped

			if (forward) {

				forwardSeekNext();

			} else {

				backwardSeekNext();

			}

			previousIndex = startIndex;

			currentIndex = startIndex;

		}

	}

	/**

	 * Determines if there are more characters to process

	 * 

	 * @return true if iterator has more characters

	 */

	public boolean hasNext() {

		return (flags & SourceParser.BACKWARD_SEARCH) == 0 ? nextIndex < parser

				.getSource().getLength() : nextIndex >= 0;

	}

	/**

	 * Gets the next character from this iterator

	 * 

	 * @return the next character

	 * @throws SourceParserException

	 *             if there are no more characters

	 */

	public char next() throws SourceParserException {

		char ret;

		previousIndex = currentIndex;

		currentIndex = nextIndex;

		if ((flags & SourceParser.BACKWARD_SEARCH) == 0) {

			ret = forwardNext();

		} else {

			ret = backwardNext();

		}

		return ret;

	}

	/**

	 * Returns next character moving forward

	 * 

	 * @return the character

	 * @throws SourceParserException

	 *             if there are no more characters

	 */

	private char forwardNext() throws SourceParserException {

		char c = parser.getSource().getChar(nextIndex);

		nextIndex++;

		forwardSeekNext();

		return c;

	}

	/**

	 * Skips to next index

	 */

	private void forwardSeekNext() {

		// Skips over the excluded area if the index enters one

		boolean didSkip;

		SourceDocumentInterface source = parser.getSource();

		try {

			do {

				didSkip = false;

				if (nextIndex >= nextExcludedStart && nextExcludedStart != -1) {

					// Skips if applicable. Otherwise just updates the next

					// excluded

					// area variables

					if (isExcluded()) {

						nextIndex = nextExcludedEnd;

					}

					updateExcludedIndex();

				}

				if ((flags & SourceParser.SKIP_WHITE_SPACES) != 0) {

					// Skips over white spaces

					boolean wspFound = true;

					do {

						// If a white space is skipped, the excluded area check

						// needs to be done again. didSkip flag controls that

						if (nextIndex < source.getLength()

								&& Character.isWhitespace(source

										.getChar(nextIndex))) {

							nextIndex++;

							didSkip = true;

						} else {

							wspFound = false;

						}

					} while (wspFound);

				}

			} while (didSkip);

		} catch (SourceParserException e) {

			// The exception must not be thrown out of this function

		}

	}

	/**

	 * Returns next character moving backward

	 * 

	 * @return the character

	 * @throws SourceParserException

	 *             if there are no more characters

	 */

	private char backwardNext() throws SourceParserException {

		char c = parser.getSource().getChar(nextIndex);

		nextIndex--;

		backwardSeekNext();

		return c;

	}

	/**

	 * Skips to previous index

	 */

	private void backwardSeekNext() {

		// Skips over the excluded area if the index enters one

		boolean didSkip;

		SourceDocumentInterface source = parser.getSource();

		try {

			do {

				didSkip = false;

				if (nextIndex <= nextExcludedEnd - 1) {

					// Skips if applicable. Otherwise just updates the next

					// excluded

					// area variables

					if (isExcluded()) {

						nextIndex = nextExcludedStart - 1;

					}

					updateExcludedIndex();

				}

				if ((flags & SourceParser.SKIP_WHITE_SPACES) != 0) {

					boolean wspFound = true;

					do {

						// If a white space is skipped, the excluded area check

						// needs to be done again. didSkip flag controls that

						if (nextIndex >= 0

								&& Character.isWhitespace(source

										.getChar(nextIndex))) {

							nextIndex--;

							didSkip = true;

						} else {

							wspFound = false;

						}

					} while (wspFound);

				}

			} while (didSkip);

		} catch (SourceParserException e) {

			// The exception must not be thrown out of this function

		}

	}

	/**

	 * Updates the excluded area index

	 */

	private void updateExcludedIndex() {

		if ((flags & SourceParser.BACKWARD_SEARCH) == 0) {

			nextExcludedIndex++;

		} else {

			nextExcludedIndex--;

		}

		// Updates the values using the next excluded area

		if (nextExcludedIndex >= 0

				&& nextExcludedIndex < parser.getExcludedAreas().size()) {

			SourceExcludedArea p = parser.getExcludedAreas().get(

					nextExcludedIndex);

			nextExcludedStart = p.getOffset();

			nextExcludedEnd = p.getOffset() + p.getLength();

			nextExcludedAreaType = p.getType();

		} else {

			nextExcludedStart = -1;

			nextExcludedEnd = -1;

		}

	}

	/**

	 * Returns the index where the next character will be fetched

	 * 

	 * @return the index

	 */

	public int nextIndex() {

		return nextIndex;

	}

	/**

	 * Gets the index of the character returned by last call to next

	 * 

	 * @return the index

	 */

	public int currentIndex() {

		return currentIndex;

	}

	/**

	 * Gets the index that preceeded the latest call to next

	 * 

	 * @return the index

	 */

	public int previousIndex() {

		return previousIndex;

	}

	/**

	 * Gets the next character but does not move the iterator

	 * 

	 * @return the next character

	 * @throws SourceParserException

	 *             if there are no more characters

	 */

	public char peek() throws SourceParserException {

		return parser.getSource().getChar(nextIndex);

	}

	/**

	 * Determines if the iterator skipped over characters during last call to

	 * next

	 * 

	 * @return true if skipped, false otherwise

	 */

	public boolean hasSkipped() {

		return (flags & SourceParser.BACKWARD_SEARCH) == 0 ? currentIndex > previousIndex + 1

				: currentIndex < previousIndex - 1;

	}

	/**

	 * Checks if the next area is skipped

	 * 

	 * @return true is skipped

	 */

	private boolean isExcluded() {

		return isExcluded(nextExcludedAreaType);

	}

	/**

	 * Checks if the given type is skipped

	 * 

	 * @param type

	 *            the type

	 * @return true is skipped

	 */

	private boolean isExcluded(int type) {

		return SourceParser.isExcluded(type, flags);

	}

}