/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*

*/

package com.nokia.carbide.internal.cpp.epoc.engine.preprocessor;

import com.nokia.carbide.cpp.epoc.engine.model.IModelDocumentProvider;

import com.nokia.carbide.cpp.epoc.engine.preprocessor.IDefine;

import com.nokia.carbide.cpp.epoc.engine.preprocessor.IIncludeFileLocator;

import com.nokia.carbide.cpp.epoc.engine.preprocessor.ITranslationUnit;

import com.nokia.carbide.cpp.epoc.engine.preprocessor.ITranslationUnitProvider;

import com.nokia.carbide.cpp.epoc.engine.preprocessor.IViewFilter;

import com.nokia.carbide.internal.api.cpp.epoc.engine.dom.*;

import com.nokia.carbide.internal.api.cpp.epoc.engine.preprocessor.*;

import com.nokia.carbide.internal.cpp.epoc.engine.dom.ASTNode;

import com.nokia.carbide.internal.cpp.epoc.engine.dom.Token;

import com.nokia.carbide.internal.cpp.epoc.engine.parser.ASTParser;

import com.nokia.carbide.internal.cpp.epoc.engine.parser.ParserUtils;

import com.nokia.cpp.internal.api.utils.core.*;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.Path;

import java.io.File;

import java.util.*;

/**

 * This class expands a DOM in accordance with a configuration (a fixed set of

 * macros), evaluating preprocessor directives and expanding macro calls to

 * create a flattened DOM. The nodes in the flattened DOM maps back to nodes in

 * the original DOM and regions in that DOM defined by particular conditions

 * expressed in the preprocessor directives. Using this knowledge, changes to

 * the view can be applied to the appropriate regions in the original DOM, or

 * new regions can be created where the view's configuration differs from that

 * of the existing regions.

 * 

 */

public class ASTPreprocessor implements IPreprocessor, IMacroProvider {

	private static final int MAXIMUM_INCLUDE_STACK_SIZE = 256;

	Stack<IConditionalBlock> blockStack;

	Stack<Boolean> takenStack; // one per #if level

	IConditionalBlock parentBlock;

	IConditionalBlock targetBlock;

	private IViewFilter filter;

	private IPreprocessorFilter outFilter;

	enum IfState {

		IncludeToNext,

		SkipToNext,

		IncludeToEndif,

		SkipToEndif;

		/**

		 * @return

		 */

		public boolean isSkip() {

			return this == SkipToNext || this == SkipToEndif; // || this == SkipToEndifNoElse;

		}

	};

	Stack<IfState> ifStateStack; // one per #if level, but not current

	private IfState ifState;

	/** current combined state of conditionality for the whole taken stack */

	private boolean currentState;

	private IConditionalBlock rootBlock;

	private Stack<IASTPreprocessorTestStatement> ifStack;

	private HashMap<String, IASTPreprocessorDefineStatement> macros;

	private IIncludeFileLocator fileLocator;

	private ITranslationUnitProvider tuProvider;

	private TopLevelNodeProvider nodeIterator;

	private Set<File> referencedFiles;

	private IdentityHashMap<IASTNode, IConditionalBlock> nodeToBlockMap;

	private HashMap<IConditionalBlock, Integer> nodeToDepthMap;

	private Set<IASTNode> macroReferencingNodes;

	private Set<IASTNode> variantMacroReferencingNodes;

	private IASTTranslationUnit tu;

	protected Map<ISourceRegion, IASTTranslationUnit> includeToTranslationUnitMap;

	protected Map<File, IASTTranslationUnit> includeFileToTranslationUnitMap;

	private List<ISourceRegion> variantMacroExpansionRegions;

	private IModelDocumentProvider modelDocumentProvider;

	public ASTPreprocessor(ITranslationUnitProvider tuProvider, IIncludeFileLocator fileLocator,

			IModelDocumentProvider modelDocumentProvider) {

		Check.checkArg(tuProvider);

		Check.checkArg(fileLocator);

		Check.checkArg(modelDocumentProvider);

		this.tuProvider = tuProvider;

		this.fileLocator = fileLocator;

		this.modelDocumentProvider = modelDocumentProvider;

		this.referencedFiles = new HashSet<File>();

		this.includeToTranslationUnitMap = new HashMap<ISourceRegion, IASTTranslationUnit>();

		this.includeFileToTranslationUnitMap = new HashMap<File, IASTTranslationUnit>();

		this.outFilter = new DefaultPreprocessorFilter();

	}

	public IConditionalBlock getRootBlock() {

		return rootBlock;

	}

	class TopLevelNodeProvider implements Iterator<IASTTopLevelNode> {

		Stack<Iterator<IASTTopLevelNode>> pushedIterators;

		Iterator<IASTTopLevelNode> currentIter;

		private Stack<File> pushedFiles;

		public TopLevelNodeProvider() {

			pushedIterators = new Stack<Iterator<IASTTopLevelNode>>();

			pushedFiles = new Stack<File>();

		}

		/**

		 * Push the top-level nodes from the given translation unit into

		 * the stream before the node that would be returned by the last call to #next().

		 * @param tu

		 */

		public void pushTranslationUnit(File file, IASTTranslationUnit tu, IASTTopLevelNode node) {

			// watch for infinite #includes

			if (pushedFiles.size() >= MAXIMUM_INCLUDE_STACK_SIZE) {

				reportProblem(node, "ASTPreprocessor.IncludeNestingTooDeep", //$NON-NLS-1$

						new Object[] { file });

				return;

			}

			if (node != null) {

				// establish a mapping from the TU to its first #include

				if (tu.getSourceNodes() == null)

					tu.setSourceNodes(new IASTNode[] { node });

				includeToTranslationUnitMap.put(node.getSourceRegion(), tu);

				includeFileToTranslationUnitMap.put(file, tu);

			}

			pushedFiles.push(file);

			pushedIterators.push(tu.getNodes().iterator());

			currentIter = pushedIterators.peek();

			enteredTranslationUnit(tu);

		}

		/* (non-Javadoc)

		 * @see java.util.Iterator#hasNext()

		 */

		public boolean hasNext() {

			//if (currentIter.hasNext())

			//	return true;

			for (Iterator<IASTTopLevelNode> iter : pushedIterators)

				if (iter.hasNext())

					return true;

			return false;

		}

		/* (non-Javadoc)

		 * @see java.util.Iterator#next()

		 */

		public IASTTopLevelNode next() {

			while (true) {

				if (!currentIter.hasNext()) {

					popCurrentFile();

				}

				else

					return currentIter.next();

			}

		}

		/* (non-Javadoc)

		 * @see java.util.Iterator#remove()

		 */

		public void remove() {

			currentIter.remove();

		}

		public void dispose() {

			while (true) {

				try {

					popCurrentFile();

				} catch (NoSuchElementException e) {

					return;

				}

			}

		}

		/**

		 * 

		 */

		private void popCurrentFile() {

			pushedIterators.pop();

			exitedTranslationUnit();

			if (pushedIterators.size() > 0) {

				currentIter = pushedIterators.peek();

				pushedFiles.pop();

				if (outFilter != null) {

					IASTPreprocessorStatement stmt = outFilter.filterIncludeExit();

					if (stmt != null) {

						appendDirectiveNode(stmt);

					}

				}

			}

			else

				throw new NoSuchElementException();

		}

	}

	public void setFilter(IPreprocessorFilter filter) {

		this.outFilter = filter;

	}

	/**

	 * Preprocess the preprocessor TU and fill in the translation unit.

	 * @return

	 */

	public IPreprocessorResults preprocess(final IASTTranslationUnit ppTu, 

			IViewFilter viewFilter, Collection<IDefine> defines) {

		this.filter = viewFilter;

		this.tu = ASTFactory.createTranslationUnit();

		tu.getNodes().clear();

		macros = new HashMap<String, IASTPreprocessorDefineStatement>();

		for (IDefine macro : defines) {

			macros.put(macro.getName(), 

					ASTFactory.createPreprocessorDefineStatement(

							ASTFactory.createPreprocessorLiteralTextNode(macro.getName()),

							ASTFactory.createPreprocessorLiteralTextNodeList(macro.getArgumentNames()),

							ASTFactory.createPreprocessorTokenStream(macro.getExpansion())));

		}

		macroReferencingNodes = new HashSet<IASTNode>();

		variantMacroReferencingNodes = new HashSet<IASTNode>();

		variantMacroExpansionRegions = new ArrayList<ISourceRegion>();

		/** map of out nodes to regions */

		nodeToBlockMap = new IdentityHashMap<IASTNode, IConditionalBlock>();

		blockStack = new Stack<IConditionalBlock>();

		ifStack = new Stack<IASTPreprocessorTestStatement>();

		takenStack = new Stack<Boolean>();

		ifStateStack = new Stack<IfState>();

		parentBlock = null;

		targetBlock = null;

		currentState = true;

		ifState = null;

		//currentIfTaken = false;

		//evaluatingCurrent = true;

		nodeToDepthMap = new HashMap<IConditionalBlock, Integer>();

		nodeIterator = new TopLevelNodeProvider();

		nodeIterator.pushTranslationUnit(null, ppTu, null);

		IASTTopLevelNode lastPpNode = null;

		while (nodeIterator.hasNext()) {

			IASTTopLevelNode ppNode = nodeIterator.next();

			lastPpNode = ppNode;

			// test nodes modify the regions and rely on filtering

			if (ppNode instanceof IASTPreprocessorTestStatement) {

				IASTPreprocessorTestStatement test = (IASTPreprocessorTestStatement) ppNode;

				handleTestStatement(test, false);

				filterOrAppendDirective(test);

				continue;

			}

			// other directives should only be used if filtered in

			if (isIncludingNode()) {

				if (ppNode instanceof IASTPreprocessorDefineStatement) {

					IASTPreprocessorDefineStatement define = (IASTPreprocessorDefineStatement) ppNode;

					handleDefineStatement(define);

					filterOrAppendDirective(define);

					continue;

				} else if (ppNode instanceof IASTPreprocessorUndefStatement) {

					IASTPreprocessorUndefStatement undef = (IASTPreprocessorUndefStatement) ppNode;

					handleUndefStatement(undef);

					filterOrAppendDirective(undef);

					continue;

				} else if (ppNode instanceof IASTPreprocessorIncludeStatement) {

					IASTPreprocessorIncludeStatement include = (IASTPreprocessorIncludeStatement) ppNode;

					handleIncludeStatement(include);

					filterOrAppendDirective(include);

					continue;

				} else if (ppNode instanceof IASTPreprocessorErrorStatement

						|| ppNode instanceof IASTPreprocessorWarningStatement) {

					IASTPreprocessorStatement problem = (IASTPreprocessorStatement) ppNode;

					handleErrorOrWarningStatement(problem);

					filterOrAppendDirective(problem);

					continue;

				} else if (ppNode instanceof IASTPreprocessorPragmaStatement) {

					// ignore these

					filterOrAppendDirective((IASTPreprocessorPragmaStatement) ppNode);

					continue;

				} else if (ppNode instanceof IASTPreprocessorUnknownStatement) {

					// ignore these

					filterOrAppendDirective((IASTPreprocessorUnknownStatement) ppNode);

					continue;

				} else if (ppNode instanceof IASTPreprocessorIncludeStatement) {

					IASTPreprocessorIncludeStatement include = (IASTPreprocessorIncludeStatement) ppNode;

					handleIncludeStatement(include);

					filterOrAppendDirective(include);

					continue;

				}

			}

			// the rest are language nodes

			ensureTargetRegion();

			IASTTopLevelNode node = expandMacrosInStatement(ppNode);

			appendPreprocessedNode(ppNode, node);

		}

		if (ifStack.size() > 0) {

			reportProblem(lastPpNode, "ASTPreprocessor.UnbalancedIfsOnExit", //$NON-NLS-1$

						new Object[0]);

			// fixup dangling blocks so we can still commit

			while (ifStack.size() > 0) {

				IASTPreprocessorEndifStatement endifStmt = ASTFactory.createPreprocessorEndifStatement();

				endifStmt.copySourceInfo(lastPpNode);

				if (lastPpNode.getSourceRegion() != null) {

					endifStmt.setSourceRegion(lastPpNode.getSourceRegion().getExclusiveTailRegion());

				}

				handleTestStatement(endifStmt, true);

			}

		}

		// exhaust the node iterators so we know that all the TUs have closed 

		nodeIterator.dispose();

		Check.checkState(blockStack.size() == 0);

		Check.checkState(takenStack.size() == 0);

		// Ensure the TU incorporates all the source for the statements that

		// are filtered in.   

		ParserUtils.setSourceRangeForListNode(null, tu.getNodes(), null);

		tu.copySourceInfo(tu.getNodes());

		// If that fails, copy empty source range from main file

		if (tu.getSourceRegion() == null) {

			tu.getNodes().copySourceInfo(ppTu.getNodes());

			tu.copySourceInfo(ppTu);

		}

		tu.setMainDocument(ppTu.getMainDocument());

		tu.setMainLocation(ppTu.getMainLocation());

		tu.setSourceNodes(new IASTNode[] { ppTu });

		tu.setDirty(false);

		tu.getNodes().setDirty(false);

		return new IPreprocessorResults() {

			public IASTTranslationUnit getOriginalTranslationUnit() {

				return ppTu;

			}

			public IASTTranslationUnit getFilteredTranslationUnit() {

				return tu;

			}

			public Collection<File> getReferencedFiles() {

				return referencedFiles;

			}

			public IASTTranslationUnit getTranslationUnitFor(IASTPreprocessorIncludeStatement include) {

				return includeToTranslationUnitMap.get(include.getSourceRegion());

			}

			public IASTTranslationUnit getTranslationUnitFor(File file) {

				return includeFileToTranslationUnitMap.get(file);

			}

			public void replaceTranslationUnitFor(File file,

					IASTTranslationUnit tu) {

				IASTTranslationUnit previous = includeFileToTranslationUnitMap.put(file, tu);

				for (Map.Entry<ISourceRegion, IASTTranslationUnit> regionEntry : includeToTranslationUnitMap.entrySet()) {

					if (regionEntry.getValue() == previous) {

						regionEntry.setValue(tu);

					}

				}

			}

			public IConditionalBlock getRootBlock() {

				return rootBlock;

			}

			/**

			 * Tell whether the preprocessor node was expanded with variant macros.

			 * @param ppStmts

			 * @return

			 */

			public boolean nodesUseVariantMacros(IASTNode[] ppStmts) {

				for (IASTNode ppStmt : ppStmts) {

					if (variantMacroReferencingNodes.contains(ppStmt))

						return true;

				}

				return false;

			}

			/**

			 * Tell if the source range covered by the node references macros

			 * @param node

			 * @return

			 */

			public boolean nodeReferencesVariantMacros(IASTNode node) {

				ISourceRegion region = node.getSourceRegion();

				if (region == null)

					return false;

				for (ISourceRegion macroRegion : variantMacroExpansionRegions) {

					if (region.contains(macroRegion)) {

						return true;

					}

				}

				return false;

			}

			public boolean nodeContainsNonSpanningVariantMacros(IASTNode node) {

				ISourceRegion region = node.getSourceRegion();

				if (region == null)

					return false;

				for (ISourceRegion macroRegion : variantMacroExpansionRegions) {

					// first, see if the node has macro references embedded.

					if (region.contains(macroRegion)) {

						// if macro expands to exact content, fine

						//if (region.equals(macroRegion))

						//	return true;

						/*

						// now see if the macro does not span a child.

						boolean spansChild = false;

						for (IASTNode kid : node.getChildren()) {

							ISourceRegion kidRegion = kid.getSourceRegion();

							// look for kids that are not fully enclosed by the macro itself (meaning they were generated by it)

							if (kidRegion != null && macroRegion.equals(kidRegion)) {

								spansChild = true;

								break;

							}

						}*/

						// now see if the macro is not enclosed in a child.

						boolean enclosedInChild = false;

						for (IASTNode kid : node.getChildren()) {

							ISourceRegion kidRegion = kid.getSourceRegion();

							// look for kids that are not fully enclosed by the macro itself (meaning they were generated by it)

							if (kidRegion != null && region.contains(kidRegion)

									&& !region.getExclusiveHeadRegion().equals(kidRegion.getExclusiveHeadRegion())

									&& !region.getExclusiveTailRegion().equals(kidRegion.getExclusiveTailRegion())) {

								if (kidRegion.contains(macroRegion)) {

									enclosedInChild = true;

									break;

								}

							}

						}

						if (!enclosedInChild) {

							return true;

						}

						// keep searching (there may be several macro expansions at once) 

					}

					// TODO: stop searching eventually (need to order these regions somehow)

				}

				return false;

			}

			/**

			 * Turn off the macro-using flag for this line.

			 * @param node

			 */

			public void unsetNodeUsesMacros(IASTNode node) {

				macroReferencingNodes.remove(node);

				variantMacroReferencingNodes.remove(node);

			}

			/**

			 * @return the nodeToBlockMap

			 */

			public Map<IASTNode, IConditionalBlock> getNodeToBlockMap() {

				return nodeToBlockMap;

			}

		};

	}

	/**

	 * @param include

	 */

	private void filterOrAppendDirective(IASTPreprocessorStatement stmt) {

		stmt = outFilter.filterDirective(stmt);

		if (stmt != null) {

			appendDirectiveNode(stmt);

		}

	}

	protected void enteredTranslationUnit(IASTTranslationUnit ppTu) {

		IConditionalBlock block = new ConditionalBlock(ppTu.getSourceRegion());

		if (rootBlock == null)

			rootBlock = block;

		pushBlock(block);

	}

	protected void exitedTranslationUnit() {

		popBlock();

	}

	/**

	 * Add a node to the output.  The input may be null for new nodes

	 * (e.g. problems)

	 * @param ppNode original pre-parsed node, may be null

	 * @param node preprocessed node

	 */

	private void appendPreprocessedNode(IASTTopLevelNode ppNode, IASTTopLevelNode node) {

		if (ppNode != null)

			targetBlock.addNode(ppNode);

		if (isIncludingNode() || node instanceof IASTProblemNode) {

			tu.getNodes().add(node);