xlc/org.eclipse.cdt.make.xlc.core/src/org/eclipse/cdt/make/xlc/core/scannerconfig/XLCBuildOutputParserUtility.java - cdt/org.eclipse.cdt - Git at Google

 /*******************************************************************************
  * Copyright (c) 2004, 2016 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  * IBM - Initial API and implementation
  *******************************************************************************/
 package org.eclipse.cdt.make.xlc.core.scannerconfig;

 import java.io.File;
 import java.io.IOException;
 import java.net.URI;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Vector;

 import org.eclipse.cdt.core.IMarkerGenerator;
 import org.eclipse.cdt.core.ProblemMarkerInfo;
 import org.eclipse.cdt.make.core.MakeCorePlugin;
 import org.eclipse.cdt.make.internal.core.MakeMessages;
 import org.eclipse.cdt.make.internal.core.scannerconfig.util.CCommandDSC;
 import org.eclipse.cdt.make.internal.core.scannerconfig.util.KVStringPair;
 import org.eclipse.cdt.make.internal.core.scannerconfig.util.SCDOptionsEnum;
 import org.eclipse.cdt.make.internal.core.scannerconfig.util.TraceUtil;
 import org.eclipse.cdt.make.xlc.core.scannerconfig.util.XLCCommandDSC;
 import org.eclipse.cdt.utils.EFSExtensionManager;
 import org.eclipse.core.resources.IContainer;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.resources.IWorkspaceRoot;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.Path;

 /**
  * @author crecoskie
  *
  */
 public class XLCBuildOutputParserUtility {
 	protected class Problem {
 		protected String description;
 		protected IResource file;
 		protected int lineNumber;
 		protected int severity;
 		protected String variableName;

 		public Problem(IResource file, int lineNumber, String desciption, int severity, String variableName) {
 			this.file = file;
 			this.lineNumber = lineNumber;
 			this.description = desciption;
 			this.severity = severity;
 			this.variableName = variableName;
 		}
 	}

 	public static IPath convertCygpath(IPath path) {
 		if (path.segmentCount() > 1 && path.segment(0).equals("cygdrive")) { //$NON-NLS-1$
 			StringBuilder buf = new StringBuilder(2);
 			buf.append(Character.toUpperCase(path.segment(1).charAt(0)));
 			buf.append(':');
 			path = path.removeFirstSegments(2);
 			path = path.setDevice(buf.toString());
 			path = path.makeAbsolute();
 		}
 		return path;
 	}

 	private List commandsList2;
 	private int commandsN = 0;
 	private List compiledFileList;

 	private Map directoryCommandListMap;

 	private IPath fBaseDirectory;
 	private String fDefaultMacroDefinitionValue = "1"; //$NON-NLS-1$
 	private Vector<IPath> fDirectoryStack;
 	private ArrayList<Problem> fErrors;
 	private int filesN = 0;

 	private IMarkerGenerator fMarkerGenerator;

 	private IProject project;

 	private int workingDirsN = 0;

 	/*
 	 * For tracking the location of files being compiled
 	 */
 	private Map<String, IFile> fFilesInProject;
 	private List<String> fCollectedFiles;
 	private List<String> fNameConflicts;

 	protected XLCBuildOutputParserUtility(IPath baseDirectory, IPath workingDirectory) {
 		fDirectoryStack = new Vector<>();
 		fErrors = new ArrayList<>();
 		this.fBaseDirectory = baseDirectory;
 		if (workingDirectory != null) {
 			pushDirectory(workingDirectory);
 		}

 	}

 	/**
 	 *
 	 */
 	public XLCBuildOutputParserUtility(IProject project, IPath workingDirectory, IMarkerGenerator markerGenerator) {
 		fDirectoryStack = new Vector<>();
 		fErrors = new ArrayList<>();
 		this.project = project;
 		fBaseDirectory = getPathForResource(project);
 		if (workingDirectory != null) {
 			pushDirectory(workingDirectory);
 		}
 	}

 	private IPath getPathForResource(IResource resource) {
 		// TODO: when the file system utility stuff is in, this will have to call it to get the path
 		// for now, get the path from the URI
 		URI locationURI = resource.getLocationURI();
 		IPath path = new Path(locationURI.getPath());
 		return path;
 	}

 	/**
 	 * Adds a mapping filename, generic_command
 	 * @param longFileName
 	 * @param genericLine
 	 */
 	void addGenericCommandForFile(String longFileName, String genericCommand) {
 		// if a file name has already been added once, return
 		if (compiledFileList.contains(longFileName))
 			return;
 		compiledFileList.add(longFileName);

 		String workingDir = getWorkingDirectory().toString();
 		List directoryCommandList = (List) directoryCommandListMap.get(workingDir);
 		if (directoryCommandList == null) {
 			directoryCommandList = new ArrayList();
 			directoryCommandListMap.put(workingDir, directoryCommandList);
 			++workingDirsN;
 		}
 		Map command21FileListMap = null;
 		for (Iterator i = directoryCommandList.iterator(); i.hasNext();) {
 			command21FileListMap = (Map) i.next();
 			List fileList = (List) command21FileListMap.get(genericCommand);
 			if (fileList != null) {
 				if (!fileList.contains(longFileName)) {
 					fileList.add(longFileName);
 					++filesN;
 				}
 				return;
 			}
 		}
 		command21FileListMap = new HashMap(1);
 		directoryCommandList.add(command21FileListMap);
 		++commandsN;
 		List fileList = new ArrayList();
 		command21FileListMap.put(genericCommand, fileList);
 		fileList.add(longFileName);
 		++filesN;
 	}

 	/**
 	 * Adds a mapping command line -> file, this time without a dir
 	 * @param longFileName
 	 * @param genericLine
 	 */
 	void addGenericCommandForFile2(String longFileName, String genericLine) {
 		// if a file name has already been added once, return
 		if (compiledFileList.contains(longFileName))
 			return;
 		compiledFileList.add(longFileName);

 		String[] tokens = genericLine.split("\\s+"); //$NON-NLS-1$
 		CCommandDSC command = getNewCCommandDSC(tokens, 0, false); // assume .c file type
 		int index = commandsList2.indexOf(command);
 		if (index == -1) {
 			commandsList2.add(command);
 			++commandsN;
 		} else {
 			command = (CCommandDSC) commandsList2.get(index);
 		}
 		//        // add a file
 		//        command.addFile(longFileName);
 		//        ++filesN;
 	}

 	public void changeMakeDirectory(String dir, int dirLevel, boolean enterDir) {
 		if (enterDir) {
 			/* Sometimes make screws up the output, so
 			 * "leave" events can't be seen.  Double-check level
 			 * here.
 			 */
 			for (int parseLevel = getDirectoryLevel(); dirLevel < parseLevel; parseLevel = getDirectoryLevel()) {
 				popDirectory();
 			}
 			pushDirectory(new Path(dir));
 		} else {
 			popDirectory();
 			/* Could check to see if they match */
 		}
 	}

 	/**
 	 * Called by the console line parsers to generate a problem marker.
 	 */
 	public void generateMarker(IResource file, int lineNumber, String desc, int severity, String varName) {
 		// No need to collect markers if marker generator is not present
 		if (fMarkerGenerator != null) {
 			Problem problem = new Problem(file, lineNumber, desc, severity, varName);
 			fErrors.add(problem);
 		}
 	}

 	/**
 	 *
 	 */
 	void generateReport() {
 		TraceUtil.metricsTrace("Stats for directory ", //$NON-NLS-1$
 				"Generic command: '", "' applicable for:", //$NON-NLS-1$ //$NON-NLS-2$
 				directoryCommandListMap);
 		TraceUtil.summaryTrace("Discovery summary", workingDirsN, commandsN, filesN); //$NON-NLS-1$
 	}

 	/**
 	 * @param filePath : String
 	 * @return filePath : IPath - not <code>null</code>
 	 */
 	public IPath getAbsolutePath(String filePath) {
 		IPath pFilePath;
 		if (filePath.startsWith("/")) { //$NON-NLS-1$
 			return convertCygpath(new Path(filePath));
 		} else if (filePath.startsWith("\\") || //$NON-NLS-1$
 				(!filePath.startsWith(".") && //$NON-NLS-1$
 						filePath.length() > 2 && filePath.charAt(1) == ':'
 						&& (filePath.charAt(2) == '\\' || filePath.charAt(2) == '/'))) {
 			// absolute path
 			pFilePath = new Path(filePath);
 		} else {
 			// relative path
 			IPath cwd = getWorkingDirectory();
 			if (!cwd.isAbsolute()) {
 				cwd = getBaseDirectory().append(cwd);
 			}
 			if (filePath.startsWith("`pwd`")) { //$NON-NLS-1$
 				if (filePath.length() > 5 && (filePath.charAt(5) == '/' || filePath.charAt(5) == '\\')) {
 					filePath = filePath.substring(6);
 				} else {
 					filePath = filePath.substring(5);
 				}
 			}
 			pFilePath = cwd.append(filePath);
 		}
 		return pFilePath;
 	}

 	/**
 	 * @return Returns the fBaseDirectory.
 	 */
 	public IPath getBaseDirectory() {
 		return fBaseDirectory;
 	}

 	/**
 	 * Returns all CCommandDSC collected so far.
 	 * Currently this list is not filled, so it will always return an empty list.
 	 * @return List of CCommandDSC
 	 */
 	public List getCCommandDSCList() {
 		return new ArrayList(commandsList2);
 	}

 	protected int getDirectoryLevel() {
 		return fDirectoryStack.size();
 	}

 	/**
 	 * @return Returns the fDirectoryStack.
 	 */
 	protected Vector<IPath> getDirectoryStack() {
 		return fDirectoryStack;
 	}

 	/**
 	 * @return Returns the fErrors.
 	 */
 	protected ArrayList<Problem> getErrors() {
 		return fErrors;
 	}

 	/**
 	 * @return Returns the fMarkerGenerator.
 	 */
 	protected IMarkerGenerator getMarkerGenerator() {
 		return fMarkerGenerator;
 	}

 	/**
 	 * @param genericLine
 	 * @param cppFileType
 	 * @return CCommandDSC compile command description
 	 */
 	public CCommandDSC getNewCCommandDSC(String[] tokens, final int idxOfCompilerCommand, boolean cppFileType) {
 		ArrayList dirafter = new ArrayList();
 		ArrayList includes = new ArrayList();
 		XLCCommandDSC command = new XLCCommandDSC(cppFileType, getProject());
 		command.addSCOption(new KVStringPair(SCDOptionsEnum.COMMAND.toString(), tokens[idxOfCompilerCommand]));
 		for (int i = idxOfCompilerCommand + 1; i < tokens.length; ++i) {
 			String token = tokens[i];
 			//Target specific options: see GccScannerInfoConsoleParser
 			if (token.startsWith("-m") || //$NON-NLS-1$
 					token.equals("-ansi") || //$NON-NLS-1$
 					token.equals("-posix") || //$NON-NLS-1$
 					token.equals("-pthread") || //$NON-NLS-1$
 					token.startsWith("-O") || //$NON-NLS-1$
 					token.equals("-fno-inline") || //$NON-NLS-1$
 					token.startsWith("-finline") || //$NON-NLS-1$
 					token.equals("-fno-exceptions") || //$NON-NLS-1$
 					token.equals("-fexceptions") || //$NON-NLS-1$
 					token.equals("-fshort-wchar") || //$NON-NLS-1$
 					token.equals("-fshort-double") || //$NON-NLS-1$
 					token.equals("-fno-signed-char") || //$NON-NLS-1$
 					token.equals("-fsigned-char") || //$NON-NLS-1$
 					token.startsWith("-fabi-version=") //$NON-NLS-1$
 			) {
 				command.addSCOption(new KVStringPair(SCDOptionsEnum.COMMAND.toString(), token));
 				continue;
 			}
 			for (int j = SCDOptionsEnum.MIN; j <= SCDOptionsEnum.MAX; ++j) {
 				final SCDOptionsEnum optionKind = SCDOptionsEnum.getSCDOptionsEnum(j);
 				if (token.startsWith(optionKind.toString())) {
 					String option = token.substring(optionKind.toString().length()).trim();
 					if (option.length() > 0) {
 						// ex. -I/dir
 					} else if (optionKind.equals(SCDOptionsEnum.IDASH)) {
 						for (Iterator iter = includes.iterator(); iter.hasNext();) {
 							option = (String) iter.next();
 							KVStringPair pair = new KVStringPair(SCDOptionsEnum.IQUOTE.toString(), option);
 							command.addSCOption(pair);
 						}
 						includes = new ArrayList();
 						// -I- has no parameter
 					} else {
 						// ex. -I /dir
 						// take a next token
 						if (i + 1 < tokens.length && !tokens[i + 1].startsWith("-")) { //$NON-NLS-1$
 							option = tokens[++i];
 						} else
 							break;
 					}

 					if (option.length() > 0 && (optionKind.equals(SCDOptionsEnum.INCLUDE)
 							|| optionKind.equals(SCDOptionsEnum.INCLUDE_FILE)
 							|| optionKind.equals(SCDOptionsEnum.IMACROS_FILE)
 							|| optionKind.equals(SCDOptionsEnum.IDIRAFTER) || optionKind.equals(SCDOptionsEnum.ISYSTEM)
 							|| optionKind.equals(SCDOptionsEnum.IQUOTE))) {
 						option = (getAbsolutePath(option)).toString();
 					}

 					if (optionKind.equals(SCDOptionsEnum.IDIRAFTER)) {
 						KVStringPair pair = new KVStringPair(SCDOptionsEnum.INCLUDE.toString(), option);
 						dirafter.add(pair);
 					} else if (optionKind.equals(SCDOptionsEnum.INCLUDE)) {
 						includes.add(option);
 					} else { // add the pair
 						if (optionKind.equals(SCDOptionsEnum.DEFINE)) {
 							if (option.indexOf('=') == -1) {
 								option += '=' + fDefaultMacroDefinitionValue;
 							}
 						}
 						KVStringPair pair = new KVStringPair(optionKind.toString(), option);
 						command.addSCOption(pair);
 					}
 					break;
 				}
 			}
 		}
 		String option;
 		for (Iterator iter = includes.iterator(); iter.hasNext();) {
 			option = (String) iter.next();
 			KVStringPair pair = new KVStringPair(SCDOptionsEnum.INCLUDE.toString(), option);
 			command.addSCOption(pair);
 		}
 		for (Iterator iter = dirafter.iterator(); iter.hasNext();) {
 			command.addSCOption((KVStringPair) iter.next());
 		}
 		return command;
 	}

 	/**
 	 * @return Returns the project.
 	 */
 	protected IProject getProject() {
 		return project;
 	}

 	public IPath getWorkingDirectory() {
 		if (fDirectoryStack.size() != 0) {
 			return fDirectoryStack.lastElement();
 		}
 		// Fallback to the Project Location
 		// FIXME: if the build did not start in the Project ?
 		return fBaseDirectory;
 	}

 	protected IPath popDirectory() {
 		int i = getDirectoryLevel();
 		if (i != 0) {
 			IPath dir = fDirectoryStack.lastElement();
 			fDirectoryStack.removeElementAt(i - 1);
 			return dir;
 		}
 		return new Path(""); //$NON-NLS-1$
 	}

 	protected void pushDirectory(IPath dir) {
 		if (dir != null) {
 			IPath pwd = null;
 			if (fBaseDirectory != null && fBaseDirectory.isPrefixOf(dir)) {
 				pwd = dir.removeFirstSegments(fBaseDirectory.segmentCount());
 			} else {
 				// check if it is a cygpath
 				pwd = convertCygpath(dir);
 			}
 			fDirectoryStack.addElement(pwd);
 		}
 	}

 	public boolean reportProblems() {
 		boolean reset = false;
 		for (Iterator<Problem> iter = fErrors.iterator(); iter.hasNext();) {
 			Problem problem = iter.next();
 			if (problem.severity == IMarkerGenerator.SEVERITY_ERROR_BUILD) {
 				reset = true;
 			}
 			if (problem.file == null) {
 				fMarkerGenerator.addMarker(new ProblemMarkerInfo(project, problem.lineNumber, problem.description,
 						problem.severity, problem.variableName));
 			} else {
 				fMarkerGenerator.addMarker(new ProblemMarkerInfo(problem.file, problem.lineNumber, problem.description,
 						problem.severity, problem.variableName));
 			}
 		}
 		fErrors.clear();
 		return reset;
 	}

 	public void setDefaultMacroDefinitionValue(String val) {
 		if (val != null) {
 			fDefaultMacroDefinitionValue = val;
 		}
 	}

 	public String getDefaultMacroDefinitionValue() {
 		return fDefaultMacroDefinitionValue;
 	}

 	public String normalizePath(String path) {
 		int column = path.indexOf(':');
 		if (column > 0) {
 			char driveLetter = path.charAt(column - 1);
 			if (Character.isLowerCase(driveLetter)) {
 				StringBuilder sb = new StringBuilder();
 				if (column - 1 > 0) {
 					sb.append(path.substring(0, column - 1));
 				}
 				sb.append(Character.toUpperCase(driveLetter));
 				sb.append(path.substring(column));
 				path = sb.toString();
 			}
 		}
 		if (path.indexOf('.') == -1 || path.equals(".")) { //$NON-NLS-1$
 			return (new Path(path)).toString(); // convert separators to '/'
 		}
 		// lose "./" segments since they confuse the Path normalization
 		StringBuilder buf = new StringBuilder(path);
 		int len = buf.length();
 		StringBuilder newBuf = new StringBuilder(buf.length());
 		int scp = 0; // starting copy point
 		int ssp = 0; // starting search point
 		int sdot;
 		boolean validPrefix;
 		while (ssp < len && (sdot = buf.indexOf(".", ssp)) != -1) { //$NON-NLS-1$
 			validPrefix = false;
 			int ddot = buf.indexOf("..", ssp);//$NON-NLS-1$
 			if (sdot < ddot || ddot == -1) {
 				newBuf.append(buf.substring(scp, sdot));
 				scp = sdot;
 				ssp = sdot + 1;
 				if (ssp < len) {
 					if (sdot == 0 || buf.charAt(sdot - 1) == '/' || buf.charAt(sdot - 1) == '\\') {
 						validPrefix = true;
 					}
 					char nextChar = buf.charAt(ssp);
 					if (validPrefix && nextChar == '/') {
 						++ssp;
 						scp = ssp;
 					} else if (validPrefix && nextChar == '\\') {
 						++ssp;
 						if (ssp < len - 1 && buf.charAt(ssp) == '\\') {
 							++ssp;
 						}
 						scp = ssp;
 					} else {
 						// no path delimiter, must be '.' inside the path
 						scp = ssp - 1;
 					}
 				}
 			} else if (sdot == ddot) {
 				ssp = sdot + 2;
 			}
 		}
 		newBuf.append(buf.substring(scp, len));

 		IPath orgPath = new Path(newBuf.toString());
 		return orgPath.toString();
 	}

 	/**
 	 * Called by the console line parsers to find a file with a given name.
 	 * @param fileName
 	 * @return IFile or null
 	 */
 	public IFile findFile(String fileName) {
 		IFile file = findFilePath(fileName);
 		if (file == null) {
 			// Try the project's map.
 			file = findFileName(fileName);
 			if (file != null) {
 				// If there is a conflict then try all files in the project.
 				if (isConflictingName(fileName)) {
 					file = null;

 					// Create a problem marker
 					final String error = MakeMessages.getString("ConsoleParser.Ambiguous_Filepath_Error_Message"); //$NON-NLS-1$
 					TraceUtil.outputError(error, fileName);
 					generateMarker(getProject(), -1, error + fileName, IMarkerGenerator.SEVERITY_WARNING, null);
 				}
 			}
 		}
 		return file;
 	}

 	/**
 	 * @param filePath
 	 * @return
 	 */
 	protected IFile findFilePath(String filePath) {
 		IPath path = null;
 		IPath fp = new Path(filePath);
 		if (fp.isAbsolute()) {
 			if (getBaseDirectory().isPrefixOf(fp)) {
 				int segments = getBaseDirectory().matchingFirstSegments(fp);
 				path = fp.removeFirstSegments(segments);
 			} else {
 				path = fp;
 			}
 		} else {
 			path = getWorkingDirectory().append(filePath);
 		}

 		IFile file = null;
 		// The workspace may throw an IllegalArgumentException
 		// Catch it and the parser should fallback to scan the entire project.
 		try {
 			file = findFileInWorkspace(path);
 		} catch (Exception e) {
 		}

 		// We have to do another try, on Windows for cases like "TEST.C" vs "test.c"
 		// We use the java.io.File canonical path.
 		if (file == null || !file.exists()) {
 			File f = path.toFile();
 			try {
 				String canon = f.getCanonicalPath();
 				path = new Path(canon);
 				file = findFileInWorkspace(path);
 			} catch (IOException e1) {
 			}
 		}
 		return (file != null && file.exists()) ? file : null;
 	}

 	/**
 	 * @param fileName
 	 * @return
 	 */
 	protected IFile findFileName(String fileName) {
 		IPath path = new Path(fileName);
 		return fFilesInProject.get(path.lastSegment());
 	}

 	protected IFile findFileInWorkspace(IPath path) {
 		IFile file = null;
 		if (path.isAbsolute()) {
 			IWorkspaceRoot root = getProject().getWorkspace().getRoot();

 			// construct a URI, based on the project's locationURI, that points
 			// to the given path
 			URI projectURI = project.getLocationURI();

 			URI newURI = EFSExtensionManager.getDefault().createNewURIFromPath(projectURI, path.toString());

 			IFile[] files = root.findFilesForLocationURI(newURI);

 			for (int i = 0; i < files.length; i++) {
 				if (files[i].getProject().equals(getProject())) {
 					file = files[i];
 					break;
 				}
 			}

 		} else {
 			file = getProject().getFile(path);
 		}
 		return file;
 	}

 	protected void collectFiles(IContainer parent, List result) {
 		try {
 			IResource[] resources = parent.members();
 			for (int i = 0; i < resources.length; i++) {
 				IResource resource = resources[i];
 				if (resource instanceof IFile) {
 					result.add(resource);
 				} else if (resource instanceof IContainer) {
 					collectFiles((IContainer) resource, result);
 				}
 			}
 		} catch (CoreException e) {
 			MakeCorePlugin.log(e.getStatus());
 		}
 	}

 	protected boolean isConflictingName(String fileName) {
 		IPath path = new Path(fileName);
 		return fNameConflicts.contains(path.lastSegment());
 	}

 	public List translateRelativePaths(IFile file, String fileName, List includes) {
 		List translatedIncludes = new ArrayList(includes.size());
 		for (Iterator i = includes.iterator(); i.hasNext();) {
 			String include = (String) i.next();
 			IPath includePath = new Path(include);
 			if (!includePath.isAbsolute() && !includePath.isUNC()) { // do not translate UNC paths
 				// First try the current working directory
 				IPath cwd = getWorkingDirectory();
 				if (!cwd.isAbsolute()) {
 					cwd = getBaseDirectory().append(cwd);
 				}

 				IPath filePath = new Path(fileName);
 				if (!filePath.isAbsolute()) {
 					// check if the cwd is the right one
 					// appending fileName to cwd should yield file path
 					filePath = cwd.append(fileName);
 				}
 				if (!filePath.toString().equalsIgnoreCase(file.getLocation().toString())) {
 					// must be the cwd is wrong
 					// check if file name starts with ".."
 					if (fileName.startsWith("..")) { //$NON-NLS-1$
 						// probably multiple choices for cwd, hopeless
 						final String error = MakeMessages.getString("ConsoleParser.Working_Directory_Error_Message"); //$NON-NLS-1$
 						TraceUtil.outputError(error, fileName);
 						generateMarker(file, -1, error, IMarkerGenerator.SEVERITY_WARNING, fileName);
 						break;
 					} else {
 						// remove common segments at the end
 						IPath tPath = new Path(fileName);
 						if (fileName.startsWith(".")) { //$NON-NLS-1$
 							tPath = tPath.removeFirstSegments(1);
 						}
 						// get the file path from the file
 						filePath = file.getLocation();
 						IPath lastFileSegment = filePath
 								.removeFirstSegments(filePath.segmentCount() - tPath.segmentCount());
 						if (lastFileSegment.matchingFirstSegments(tPath) == tPath.segmentCount()) {
 							cwd = filePath.removeLastSegments(tPath.segmentCount());
 						}
 					}
 				}

 				IPath candidatePath = cwd.append(includePath);
 				File dir = candidatePath.toFile();
 				include = candidatePath.toString();
 				if (!dir.exists()) {
 					final String error = MakeMessages.getString("ConsoleParser.Nonexistent_Include_Path_Error_Message"); //$NON-NLS-1$
 					TraceUtil.outputError(error, include);
 					//					generateMarker(file, -1, error+include, IMarkerGenerator.SEVERITY_WARNING, fileName);
 				}
 			}
 			// TODO VMIR for now add unresolved paths as well
 			translatedIncludes.add(include);
 		}
 		return translatedIncludes;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2004, 2016 IBM Corporation and others.
	*
	* This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License 2.0
	* which accompanies this distribution, and is available at
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	* Contributors:
	* IBM - Initial API and implementation
	*******************************************************************************/
	package org.eclipse.cdt.make.xlc.core.scannerconfig;

	import java.io.File;
	import java.io.IOException;
	import java.net.URI;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;
	import java.util.Vector;

	import org.eclipse.cdt.core.IMarkerGenerator;
	import org.eclipse.cdt.core.ProblemMarkerInfo;
	import org.eclipse.cdt.make.core.MakeCorePlugin;
	import org.eclipse.cdt.make.internal.core.MakeMessages;
	import org.eclipse.cdt.make.internal.core.scannerconfig.util.CCommandDSC;
	import org.eclipse.cdt.make.internal.core.scannerconfig.util.KVStringPair;
	import org.eclipse.cdt.make.internal.core.scannerconfig.util.SCDOptionsEnum;
	import org.eclipse.cdt.make.internal.core.scannerconfig.util.TraceUtil;
	import org.eclipse.cdt.make.xlc.core.scannerconfig.util.XLCCommandDSC;
	import org.eclipse.cdt.utils.EFSExtensionManager;
	import org.eclipse.core.resources.IContainer;
	import org.eclipse.core.resources.IFile;
	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.resources.IWorkspaceRoot;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IPath;
	import org.eclipse.core.runtime.Path;

	/**
	* @author crecoskie
	*
	*/
	public class XLCBuildOutputParserUtility {
	protected class Problem {
	protected String description;
	protected IResource file;
	protected int lineNumber;
	protected int severity;
	protected String variableName;

	public Problem(IResource file, int lineNumber, String desciption, int severity, String variableName) {
	this.file = file;
	this.lineNumber = lineNumber;
	this.description = desciption;
	this.severity = severity;
	this.variableName = variableName;
	}
	}

	public static IPath convertCygpath(IPath path) {
	if (path.segmentCount() > 1 && path.segment(0).equals("cygdrive")) { //$NON-NLS-1$
	StringBuilder buf = new StringBuilder(2);
	buf.append(Character.toUpperCase(path.segment(1).charAt(0)));
	buf.append(':');
	path = path.removeFirstSegments(2);
	path = path.setDevice(buf.toString());
	path = path.makeAbsolute();
	}
	return path;
	}

	private List commandsList2;
	private int commandsN = 0;
	private List compiledFileList;

	private Map directoryCommandListMap;

	private IPath fBaseDirectory;
	private String fDefaultMacroDefinitionValue = "1"; //$NON-NLS-1$
	private Vector<IPath> fDirectoryStack;
	private ArrayList<Problem> fErrors;
	private int filesN = 0;

	private IMarkerGenerator fMarkerGenerator;

	private IProject project;

	private int workingDirsN = 0;

	/*
	* For tracking the location of files being compiled
	*/
	private Map<String, IFile> fFilesInProject;
	private List<String> fCollectedFiles;
	private List<String> fNameConflicts;

	protected XLCBuildOutputParserUtility(IPath baseDirectory, IPath workingDirectory) {
	fDirectoryStack = new Vector<>();
	fErrors = new ArrayList<>();
	this.fBaseDirectory = baseDirectory;
	if (workingDirectory != null) {
	pushDirectory(workingDirectory);
	}

	}

	/**
	*
	*/
	public XLCBuildOutputParserUtility(IProject project, IPath workingDirectory, IMarkerGenerator markerGenerator) {
	fDirectoryStack = new Vector<>();
	fErrors = new ArrayList<>();
	this.project = project;
	fBaseDirectory = getPathForResource(project);
	if (workingDirectory != null) {
	pushDirectory(workingDirectory);
	}
	}

	private IPath getPathForResource(IResource resource) {
	// TODO: when the file system utility stuff is in, this will have to call it to get the path
	// for now, get the path from the URI
	URI locationURI = resource.getLocationURI();
	IPath path = new Path(locationURI.getPath());
	return path;
	}

	/**
	* Adds a mapping filename, generic_command
	* @param longFileName
	* @param genericLine
	*/
	void addGenericCommandForFile(String longFileName, String genericCommand) {
	// if a file name has already been added once, return
	if (compiledFileList.contains(longFileName))
	return;
	compiledFileList.add(longFileName);

	String workingDir = getWorkingDirectory().toString();
	List directoryCommandList = (List) directoryCommandListMap.get(workingDir);
	if (directoryCommandList == null) {
	directoryCommandList = new ArrayList();
	directoryCommandListMap.put(workingDir, directoryCommandList);
	++workingDirsN;
	}
	Map command21FileListMap = null;
	for (Iterator i = directoryCommandList.iterator(); i.hasNext();) {
	command21FileListMap = (Map) i.next();
	List fileList = (List) command21FileListMap.get(genericCommand);
	if (fileList != null) {
	if (!fileList.contains(longFileName)) {
	fileList.add(longFileName);
	++filesN;
	}
	return;
	}
	}
	command21FileListMap = new HashMap(1);
	directoryCommandList.add(command21FileListMap);
	++commandsN;
	List fileList = new ArrayList();
	command21FileListMap.put(genericCommand, fileList);
	fileList.add(longFileName);
	++filesN;
	}

	/**
	* Adds a mapping command line -> file, this time without a dir
	* @param longFileName
	* @param genericLine
	*/
	void addGenericCommandForFile2(String longFileName, String genericLine) {
	// if a file name has already been added once, return
	if (compiledFileList.contains(longFileName))
	return;
	compiledFileList.add(longFileName);

	String[] tokens = genericLine.split("\\s+"); //$NON-NLS-1$
	CCommandDSC command = getNewCCommandDSC(tokens, 0, false); // assume .c file type
	int index = commandsList2.indexOf(command);
	if (index == -1) {
	commandsList2.add(command);
	++commandsN;
	} else {
	command = (CCommandDSC) commandsList2.get(index);
	}
	// // add a file
	// command.addFile(longFileName);
	// ++filesN;
	}

	public void changeMakeDirectory(String dir, int dirLevel, boolean enterDir) {
	if (enterDir) {
	/* Sometimes make screws up the output, so
	* "leave" events can't be seen. Double-check level
	* here.
	*/
	for (int parseLevel = getDirectoryLevel(); dirLevel < parseLevel; parseLevel = getDirectoryLevel()) {
	popDirectory();
	}
	pushDirectory(new Path(dir));
	} else {
	popDirectory();
	/* Could check to see if they match */
	}
	}

	/**
	* Called by the console line parsers to generate a problem marker.
	*/
	public void generateMarker(IResource file, int lineNumber, String desc, int severity, String varName) {
	// No need to collect markers if marker generator is not present
	if (fMarkerGenerator != null) {
	Problem problem = new Problem(file, lineNumber, desc, severity, varName);
	fErrors.add(problem);
	}
	}

	/**
	*
	*/
	void generateReport() {
	TraceUtil.metricsTrace("Stats for directory ", //$NON-NLS-1$
	"Generic command: '", "' applicable for:", //$NON-NLS-1$ //$NON-NLS-2$
	directoryCommandListMap);
	TraceUtil.summaryTrace("Discovery summary", workingDirsN, commandsN, filesN); //$NON-NLS-1$
	}

	/**
	* @param filePath : String
	* @return filePath : IPath - not <code>null</code>
	*/
	public IPath getAbsolutePath(String filePath) {
	IPath pFilePath;
	if (filePath.startsWith("/")) { //$NON-NLS-1$
	return convertCygpath(new Path(filePath));
	} else if (filePath.startsWith("\\") \|\| //$NON-NLS-1$
	(!filePath.startsWith(".") && //$NON-NLS-1$
	filePath.length() > 2 && filePath.charAt(1) == ':'
	&& (filePath.charAt(2) == '\\' \|\| filePath.charAt(2) == '/'))) {
	// absolute path
	pFilePath = new Path(filePath);
	} else {
	// relative path
	IPath cwd = getWorkingDirectory();
	if (!cwd.isAbsolute()) {
	cwd = getBaseDirectory().append(cwd);
	}
	if (filePath.startsWith("`pwd`")) { //$NON-NLS-1$
	if (filePath.length() > 5 && (filePath.charAt(5) == '/' \|\| filePath.charAt(5) == '\\')) {
	filePath = filePath.substring(6);
	} else {
	filePath = filePath.substring(5);
	}
	}
	pFilePath = cwd.append(filePath);
	}
	return pFilePath;
	}

	/**
	* @return Returns the fBaseDirectory.
	*/
	public IPath getBaseDirectory() {
	return fBaseDirectory;
	}

	/**
	* Returns all CCommandDSC collected so far.
	* Currently this list is not filled, so it will always return an empty list.
	* @return List of CCommandDSC
	*/
	public List getCCommandDSCList() {
	return new ArrayList(commandsList2);
	}

	protected int getDirectoryLevel() {
	return fDirectoryStack.size();
	}

	/**
	* @return Returns the fDirectoryStack.
	*/
	protected Vector<IPath> getDirectoryStack() {
	return fDirectoryStack;
	}

	/**
	* @return Returns the fErrors.
	*/
	protected ArrayList<Problem> getErrors() {
	return fErrors;
	}

	/**
	* @return Returns the fMarkerGenerator.
	*/
	protected IMarkerGenerator getMarkerGenerator() {
	return fMarkerGenerator;
	}

	/**
	* @param genericLine
	* @param cppFileType
	* @return CCommandDSC compile command description
	*/
	public CCommandDSC getNewCCommandDSC(String[] tokens, final int idxOfCompilerCommand, boolean cppFileType) {
	ArrayList dirafter = new ArrayList();
	ArrayList includes = new ArrayList();
	XLCCommandDSC command = new XLCCommandDSC(cppFileType, getProject());
	command.addSCOption(new KVStringPair(SCDOptionsEnum.COMMAND.toString(), tokens[idxOfCompilerCommand]));
	for (int i = idxOfCompilerCommand + 1; i < tokens.length; ++i) {
	String token = tokens[i];
	//Target specific options: see GccScannerInfoConsoleParser
	if (token.startsWith("-m") \|\| //$NON-NLS-1$
	token.equals("-ansi") \|\| //$NON-NLS-1$
	token.equals("-posix") \|\| //$NON-NLS-1$
	token.equals("-pthread") \|\| //$NON-NLS-1$
	token.startsWith("-O") \|\| //$NON-NLS-1$
	token.equals("-fno-inline") \|\| //$NON-NLS-1$
	token.startsWith("-finline") \|\| //$NON-NLS-1$
	token.equals("-fno-exceptions") \|\| //$NON-NLS-1$
	token.equals("-fexceptions") \|\| //$NON-NLS-1$
	token.equals("-fshort-wchar") \|\| //$NON-NLS-1$
	token.equals("-fshort-double") \|\| //$NON-NLS-1$
	token.equals("-fno-signed-char") \|\| //$NON-NLS-1$
	token.equals("-fsigned-char") \|\| //$NON-NLS-1$
	token.startsWith("-fabi-version=") //$NON-NLS-1$
	) {
	command.addSCOption(new KVStringPair(SCDOptionsEnum.COMMAND.toString(), token));
	continue;
	}
	for (int j = SCDOptionsEnum.MIN; j <= SCDOptionsEnum.MAX; ++j) {
	final SCDOptionsEnum optionKind = SCDOptionsEnum.getSCDOptionsEnum(j);
	if (token.startsWith(optionKind.toString())) {
	String option = token.substring(optionKind.toString().length()).trim();
	if (option.length() > 0) {
	// ex. -I/dir
	} else if (optionKind.equals(SCDOptionsEnum.IDASH)) {
	for (Iterator iter = includes.iterator(); iter.hasNext();) {
	option = (String) iter.next();
	KVStringPair pair = new KVStringPair(SCDOptionsEnum.IQUOTE.toString(), option);
	command.addSCOption(pair);
	}
	includes = new ArrayList();
	// -I- has no parameter
	} else {
	// ex. -I /dir
	// take a next token
	if (i + 1 < tokens.length && !tokens[i + 1].startsWith("-")) { //$NON-NLS-1$
	option = tokens[++i];
	} else
	break;
	}

	if (option.length() > 0 && (optionKind.equals(SCDOptionsEnum.INCLUDE)
	\|\| optionKind.equals(SCDOptionsEnum.INCLUDE_FILE)
	\|\| optionKind.equals(SCDOptionsEnum.IMACROS_FILE)
	\|\| optionKind.equals(SCDOptionsEnum.IDIRAFTER) \|\| optionKind.equals(SCDOptionsEnum.ISYSTEM)
	\|\| optionKind.equals(SCDOptionsEnum.IQUOTE))) {
	option = (getAbsolutePath(option)).toString();
	}

	if (optionKind.equals(SCDOptionsEnum.IDIRAFTER)) {
	KVStringPair pair = new KVStringPair(SCDOptionsEnum.INCLUDE.toString(), option);
	dirafter.add(pair);
	} else if (optionKind.equals(SCDOptionsEnum.INCLUDE)) {
	includes.add(option);
	} else { // add the pair
	if (optionKind.equals(SCDOptionsEnum.DEFINE)) {
	if (option.indexOf('=') == -1) {
	option += '=' + fDefaultMacroDefinitionValue;
	}
	}
	KVStringPair pair = new KVStringPair(optionKind.toString(), option);
	command.addSCOption(pair);
	}
	break;
	}
	}
	}
	String option;
	for (Iterator iter = includes.iterator(); iter.hasNext();) {
	option = (String) iter.next();
	KVStringPair pair = new KVStringPair(SCDOptionsEnum.INCLUDE.toString(), option);
	command.addSCOption(pair);
	}
	for (Iterator iter = dirafter.iterator(); iter.hasNext();) {
	command.addSCOption((KVStringPair) iter.next());
	}
	return command;
	}

	/**
	* @return Returns the project.
	*/
	protected IProject getProject() {
	return project;
	}

	public IPath getWorkingDirectory() {
	if (fDirectoryStack.size() != 0) {
	return fDirectoryStack.lastElement();
	}
	// Fallback to the Project Location
	// FIXME: if the build did not start in the Project ?
	return fBaseDirectory;
	}

	protected IPath popDirectory() {
	int i = getDirectoryLevel();
	if (i != 0) {
	IPath dir = fDirectoryStack.lastElement();
	fDirectoryStack.removeElementAt(i - 1);
	return dir;
	}
	return new Path(""); //$NON-NLS-1$
	}

	protected void pushDirectory(IPath dir) {
	if (dir != null) {
	IPath pwd = null;
	if (fBaseDirectory != null && fBaseDirectory.isPrefixOf(dir)) {
	pwd = dir.removeFirstSegments(fBaseDirectory.segmentCount());
	} else {
	// check if it is a cygpath
	pwd = convertCygpath(dir);
	}
	fDirectoryStack.addElement(pwd);
	}
	}

	public boolean reportProblems() {
	boolean reset = false;
	for (Iterator<Problem> iter = fErrors.iterator(); iter.hasNext();) {
	Problem problem = iter.next();
	if (problem.severity == IMarkerGenerator.SEVERITY_ERROR_BUILD) {
	reset = true;
	}
	if (problem.file == null) {
	fMarkerGenerator.addMarker(new ProblemMarkerInfo(project, problem.lineNumber, problem.description,
	problem.severity, problem.variableName));
	} else {
	fMarkerGenerator.addMarker(new ProblemMarkerInfo(problem.file, problem.lineNumber, problem.description,
	problem.severity, problem.variableName));
	}
	}
	fErrors.clear();
	return reset;
	}

	public void setDefaultMacroDefinitionValue(String val) {
	if (val != null) {
	fDefaultMacroDefinitionValue = val;
	}
	}

	public String getDefaultMacroDefinitionValue() {
	return fDefaultMacroDefinitionValue;
	}

	public String normalizePath(String path) {
	int column = path.indexOf(':');
	if (column > 0) {
	char driveLetter = path.charAt(column - 1);
	if (Character.isLowerCase(driveLetter)) {
	StringBuilder sb = new StringBuilder();
	if (column - 1 > 0) {
	sb.append(path.substring(0, column - 1));
	}
	sb.append(Character.toUpperCase(driveLetter));
	sb.append(path.substring(column));
	path = sb.toString();
	}
	}
	if (path.indexOf('.') == -1 \|\| path.equals(".")) { //$NON-NLS-1$
	return (new Path(path)).toString(); // convert separators to '/'
	}
	// lose "./" segments since they confuse the Path normalization
	StringBuilder buf = new StringBuilder(path);
	int len = buf.length();
	StringBuilder newBuf = new StringBuilder(buf.length());
	int scp = 0; // starting copy point
	int ssp = 0; // starting search point
	int sdot;
	boolean validPrefix;
	while (ssp < len && (sdot = buf.indexOf(".", ssp)) != -1) { //$NON-NLS-1$
	validPrefix = false;
	int ddot = buf.indexOf("..", ssp);//$NON-NLS-1$
	if (sdot < ddot \|\| ddot == -1) {
	newBuf.append(buf.substring(scp, sdot));
	scp = sdot;
	ssp = sdot + 1;
	if (ssp < len) {
	if (sdot == 0 \|\| buf.charAt(sdot - 1) == '/' \|\| buf.charAt(sdot - 1) == '\\') {
	validPrefix = true;
	}
	char nextChar = buf.charAt(ssp);
	if (validPrefix && nextChar == '/') {
	++ssp;
	scp = ssp;
	} else if (validPrefix && nextChar == '\\') {
	++ssp;
	if (ssp < len - 1 && buf.charAt(ssp) == '\\') {
	++ssp;
	}
	scp = ssp;
	} else {
	// no path delimiter, must be '.' inside the path
	scp = ssp - 1;
	}
	}
	} else if (sdot == ddot) {
	ssp = sdot + 2;
	}
	}
	newBuf.append(buf.substring(scp, len));

	IPath orgPath = new Path(newBuf.toString());
	return orgPath.toString();
	}

	/**
	* Called by the console line parsers to find a file with a given name.
	* @param fileName
	* @return IFile or null
	*/
	public IFile findFile(String fileName) {
	IFile file = findFilePath(fileName);
	if (file == null) {
	// Try the project's map.
	file = findFileName(fileName);
	if (file != null) {
	// If there is a conflict then try all files in the project.
	if (isConflictingName(fileName)) {
	file = null;

	// Create a problem marker
	final String error = MakeMessages.getString("ConsoleParser.Ambiguous_Filepath_Error_Message"); //$NON-NLS-1$
	TraceUtil.outputError(error, fileName);
	generateMarker(getProject(), -1, error + fileName, IMarkerGenerator.SEVERITY_WARNING, null);
	}
	}
	}
	return file;
	}

	/**
	* @param filePath
	* @return
	*/
	protected IFile findFilePath(String filePath) {
	IPath path = null;
	IPath fp = new Path(filePath);
	if (fp.isAbsolute()) {
	if (getBaseDirectory().isPrefixOf(fp)) {
	int segments = getBaseDirectory().matchingFirstSegments(fp);
	path = fp.removeFirstSegments(segments);
	} else {
	path = fp;
	}
	} else {
	path = getWorkingDirectory().append(filePath);
	}

	IFile file = null;
	// The workspace may throw an IllegalArgumentException
	// Catch it and the parser should fallback to scan the entire project.
	try {
	file = findFileInWorkspace(path);
	} catch (Exception e) {
	}

	// We have to do another try, on Windows for cases like "TEST.C" vs "test.c"
	// We use the java.io.File canonical path.
	if (file == null \|\| !file.exists()) {
	File f = path.toFile();
	try {
	String canon = f.getCanonicalPath();
	path = new Path(canon);
	file = findFileInWorkspace(path);
	} catch (IOException e1) {
	}
	}
	return (file != null && file.exists()) ? file : null;
	}

	/**
	* @param fileName
	* @return
	*/
	protected IFile findFileName(String fileName) {
	IPath path = new Path(fileName);
	return fFilesInProject.get(path.lastSegment());
	}

	protected IFile findFileInWorkspace(IPath path) {
	IFile file = null;
	if (path.isAbsolute()) {
	IWorkspaceRoot root = getProject().getWorkspace().getRoot();

	// construct a URI, based on the project's locationURI, that points
	// to the given path
	URI projectURI = project.getLocationURI();

	URI newURI = EFSExtensionManager.getDefault().createNewURIFromPath(projectURI, path.toString());

	IFile[] files = root.findFilesForLocationURI(newURI);

	for (int i = 0; i < files.length; i++) {
	if (files[i].getProject().equals(getProject())) {
	file = files[i];
	break;
	}
	}

	} else {
	file = getProject().getFile(path);
	}
	return file;
	}

	protected void collectFiles(IContainer parent, List result) {
	try {
	IResource[] resources = parent.members();
	for (int i = 0; i < resources.length; i++) {
	IResource resource = resources[i];
	if (resource instanceof IFile) {
	result.add(resource);
	} else if (resource instanceof IContainer) {
	collectFiles((IContainer) resource, result);
	}
	}
	} catch (CoreException e) {
	MakeCorePlugin.log(e.getStatus());
	}
	}

	protected boolean isConflictingName(String fileName) {
	IPath path = new Path(fileName);
	return fNameConflicts.contains(path.lastSegment());
	}

	public List translateRelativePaths(IFile file, String fileName, List includes) {
	List translatedIncludes = new ArrayList(includes.size());
	for (Iterator i = includes.iterator(); i.hasNext();) {
	String include = (String) i.next();
	IPath includePath = new Path(include);
	if (!includePath.isAbsolute() && !includePath.isUNC()) { // do not translate UNC paths
	// First try the current working directory
	IPath cwd = getWorkingDirectory();
	if (!cwd.isAbsolute()) {
	cwd = getBaseDirectory().append(cwd);
	}

	IPath filePath = new Path(fileName);
	if (!filePath.isAbsolute()) {
	// check if the cwd is the right one
	// appending fileName to cwd should yield file path
	filePath = cwd.append(fileName);
	}
	if (!filePath.toString().equalsIgnoreCase(file.getLocation().toString())) {
	// must be the cwd is wrong
	// check if file name starts with ".."
	if (fileName.startsWith("..")) { //$NON-NLS-1$
	// probably multiple choices for cwd, hopeless
	final String error = MakeMessages.getString("ConsoleParser.Working_Directory_Error_Message"); //$NON-NLS-1$
	TraceUtil.outputError(error, fileName);
	generateMarker(file, -1, error, IMarkerGenerator.SEVERITY_WARNING, fileName);
	break;
	} else {
	// remove common segments at the end
	IPath tPath = new Path(fileName);
	if (fileName.startsWith(".")) { //$NON-NLS-1$
	tPath = tPath.removeFirstSegments(1);
	}
	// get the file path from the file
	filePath = file.getLocation();
	IPath lastFileSegment = filePath
	.removeFirstSegments(filePath.segmentCount() - tPath.segmentCount());
	if (lastFileSegment.matchingFirstSegments(tPath) == tPath.segmentCount()) {
	cwd = filePath.removeLastSegments(tPath.segmentCount());
	}
	}
	}

	IPath candidatePath = cwd.append(includePath);
	File dir = candidatePath.toFile();
	include = candidatePath.toString();
	if (!dir.exists()) {
	final String error = MakeMessages.getString("ConsoleParser.Nonexistent_Include_Path_Error_Message"); //$NON-NLS-1$
	TraceUtil.outputError(error, include);
	// generateMarker(file, -1, error+include, IMarkerGenerator.SEVERITY_WARNING, fileName);
	}
	}
	// TODO VMIR for now add unresolved paths as well
	translatedIncludes.add(include);
	}
	return translatedIncludes;
	}
	}