--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/trace/tracebuilder/com.nokia.tracebuilder.eclipse/src/com/nokia/tracebuilder/eclipse/TraceProjectMonitor.java Wed Jun 23 14:35:40 2010 +0300
@@ -0,0 +1,1893 @@
+/*
+ * Copyright (c) 2008-2010 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:
+ *
+ * Workbench monitor which opens / closes the trace project
+ *
+ */
+package com.nokia.tracebuilder.eclipse;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.DataInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Vector;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IWorkspace;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.jface.text.Document;
+import org.eclipse.jface.text.IDocument;
+import org.eclipse.ui.IEditorReference;
+import org.eclipse.ui.IWorkbenchPage;
+import org.eclipse.ui.IWorkbenchWindow;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.texteditor.ITextEditor;
+import org.osgi.framework.Version;
+
+import com.nokia.carbide.cdt.builder.CarbideBuilderPlugin;
+import com.nokia.carbide.cdt.builder.DefaultMMPViewConfiguration;
+import com.nokia.carbide.cdt.builder.EMMPPathContext;
+import com.nokia.carbide.cdt.builder.EpocEngineHelper;
+import com.nokia.carbide.cdt.builder.ICarbideBuildManager;
+import com.nokia.carbide.cdt.builder.InvalidDriveInMMPPathException;
+import com.nokia.carbide.cdt.builder.MMPViewPathHelper;
+import com.nokia.carbide.cdt.builder.project.ICarbideBuildConfiguration;
+import com.nokia.carbide.cdt.builder.project.ICarbideProjectInfo;
+import com.nokia.carbide.cpp.epoc.engine.EpocEnginePlugin;
+import com.nokia.carbide.cpp.epoc.engine.MMPDataRunnableAdapter;
+import com.nokia.carbide.cpp.epoc.engine.MMPViewRunnableAdapter;
+import com.nokia.carbide.cpp.epoc.engine.model.mmp.EMMPStatement;
+import com.nokia.carbide.cpp.epoc.engine.model.mmp.IMMPData;
+import com.nokia.carbide.cpp.epoc.engine.model.mmp.IMMPView;
+import com.nokia.carbide.cpp.epoc.engine.preprocessor.AcceptedNodesViewFilter;
+import com.nokia.tracebuilder.engine.TraceBuilderConfiguration;
+import com.nokia.tracebuilder.engine.TraceBuilderGlobals;
+import com.nokia.tracebuilder.engine.TraceBuilderView;
+import com.nokia.tracebuilder.engine.TraceLocationConverter;
+import com.nokia.tracebuilder.engine.TraceLocationMap;
+import com.nokia.tracebuilder.engine.TraceProjectMonitorInterface;
+import com.nokia.tracebuilder.engine.TraceBuilderErrorCodes.FileErrorParameters;
+import com.nokia.tracebuilder.engine.TraceBuilderErrorCodes.TraceBuilderErrorCode;
+import com.nokia.tracebuilder.engine.project.ProjectEngine;
+import com.nokia.tracebuilder.engine.source.SourceProperties;
+import com.nokia.tracebuilder.file.FileUtils;
+import com.nokia.tracebuilder.model.TraceBuilderException;
+import com.nokia.tracebuilder.project.GroupNameHandlerBase;
+import com.nokia.tracebuilder.project.GroupNameHandlerOSTv1;
+import com.nokia.tracebuilder.project.GroupNameHandlerOSTv2;
+import com.nokia.tracebuilder.source.SourceConstants;
+import com.nokia.tracebuilder.source.SourceDocumentInterface;
+import com.nokia.tracebuilder.utils.DocumentFactory;
+import com.nokia.carbide.cpp.sdk.core.SDKCorePlugin;
+import com.nokia.carbide.cpp.sdk.core.ISDKManager;
+
+/**
+ * Workbench monitor which opens / closes the trace project
+ *
+ */
+class TraceProjectMonitor implements WorkbenchListenerCallback,
+ TraceProjectMonitorInterface {
+
+ /**
+ * OST_INSTRUMENTATION_API_VERSION text
+ */
+ private static final String OST_INSTRUMENTATION_API_VERSION_TEXT = "OST_INSTRUMENTATION_API_VERSION"; //$NON-NLS-1$
+
+ /**
+ * Regular expression for OST_INSTRUMENTATION_API_VERSION macro check
+ */
+ private static final String OST_INSTRUMENTATION_API_VERSION_REGEX = "#define\\s+OST_INSTRUMENTATION_API_VERSION.*"; //$NON-NLS-1$
+
+ /**
+ * OSTv1 version text
+ */
+ private static final String OST_VERSION_1_X_X = "1.x.x"; //$NON-NLS-1$
+
+ /**
+ * OSTv2 version text
+ */
+ private static final String OST_VERSION_2_X_X = "2.x.x"; //$NON-NLS-1$
+
+ /**
+ * OpenSystemTrace.h file name
+ */
+ private static final String OPEN_SYSTEM_TRACE_H = "opensystemtrace.h"; //$NON-NLS-1$
+
+ /**
+ * epoc32\include\include path as string
+ */
+ private static final String EPOC32_INCLUDE_INTERNAL = "epoc32" + File.separator + "include" + File.separator + "internal"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+
+ /**
+ * epoc32\include\platform path as string
+ */
+ private static final String EPOC32_INCLUDE_PLATFORM = "epoc32" + File.separator + "include" + File.separator + "platform"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+
+ /**
+ * PLATFORM_PATHS.HRH
+ */
+ private static final String PLATFORM_PATHS_HRH = "PLATFORM_PATHS.HRH"; //$NON-NLS-1$
+
+ /**
+ * #INCLUDE
+ */
+ private static final String INCLUDE = "#INCLUDE"; //$NON-NLS-1$
+
+ /**
+ * Multiline comment start
+ */
+ private static final String MULTILINE_COMMENT_START = "/*"; //$NON-NLS-1$
+
+ /**
+ * Comment
+ */
+ private static final String COMMENT = "//"; //$NON-NLS-1$
+
+ /**
+ * Multiline comment end
+ */
+ private static final String MULTILINE_COMMENT_END = "*/"; //$NON-NLS-1$
+
+ /**
+ * ncp sw folder name
+ */
+ private static final String NCP_SW_FOLDER_NAME = "ncp_sw"; //$NON-NLS-1$
+
+ /**
+ * os folder name
+ */
+ private static final String OS_FOLDER_NAME = "os"; //$NON-NLS-1$
+
+ /**
+ * mw folder name
+ */
+ private static final String MW_FOLDER_NAME = "mw"; //$NON-NLS-1$
+
+ /**
+ * sf folder name
+ */
+ private static final String SF_FOLDER_NAME = "sf"; //$NON-NLS-1$
+
+ /**
+ * platform_paths.hrh include
+ */
+ private static final String INCLUDE_PLATFORM_PATHS_HRH = "#include \"platform_paths.hrh\""; //$NON-NLS-1$
+
+ /**
+ * OS layer system include macro
+ */
+ private static final String OS_LAYER_SYSTEMINCLUDE_MACRO = "OS_LAYER_SYSTEMINCLUDE"; //$NON-NLS-1$
+
+ /**
+ * MW layer system include macro
+ */
+ private static final String MW_LAYER_SYSTEMINCLUDE_MACRO = "MW_LAYER_SYSTEMINCLUDE"; //$NON-NLS-1$
+
+ /**
+ * APP layer system include macro
+ */
+ private static final String APP_LAYER_SYSTEMINCLUDE_MACRO = "APP_LAYER_SYSTEMINCLUDE"; //$NON-NLS-1$
+
+ /**
+ * Group directory
+ */
+ private static final String GROUP_DIRECTORY = "group"; //$NON-NLS-1$
+
+ /**
+ * Traces directory
+ */
+ public static final String TRACES_DIRECTORY = "traces"; //$NON-NLS-1$
+
+ /**
+ * MmpFiles directory
+ */
+ private static final String MMPFILES_DIRECTORY = "mmpfiles"; //$NON-NLS-1$
+
+ /**
+ * Underscore character
+ */
+ public static final String UNDERSCORE = "_"; //$NON-NLS-1$
+
+ /**
+ * The workbench listener
+ */
+ private WorkbenchListener listener;
+
+ /**
+ * Project path that is currently open
+ */
+ private String openProjectPath;
+
+ /**
+ * Project object that is currently open
+ */
+ private IProject openProjectObject;
+
+ /**
+ * Trace project include added to MMP files
+ */
+ private boolean mmpFileModified;
+
+ /**
+ * Name of the "traces_<component name>" folder
+ */
+ private String tracesComponentNameFolder;
+
+ /**
+ * Name of the "traces_<target_name>_<target_type>" folder
+ */
+ private String tracesTargetNameTargetTypeFolder;
+
+ /**
+ * Name of the "traces\<target_name>_<target_ext>" folder
+ */
+ private String tracesDirTargetNameTargetExtFolder;
+
+ /**
+ * Trace folder name used in SBSv2
+ */
+ private String sbsv2TraceFolderName;
+
+ /**
+ * Select software component flag
+ */
+ private boolean selectSoftwareComponent = true;
+
+ /**
+ * Select software component check needed flag
+ */
+ private boolean selectSoftwareComponentCheckNeeded = false;
+
+ /**
+ * Trace folder changed flag
+ */
+ private boolean traceFolderChanged = false;
+
+ /**
+ * Previous file included more than once flag
+ */
+ private boolean previousFileIncludedMoreThanOnce = false;
+
+ /**
+ * Editor opened flag
+ */
+ private boolean editorOpened = false;
+
+ /**
+ * File object that is currently visible
+ */
+ IFile openFileObject = null;
+
+ /**
+ * Trace folder name of the project that is currently visible
+ */
+ String openProjectTraceFolderName = null;
+
+ /**
+ * OSTv1 start text
+ */
+ private static final String OSTV1_START_TEXT = "1."; //$NON-NLS-1$
+
+ /**
+ * OSTv2 start text
+ */
+ private static final String OSTV2_START_TEXT = "2."; //$NON-NLS-1$
+
+ /**
+ * Constructor
+ */
+ TraceProjectMonitor() {
+ listener = new WorkbenchListener(this);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * com.nokia.tracebuilder.eclipse.TraceProjectMonitorInterface#startMonitor
+ * ()
+ */
+ public void startMonitor() {
+ listener.startListener();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * com.nokia.tracebuilder.eclipse.TraceProjectMonitorInterface#stopMonitor()
+ */
+ public void stopMonitor() {
+ listener.stopListener();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see com.nokia.tracebuilder.eclipse.WorkbenchListenerCallback#
+ * editorActivated(org.eclipse.ui.texteditor.ITextEditor,
+ * org.eclipse.core.resources.IFile)
+ */
+ public void editorActivated(ITextEditor editor, IFile file) {
+ TraceBuilderView view = TraceBuilderGlobals.getView();
+ view.refresh();
+ if (editorOpened) {
+ view.expandTraceGroupsBranch();
+ editorOpened = false;
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see com.nokia.tracebuilder.eclipse.WorkbenchListenerCallback#
+ * editorClosed(org.eclipse.ui.texteditor.ITextEditor,
+ * org.eclipse.core.resources.IFile)
+ */
+ public void editorClosed(ITextEditor editor, IFile file) {
+ if (!WorkbenchUtils.isEditorsOpen()) {
+ if (openProjectPath != null) {
+ TraceBuilderGlobals.getTraceBuilder().closeProject();
+ openProjectPath = null;
+ }
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see com.nokia.tracebuilder.eclipse.WorkbenchListenerCallback#
+ * editorOpened(org.eclipse.ui.texteditor.ITextEditor,
+ * org.eclipse.core.resources.IFile)
+ */
+ public void editorOpened(ITextEditor editor, IFile file) {
+ openFileObject = file;
+ updateProject(file);
+ editorOpened = true;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see com.nokia.tracebuilder.eclipse.WorkbenchListenerCallback#
+ * editorHidden(org.eclipse.ui.texteditor.ITextEditor,
+ * org.eclipse.core.resources.IFile)
+ */
+ public void editorHidden(ITextEditor editor, IFile file) {
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see com.nokia.tracebuilder.eclipse.WorkbenchListenerCallback#
+ * editorVisible(org.eclipse.ui.texteditor.ITextEditor,
+ * org.eclipse.core.resources.IFile)
+ */
+ public void editorVisible(ITextEditor editor, IFile file) {
+ if (!file.equals(openFileObject)) {
+ updateProject(file);
+ openFileObject = file;
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see com.nokia.tracebuilder.eclipse.WorkbenchListenerCallback#
+ * editorReplaced(org.eclipse.ui.texteditor.ITextEditor,
+ * org.eclipse.core.resources.IFile)
+ */
+ public void editorReplaced(ITextEditor editor, IFile file) {
+ updateProject(file);
+ }
+
+ /**
+ * Opens the trace project related to given file
+ *
+ * @param file
+ * the file
+ */
+ private void updateProject(IFile file) {
+ IProject project = file.getProject();
+
+ // Check that project is Carbide project
+ boolean isCarbideProject = CarbideBuilderPlugin.getBuildManager()
+ .isCarbideProject(project);
+ if (isCarbideProject) {
+
+ String projectPath = getProjectPath(file);
+
+ // If trace folder name or project changes, existing project
+ // needs to be closed
+ if (traceFolderChanged == true
+ || (openProjectPath != null && projectPath != null && !projectPath
+ .equals(openProjectPath))) {
+ TraceBuilderGlobals.getTraceBuilder().closeProject();
+ openProjectPath = null;
+ openProjectObject = null;
+ }
+ if (projectPath != null && !projectPath.equals(openProjectPath)) {
+ try {
+ mmpFileModified = false;
+ openProjectPath = projectPath;
+ openProjectObject = file.getProject();
+ ProjectEngine.traceFolderName = openProjectTraceFolderName;
+ TraceBuilderGlobals.setProjectPath(projectPath);
+ initializeDefaultGroupNames();
+
+ // Get project name
+ String projectName = getProjectName(projectPath);
+
+ // Save Epoc root of this SDK
+ saveEpocRoot(openProjectObject);
+
+ // Open the project
+ TraceBuilderGlobals.getTraceBuilder().openProject(
+ projectName);
+
+ // Parse traces from other source files in same
+ // component
+ parseOtherTracesFromComponent(file, project);
+
+ } catch (TraceBuilderException e) {
+ openProjectPath = null;
+ openProjectObject = null;
+ // If a source file is not open, this error is not
+ // relevant
+ // The project will be opened when a source is opened
+ if (e.getErrorCode() != TraceBuilderErrorCode.SOURCE_NOT_OPEN) {
+ TraceBuilderGlobals.getEvents().postError(e);
+ }
+ }
+ }
+ } else {
+ TraceBuilderGlobals.getTraceBuilder().closeProject();
+ openProjectPath = null;
+ openProjectObject = null;
+ }
+ }
+
+ /**
+ * Initialize default group names based on used OST version
+ *
+ * @throws TraceBuilderException
+ */
+ private void initializeDefaultGroupNames() throws TraceBuilderException {
+
+ // Initialize default group names
+
+ String ostVersion = null;
+ IPath epocroot = WorkbenchUtils
+ .getEpocRootForProject(openProjectObject);
+ String epocRootAsString = epocroot.toOSString();
+ File platformDir = new File(epocRootAsString + EPOC32_INCLUDE_PLATFORM);
+ File platformOpenSystemTraceFile = new File(platformDir,
+ OPEN_SYSTEM_TRACE_H);
+ if (platformOpenSystemTraceFile.exists()
+ && platformOpenSystemTraceFile.isFile()) {
+ ostVersion = getOstVersion(platformOpenSystemTraceFile);
+
+ // If OST version is not defined in opensystemtrace.h file then
+ // default is 1.x.x
+ if (ostVersion == null) {
+ ostVersion = OST_VERSION_1_X_X;
+ }
+
+ } else {
+ File internalDir = new File(epocRootAsString
+ + EPOC32_INCLUDE_INTERNAL);
+ File internalOpenSystemTraceFile = new File(internalDir,
+ OPEN_SYSTEM_TRACE_H);
+
+ // If opensystemtrace.h file exist only in internal folder then
+ // version is 1.x.x. In OSTv2 case opensystemtrace.h file should
+ // newer exist only in internal folder, so it is enough that we
+ // check version only from header in platform folder, because OSTv1
+ // version of header does not contain version information.
+ if (internalOpenSystemTraceFile.exists()
+ && internalOpenSystemTraceFile.isFile()) {
+ ostVersion = OST_VERSION_1_X_X;
+ } else {
+
+ // If opensystemtrace.h file does not exist at all then default
+ // is 2.x.x
+ ostVersion = OST_VERSION_2_X_X;
+ }
+ }
+
+ // Check is OST version 1.x.x in use. If it is then use OSTv1 otherwise
+ // use OSTv2
+ GroupNameHandlerBase groupNameHandler = TraceBuilderGlobals
+ .getGroupNameHandler();
+ if (ostVersion.startsWith(OSTV1_START_TEXT)) {
+ if (!(groupNameHandler instanceof GroupNameHandlerOSTv1)) {
+ TraceBuilderGlobals
+ .setGroupNameHandler(new GroupNameHandlerOSTv1());
+ }
+ } else if (ostVersion.startsWith(OSTV2_START_TEXT)) {
+ if (!(groupNameHandler instanceof GroupNameHandlerOSTv2)) {
+ TraceBuilderGlobals
+ .setGroupNameHandler(new GroupNameHandlerOSTv2());
+ }
+ } else {
+ throw new TraceBuilderException(
+ TraceBuilderErrorCode.UNKNOWN_OST_VERSION);
+ }
+ }
+
+ /**
+ * Get OST version from OpenSystemTrace.h file
+ *
+ * @param platformOpenSystemTraceFile
+ * open system trace API file
+ * @return OST version Used OST version (e.g. 2.0.0)
+ * @throws TraceBuilderException
+ */
+ private String getOstVersion(File platformOpenSystemTraceFile)
+ throws TraceBuilderException {
+ String ostVersion = null;
+ FileInputStream fstream;
+ try {
+ fstream = new FileInputStream(platformOpenSystemTraceFile
+ .toString());
+ DataInputStream in = new DataInputStream(fstream);
+
+ BufferedReader br = new BufferedReader(new InputStreamReader(in));
+ String strLine;
+
+ // Read opensystemtrace.h file line by line
+ try {
+ while ((strLine = br.readLine()) != null) {
+ boolean versionDefinitionFound = strLine
+ .matches(OST_INSTRUMENTATION_API_VERSION_REGEX);
+ if (versionDefinitionFound) {
+ int versionNumberStart = strLine
+ .indexOf(OST_INSTRUMENTATION_API_VERSION_TEXT)
+ + OST_INSTRUMENTATION_API_VERSION_TEXT.length();
+ ostVersion = strLine.substring(versionNumberStart);
+ ostVersion = ostVersion.trim();
+ break;
+ }
+ }
+ } catch (IOException e) {
+ throw new TraceBuilderException(
+ TraceBuilderErrorCode.UNEXPECTED_EXCEPTION, e);
+ } finally {
+ try {
+ in.close();
+ } catch (IOException e1) {
+ throw new TraceBuilderException(
+ TraceBuilderErrorCode.UNEXPECTED_EXCEPTION, e1);
+ }
+ }
+ } catch (FileNotFoundException e2) {
+ FileErrorParameters params = new FileErrorParameters();
+ params.file = platformOpenSystemTraceFile.toString();
+ throw new TraceBuilderException(
+ TraceBuilderErrorCode.FILE_NOT_FOUND, params);
+ }
+
+ return ostVersion;
+ }
+
+ /**
+ * Parse traces from other source files in same component
+ *
+ * @param file
+ * the file
+ * @param project
+ * the project
+ */
+ private void parseOtherTracesFromComponent(IFile file, IProject project) {
+
+ if (file != null && project != null) {
+ ICarbideBuildConfiguration buildConfig = getBuildConfiguration(project);
+ if (buildConfig != null) {
+
+ // Get MMP files for given source file
+ for (final IPath mmpPath : EpocEngineHelper.getMMPsForSource(
+ openProjectObject, file.getLocation())) {
+ IPath fullMmpPath = new Path(openProjectPath);
+ fullMmpPath = fullMmpPath.append(mmpPath);
+
+ String componentId = getComponentIdFromMMPFile(mmpPath,
+ project);
+
+ // Component ID in MMP file must be same as current software
+ // component ID
+ if (TraceBuilderGlobals.getCurrentSoftwareComponentId() != null
+ && TraceBuilderGlobals
+ .getCurrentSoftwareComponentId().equals(
+ componentId)) {
+
+ // Get source files for MMP file
+ for (final IPath sourcePath : EpocEngineHelper
+ .getSourceFilesForConfiguration(buildConfig,
+ fullMmpPath)) {
+ File source = new File(sourcePath.toOSString());
+
+ // Check that source file is not same as opened file
+ if (!file.getName().equalsIgnoreCase(
+ source.getName())
+ && !isFileOpenedInEditor(source)) {
+ IWorkspace workspace = ResourcesPlugin
+ .getWorkspace();
+ IPath location = Path.fromOSString(source
+ .getAbsolutePath());
+ IFile isource = workspace.getRoot()
+ .getFileForLocation(location);
+
+ // Parse traces from source file
+ parseTracesFromFile(isource);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Get build configuration
+ *
+ * @param project
+ * the project
+ * @return the build configuration
+ */
+ private ICarbideBuildConfiguration getBuildConfiguration(IProject project) {
+ ICarbideBuildManager buildMgr = CarbideBuilderPlugin.getBuildManager();
+ ICarbideBuildConfiguration buildConfig = null;
+ if (buildMgr != null) {
+
+ // We do not need to check that is project Carbide
+ // project because we have done that earlier
+ ICarbideProjectInfo cpi = buildMgr.getProjectInfo(project);
+ if (cpi != null) {
+
+ // Get the default build configuration
+ buildConfig = cpi.getDefaultConfiguration();
+ }
+ }
+ return buildConfig;
+ }
+
+ /**
+ * Parse traces from given file
+ *
+ * @param file
+ * the file
+ */
+ private void parseTracesFromFile(IFile file) {
+
+ if (file != null) {
+
+ // Get file content to string variable
+ String sourceData = getFileContentAsString(file);
+
+ if (sourceData != null) {
+
+ // Create new document from source data
+ IDocument document = new Document(sourceData);
+ document
+ .addPositionCategory(JFaceDocumentWrapper.TRACEBUILDER_POSITION_CATEGORY);
+ JFaceLocationUpdater locationUpdater = new JFaceLocationUpdater(
+ JFaceDocumentWrapper.TRACEBUILDER_POSITION_CATEGORY);
+ document.addPositionUpdater(locationUpdater);
+ SourceDocumentInterface sourceDocumentInterface = new JFaceDocumentWrapper(
+ document);
+
+ // Create new source properties
+ SourceProperties properties = new SourceProperties(
+ TraceBuilderGlobals.getTraceModel(), DocumentFactory
+ .getDocumentMonitor().getFactory(),
+ sourceDocumentInterface);
+
+ // Parse trace locations from source properties
+ properties.updateTraces(0, sourceData.length());
+
+ TraceLocationMap locationMap = TraceBuilderGlobals
+ .getLocationMap();
+
+ // When we add source to location map it will go to unrelated
+ // list
+ locationMap.addSource(properties);
+
+ // Parse traces from source so those will be added to the model
+ TraceLocationConverter lc = TraceBuilderGlobals
+ .getLocationConverter();
+ lc.parseTracesFromSource(properties);
+
+ String path = file.getLocation().removeLastSegments(1)
+ .toOSString()
+ + "\\"; //$NON-NLS-1$
+ String fileName = file.getName();
+
+ // When we remove source from location map it will go to last
+ // known locations list
+ locationMap.removeSource(properties, path, fileName);
+ }
+ }
+ }
+
+ /**
+ * Get file content as string
+ *
+ * @param file
+ * the file
+ * @return file content as string
+ */
+ private String getFileContentAsString(IFile file) {
+ String fileContentAsString = null;
+ boolean continueExecution = true;
+
+ InputStream is = null;
+ try {
+ is = file.getContents();
+ } catch (CoreException e1) {
+ continueExecution = false;
+ }
+
+ if (continueExecution) {
+ BufferedReader reader = new BufferedReader(
+ new InputStreamReader(is));
+ StringBuilder sb = new StringBuilder();
+
+ String line = null;
+ try {
+
+ // Read file content line by line to string builder
+ while ((line = reader.readLine()) != null) {
+ sb.append(line + SourceConstants.LINE_FEED);
+ }
+ } catch (IOException e) {
+ continueExecution = false;
+ } finally {
+ try {
+ is.close();
+ } catch (IOException e) {
+ continueExecution = false;
+ }
+ }
+
+ // If everything went OK, get content from string builder to string
+ // variable
+ if (continueExecution) {
+ fileContentAsString = sb.toString();
+ }
+ }
+
+ return fileContentAsString;
+ }
+
+ /**
+ * Check is file opened in editor
+ *
+ * @param source
+ * .getAbsolutePath() the file
+ * @return true if file is opened in editor, otherwise false
+ */
+ private boolean isFileOpenedInEditor(File source) {
+ boolean fileAlredyOpened = false;
+ IWorkbenchWindow[] windows = PlatformUI.getWorkbench()
+ .getWorkbenchWindows();
+ for (IWorkbenchWindow window : windows) {
+ IWorkbenchPage[] pages = window.getPages();
+ for (IWorkbenchPage page : pages) {
+ IEditorReference[] refs = page.getEditorReferences();
+ IFile alreadyOpenedFile = null;
+ for (IEditorReference ref : refs) {
+ alreadyOpenedFile = WorkbenchUtils.getEditorFile(ref);
+ if (alreadyOpenedFile != null
+ && alreadyOpenedFile.getLocation().toOSString()
+ .equals(source.getAbsolutePath())) {
+ fileAlredyOpened = true;
+ break;
+ }
+ }
+ if (fileAlredyOpened) {
+ break;
+ }
+ }
+ if (fileAlredyOpened) {
+ break;
+ }
+ }
+ return fileAlredyOpened;
+ }
+
+ /**
+ * Gets project name from project path
+ *
+ * @param projectPath
+ * the project path
+ * @return project name
+ */
+ private String getProjectName(String projectPath) {
+ String separator = System.getProperty("file.separator"); //$NON-NLS-1$
+ String projectName = projectPath.substring(projectPath
+ .lastIndexOf(separator) + 1);
+ return projectName;
+ }
+
+ /**
+ * Gets project path from file
+ *
+ * @param file
+ * the file
+ * @return the project path
+ */
+ private String getProjectPath(IFile file) {
+ String projectPath = null;
+
+ // Initial project path is the file's parent folder
+ IPath path = file.getLocation();
+ IProject project = file.getProject();
+
+ // Check if file is source file
+ if (isSourceFile(file)) {
+ projectPath = getProjectPathToSourceFile(project, path);
+
+ // It could be that source file is not included to MMP file and
+ // because that we did not find project path. So if source file
+ // project path is null, try to find project path to source file
+ // same way than non source file.
+ if (projectPath == null) {
+ projectPath = getProjetcPathToNonSourceFile(project, path);
+ }
+ } else {
+ projectPath = getProjetcPathToNonSourceFile(project, path);
+ }
+
+ return projectPath;
+ }
+
+ /**
+ * Get project path to source file
+ *
+ * @param project
+ * project
+ * @param path
+ * path where to start find project path
+ * @return the project path
+ */
+ private String getProjectPathToSourceFile(IProject project, IPath path) {
+ String projectPath = null;
+ String mmpFilePath = null;
+ IPath currentSoftwareComponentMMPPath = null;
+ List<IPath> mmpPaths = EpocEngineHelper.getMMPsForSource(project, path);
+ if (mmpPaths.size() > 0) {
+
+ // Check that was source file included to more than one MMP file
+ if (mmpPaths.size() > 1) {
+
+ // User need to select software component to work with, if
+ // previous file was also included to more than one MMP file or
+ // if some of the previous files belonged to different
+ // component.
+ if (selectSoftwareComponent || previousFileIncludedMoreThanOnce) {
+
+ // Clear old software component list
+ TraceBuilderGlobals.clearSoftwareComponents();
+
+ // Add all software components to software component list
+ for (int i = 0; i < mmpPaths.size(); i++) {
+ IPath mmpPath = mmpPaths.get(i);
+ String mmpPathAsString = mmpPath.toString();
+ String componentId = getComponentIdFromMMPFile(mmpPath,
+ project);
+ String componentName = getComponentNameFromMMPFileName(mmpPathAsString);
+ TraceBuilderGlobals.addSoftwareComponent(componentId,
+ componentName, mmpPathAsString);
+ }
+
+ // Ask user to select software component to be used
+ try {
+ TraceBuilderGlobals.getTraceBuilder().selectComponent();
+ } catch (TraceBuilderException e) {
+ TraceBuilderGlobals.getEvents().postError(e);
+ }
+
+ selectSoftwareComponentCheckNeeded = true;
+ }
+
+ currentSoftwareComponentMMPPath = new Path(TraceBuilderGlobals
+ .getCurrentSoftwareComponentMMPPath());
+ String currentSoftwareComponentName = TraceBuilderGlobals
+ .getCurrentSoftwareComponentName();
+ setPossibleTraceFolderNames(project,
+ currentSoftwareComponentName,
+ currentSoftwareComponentMMPPath);
+
+ // Remove mmp file name from mmpPathAsString variable
+ IPath projectLocation = project.getLocation();
+ String mmpPathAsString = TraceBuilderGlobals
+ .getCurrentSoftwareComponentMMPPath();
+ int lastIndexOfForwardSlashChar = mmpPathAsString
+ .lastIndexOf(SourceConstants.FORWARD_SLASH_CHAR);
+
+ if (lastIndexOfForwardSlashChar != -1) {
+ mmpPathAsString = mmpPathAsString.substring(0,
+ lastIndexOfForwardSlashChar);
+ }
+
+ // Append mmpPathAsString to Project path to get real
+ // mmp file path
+ mmpFilePath = projectLocation.append(mmpPathAsString)
+ .toString();
+
+ previousFileIncludedMoreThanOnce = true;
+ } else {
+ currentSoftwareComponentMMPPath = mmpPaths.get(0);
+ String mmpPathAsString = currentSoftwareComponentMMPPath
+ .toString();
+
+ String componentId = getComponentIdFromMMPFile(
+ currentSoftwareComponentMMPPath, project);
+ String componentName = getComponentNameFromMMPFileName(mmpPathAsString);
+
+ if (selectSoftwareComponentCheckNeeded) {
+ if (TraceBuilderGlobals.getCurrentSoftwareComponentId() != null
+ && TraceBuilderGlobals
+ .getCurrentSoftwareComponentId().equals(
+ componentId)) {
+ selectSoftwareComponent = false;
+ } else {
+ selectSoftwareComponent = true;
+ selectSoftwareComponentCheckNeeded = false;
+ }
+ }
+
+ // Clear old software component list
+ TraceBuilderGlobals.clearSoftwareComponents();
+
+ // Add software component to software component list
+ TraceBuilderGlobals.addSoftwareComponent(componentId,
+ componentName, mmpPathAsString);
+
+ // Because there is only one component current component index
+ // is 0
+ TraceBuilderGlobals.setCurrentSoftwareComponentIndex(0);
+
+ setPossibleTraceFolderNames(project, componentName,
+ currentSoftwareComponentMMPPath);
+
+ // Remove mmp file name from mmpPathAsString variable
+ IPath projectLocation = project.getLocation();
+ int lastIndexOfForwardSlashChar = mmpPathAsString
+ .lastIndexOf(SourceConstants.FORWARD_SLASH_CHAR);
+
+ if (lastIndexOfForwardSlashChar != -1) {
+ mmpPathAsString = mmpPathAsString.substring(0,
+ lastIndexOfForwardSlashChar);
+ }
+
+ // Append mmpPathAsString to Project path to get real
+ // mmp file path
+ mmpFilePath = projectLocation.append(mmpPathAsString)
+ .toString();
+
+ previousFileIncludedMoreThanOnce = false;
+ }
+ projectPath = findProjectRootAndSetTracesFolderName(
+ currentSoftwareComponentMMPPath, project, mmpFilePath);
+ }
+ return projectPath;
+ }
+
+ /**
+ * Find project root and set traces folder name
+ *
+ * @param mmpFilePath
+ * MPP file path
+ * @return Project root
+ */
+ private String findProjectRootAndSetTracesFolderName(IPath mmpPath,
+ IProject project, String mmpFilePath) {
+ String projectPath;
+ projectPath = findProjectRoot(mmpFilePath);
+
+ // Store previous trace folder name
+ String previousTraceFolderName = ProjectEngine.traceFolderName;
+ openProjectTraceFolderName = findTraceFolderName(mmpPath, project,
+ projectPath);
+
+ // Check has trace folder name changed
+ traceFolderChanged = false;
+ if (previousTraceFolderName != null
+ && !previousTraceFolderName
+ .equalsIgnoreCase(openProjectTraceFolderName)) {
+ traceFolderChanged = true;
+ }
+ return projectPath;
+ }
+
+ /**
+ * Set possible trace folder names
+ *
+ * @param carbideProject
+ * Current Carbide.c++ project
+ * @param componentName
+ * Current component name
+ * @param relativeMMPPath
+ * Relative path to current MMP file
+ */
+ private void setPossibleTraceFolderNames(IProject carbideProject,
+ String componentName, IPath relativeMMPPath) {
+ String targetName = null;
+ String targetExt = null;
+ tracesComponentNameFolder = TRACES_DIRECTORY + UNDERSCORE
+ + componentName;
+
+ // Append relative MMP path to the project location to get location of
+ // the MMP file
+ IPath mmpPath = carbideProject.getLocation().append(relativeMMPPath);
+
+ ICarbideBuildManager buildMgr = CarbideBuilderPlugin.getBuildManager();
+ ICarbideProjectInfo cpi = buildMgr.getProjectInfo(carbideProject);
+
+ // Get the default build configuration
+ ICarbideBuildConfiguration defultConfig = cpi.getDefaultConfiguration();
+ IPath pathForExcutable = EpocEngineHelper.getHostPathForExecutable(
+ defultConfig, mmpPath);
+ if (pathForExcutable != null) {
+ String fileName = pathForExcutable.lastSegment();
+ int lastIndexOfDot = fileName.lastIndexOf("."); //$NON-NLS-1$
+ targetName = fileName.substring(0, lastIndexOfDot);
+ targetExt = fileName.substring(lastIndexOfDot + 1);
+ }
+
+ Object data = EpocEnginePlugin.runWithMMPData(mmpPath,
+ new DefaultMMPViewConfiguration(carbideProject, defultConfig,
+ new AcceptedNodesViewFilter()),
+ new MMPDataRunnableAdapter() {
+ public Object run(IMMPData mmpData) {
+ // The real return value, getting a single argument
+ // setting
+ return mmpData.getSingleArgumentSettings().get(
+ EMMPStatement.TARGETTYPE);
+ }
+ });
+
+ String targetType = (String) data;
+
+ if (targetName != null && targetType != null) {
+ tracesTargetNameTargetTypeFolder = TRACES_DIRECTORY + UNDERSCORE
+ + targetName + UNDERSCORE + targetType;
+ } else {
+ tracesTargetNameTargetTypeFolder = null;
+ }
+
+ if (targetName != null && targetExt != null) {
+ tracesDirTargetNameTargetExtFolder = TRACES_DIRECTORY
+ + File.separator + targetName + UNDERSCORE + targetExt;
+ } else {
+ tracesDirTargetNameTargetExtFolder = null;
+ }
+
+ setSBSv2TraceFolderName(carbideProject);
+ }
+
+ /**
+ * Get component id from MMP file
+ *
+ * @param mmpPath
+ * the mmp file path
+ * @param project
+ * the project
+ * @return the component id as string
+ */
+ private String getComponentIdFromMMPFile(IPath mmpPath, IProject project) {
+ String uid = null;
+ if (mmpPath != null) {
+ ICarbideBuildConfiguration buildConfig = getBuildConfiguration(project);
+ if (buildConfig != null) {
+ Object data = EpocEnginePlugin.runWithMMPData(project
+ .getLocation().append(mmpPath),
+ new DefaultMMPViewConfiguration(buildConfig
+ .getCarbideProject().getProject(), buildConfig,
+ new AcceptedNodesViewFilter()),
+ new MMPDataRunnableAdapter() {
+ public Object run(IMMPData mmpData) {
+
+ // Try first get value of UID3
+ String uid = mmpData.getUid3();
+
+ // If value of UID3 is null then
+ // try get value of UID2
+ if (uid == null) {
+ uid = mmpData.getUid2();
+ }
+
+ // return value could be null if
+ // UID2 is not defined
+ return uid; // CodForChk_Dis_Exits
+ }
+ });
+ uid = (String) data;
+ }
+ }
+ return uid;
+ }
+
+ /**
+ * Get trace folder name from MMP file
+ *
+ * @param mmpPath
+ * the mmp file path
+ * @param project
+ * the project
+ * @return the trace folder name
+ */
+ private String getTraceFolderFromMMPFile(IPath mmpPath, IProject project) {
+ String traceFolder = null;
+ if (mmpPath != null) {
+ ICarbideBuildConfiguration buildConfig = getBuildConfiguration(project);
+ if (buildConfig != null) {
+ Object data = EpocEnginePlugin.runWithMMPData(project
+ .getLocation().append(mmpPath),
+ new DefaultMMPViewConfiguration(buildConfig
+ .getCarbideProject().getProject(), buildConfig,
+ new AcceptedNodesViewFilter()),
+ new MMPDataRunnableAdapter() {
+ public Object run(IMMPData mmpData) {
+
+ String traceFolder = null;
+
+ // Get the list of user include
+ // paths
+ List<IPath> userIncludes = mmpData
+ .getUserIncludes();
+
+ // Go through existing userincludes
+ // to check if the path to add is
+ // already present
+ for (int i = 0; i < userIncludes.size(); i++) {
+ String userIncludeAsOSString = userIncludes
+ .get(i).toOSString();
+ if (userIncludeAsOSString
+ .equalsIgnoreCase(TRACES_DIRECTORY)
+ || userIncludeAsOSString
+ .equalsIgnoreCase(tracesComponentNameFolder)
+ || userIncludeAsOSString
+ .equalsIgnoreCase(tracesTargetNameTargetTypeFolder)
+ || userIncludeAsOSString
+ .equalsIgnoreCase(tracesDirTargetNameTargetExtFolder)) {
+ traceFolder = userIncludeAsOSString;
+ break;
+ }
+ }
+ return traceFolder; // CodForChk_Dis_Exits
+ }
+ });
+ traceFolder = (String) data;
+ }
+ }
+ return traceFolder;
+ }
+
+ /**
+ * Get component name from MMP file name
+ *
+ * @param mmpPathAsString
+ * the mmp file path as string
+ * @return the component name
+ */
+ private String getComponentNameFromMMPFileName(String mmpPathAsString) {
+ String mmpFileName = null;
+ if (mmpPathAsString != null) {
+ int lastIndexOfForwardSlashChar = mmpPathAsString
+ .lastIndexOf(SourceConstants.FORWARD_SLASH_CHAR);
+ int lastIndexOfPeriod = mmpPathAsString.lastIndexOf(FileUtils.MMP);
+ mmpFileName = mmpPathAsString.substring(
+ lastIndexOfForwardSlashChar + 1, lastIndexOfPeriod);
+ }
+
+ return mmpFileName;
+ }
+
+ /**
+ * Get project path to non source file
+ *
+ * @param project
+ * project
+ * @param path
+ * path where to start find project path
+ * @return the project path
+ */
+ private String getProjetcPathToNonSourceFile(IProject project, IPath path) {
+ String projectPath = null;
+
+ // We can not parse software components, because file is not source file
+ // and it is not listed in MMP files. So just clear software components
+ // list.
+ TraceBuilderGlobals.clearSoftwareComponents();
+
+ // Check that is file part of open project
+ if (project.equals(openProjectObject) && openProjectPath != null) {
+
+ // File part of open project, so use same project path
+ projectPath = openProjectPath;
+
+ // Because project path is same, also trace folder is same
+ traceFolderChanged = false;
+ } else {
+
+ // File not part of open project, so find project path
+ projectPath = findProjectRootAndSetTracesFolderName(path, project,
+ path.toOSString());
+ }
+ return projectPath;
+ }
+
+ /**
+ * Find files project root
+ *
+ * @param path
+ * path where to start find project root
+ * @return the project root
+ */
+ private String findProjectRoot(String path) {
+ boolean found = false;
+ String root = path;
+ File file = new File(root);
+ while (!found && file != null) {
+ if (isProjectRoot(file)) {
+ root = file.getPath();
+ found = true;
+ } else {
+ file = file.getParentFile();
+ }
+ }
+ return root;
+ }
+
+ /**
+ * Find trace folder name
+ *
+ * @param mmpFilePath
+ * MMP file path
+ * @param projectRoot
+ * project root
+ * @return the trace folder name
+ */
+ private String findTraceFolderName(IPath mmpPath, IProject project,
+ String projectRoot) {
+ String traceFolderName = null;
+
+ traceFolderName = getTraceFolderFromMMPFile(mmpPath, project);
+
+ if (traceFolderName == null) {
+ traceFolderName = findTraceFolderNameFromFileSystem(projectRoot);
+ }
+ return traceFolderName;
+ }
+
+ /**
+ * Find trace folder name from file system
+ *
+ * @param projectRoot
+ * project root
+ * @return the trace folder name
+ */
+ private String findTraceFolderNameFromFileSystem(String projectRoot) {
+ String traceFolderName = null;
+ File file = new File(projectRoot);
+
+ File[] children = file.listFiles();
+
+ // Check that does subdirectory that name is one of the possible trace
+ // folder name exist in this directory. If it exist use that as traces
+ // directory name.
+ for (int i = 0; i < children.length; i++) {
+ File child = children[i];
+ String childName = child.getName();
+ if (child.isDirectory()) {
+ if (childName
+ .equalsIgnoreCase(tracesDirTargetNameTargetExtFolder)) {
+ traceFolderName = tracesDirTargetNameTargetExtFolder;
+ break;
+ } else if (childName
+ .equalsIgnoreCase(tracesTargetNameTargetTypeFolder)) {
+ traceFolderName = tracesTargetNameTargetTypeFolder;
+ break;
+ } else if (childName
+ .equalsIgnoreCase(tracesComponentNameFolder)) {
+ traceFolderName = tracesComponentNameFolder;
+ break;
+ } else if (childName.equalsIgnoreCase(TRACES_DIRECTORY)) {
+ traceFolderName = TRACES_DIRECTORY;
+ break;
+ }
+ }
+ }
+
+ // If trace folder name is "traces" we need to check that does it
+ // include folder "<target name>_<target ext>". If it includes then
+ // that folder need to be as traces folder name
+ if (traceFolderName != null && traceFolderName.equals(TRACES_DIRECTORY) && tracesDirTargetNameTargetExtFolder != null) {
+ file = new File(projectRoot + File.separator + TRACES_DIRECTORY);
+ children = file.listFiles();
+ int startIndex = tracesDirTargetNameTargetExtFolder
+ .lastIndexOf(File.separator);
+ String targetNameTargetExtFolder = tracesDirTargetNameTargetExtFolder
+ .substring(startIndex + 1);
+ for (int i = 0; i < children.length; i++) {
+ File child = children[i];
+ String childName = child.getName();
+ if (child.isDirectory()) {
+ if (childName.equalsIgnoreCase(targetNameTargetExtFolder)) {
+ traceFolderName = tracesDirTargetNameTargetExtFolder;
+ break;
+ }
+ }
+ }
+ }
+
+ // If trace folder is still null set default value based on used SBS
+ // version
+ if (traceFolderName == null) {
+ if (sbsv2TraceFolderName != null) {
+ traceFolderName = sbsv2TraceFolderName;
+ } else {
+ traceFolderName = tracesComponentNameFolder;
+ }
+ }
+ return traceFolderName;
+ }
+
+ /**
+ * Set SBSv2 trace folder name
+ *
+ * @param project
+ * Carbide project
+ */
+ private void setSBSv2TraceFolderName(IProject project) {
+ ICarbideBuildManager buildMgr = CarbideBuilderPlugin.getBuildManager();
+
+ boolean isSBSv2Project = buildMgr.isCarbideSBSv2Project(project);
+
+ if (isSBSv2Project) {
+ ISDKManager sdkMgr = SDKCorePlugin.getSDKManager();
+ Version sbsv2Version = sdkMgr.getSBSv2Version(true);
+ int major = sbsv2Version.getMajor();
+ int minor = sbsv2Version.getMinor();
+ int micro = sbsv2Version.getMicro();
+
+ if ((major < 2) || (major == 2 && minor < 10)
+ || (major == 2 && minor == 10 && micro == 0)) {
+ sbsv2TraceFolderName = tracesComponentNameFolder;
+ } else if (major == 2) {
+ if ((major == 2 && minor < 14)) {
+ sbsv2TraceFolderName = tracesTargetNameTargetTypeFolder;
+ } else {
+ sbsv2TraceFolderName = tracesDirTargetNameTargetExtFolder;
+ }
+ } else {
+ sbsv2TraceFolderName = tracesDirTargetNameTargetExtFolder;
+ }
+ } else {
+ sbsv2TraceFolderName = null;
+ }
+ }
+
+ /**
+ * Checks if this folder is the project root
+ *
+ * @param parentFolder
+ * parent folder
+ * @return true if this folder is the project root
+ */
+ private boolean isProjectRoot(File mmpFile) {
+ // Try to find traces, group or mmpfiles folder from this folder
+ boolean isProjectRoot = false;
+
+ FilenameFilter filter = new FilenameFilter() {
+ public boolean accept(File file, String name) {
+ boolean retval = false;
+
+ if (file.isDirectory()) {
+ if (name
+ .equalsIgnoreCase(tracesDirTargetNameTargetExtFolder)
+ || name
+ .equalsIgnoreCase(tracesTargetNameTargetTypeFolder)
+ || name.equalsIgnoreCase(tracesComponentNameFolder)
+ || name.equalsIgnoreCase(TRACES_DIRECTORY)
+ || name.equalsIgnoreCase(GROUP_DIRECTORY)
+ || name.equalsIgnoreCase(MMPFILES_DIRECTORY)) {
+ retval = true;
+ }
+ }
+ return retval; // CodForChk_Dis_Exits
+ }
+ };
+
+ String[] children = mmpFile.list(filter);
+
+ if (children != null && children.length != 0) {
+ isProjectRoot = true;
+ }
+
+ return isProjectRoot; // CodForChk_Dis_Exits
+ }
+
+ /**
+ * Saves Epoc root to Trace Builder Configuration
+ *
+ * @param project
+ * the project
+ */
+ private void saveEpocRoot(IProject project) {
+ IPath epocRoot = WorkbenchUtils.getEpocRootForProject(project);
+
+ if (epocRoot != null) {
+ TraceBuilderGlobals.getConfiguration().setText(
+ TraceBuilderConfiguration.ENVIRONMENT_ROOT,
+ epocRoot.toOSString());
+ } else {
+ TraceBuilderGlobals.getConfiguration().setText(
+ TraceBuilderConfiguration.ENVIRONMENT_ROOT, ""); //$NON-NLS-1$
+ }
+ }
+
+ /**
+ * Checks that the given file belongs to active project
+ *
+ * @param file
+ * the file
+ * @return true if valid, false if not
+ */
+ boolean isFileActive(IFile file) {
+ boolean isActive = false;
+ IProject project = file.getProject();
+ if (project.equals(openProjectObject) == true) {
+
+ // Check that project is Carbide project
+ boolean isCarbideProject = CarbideBuilderPlugin.getBuildManager()
+ .isCarbideProject(project);
+ if (isCarbideProject) {
+
+ // If file is source file then we need to check that trace
+ // folcer name is same than open project trace folder name
+ if (isSourceFile(file)) {
+ IPath path = file.getLocation();
+ List<IPath> mmpPaths = EpocEngineHelper.getMMPsForSource(
+ project, path);
+ if (mmpPaths.size() > 0) {
+ for (int i = 0; i < mmpPaths.size(); i++) {
+ IPath mmpPath = mmpPaths.get(i);
+ String mmpPathAsString = mmpPath.toString();
+ String componentName = getComponentNameFromMMPFileName(mmpPathAsString);
+ String currentComponentName = TraceBuilderGlobals
+ .getCurrentSoftwareComponentName();
+ if (componentName != null
+ && componentName
+ .equalsIgnoreCase(currentComponentName)) {
+ isActive = true;
+ break;
+ }
+ }
+ }
+ } else {
+ isActive = true;
+ }
+ }
+ }
+ return isActive;
+ }
+
+ /**
+ * Check that is file source file
+ *
+ * @param file
+ * file that need to be check
+ * @return true if file is source file, false if not
+ */
+ private boolean isSourceFile(IFile file) {
+ boolean retVal = false;
+
+ String extension = file.getFileExtension();
+
+ if (extension != null
+ && (extension.equalsIgnoreCase(FileUtils.CPP_EXTENSION) || extension
+ .equalsIgnoreCase(FileUtils.C_EXTENSION))) {
+ retVal = true;
+ }
+ return retVal;
+ }
+
+ /**
+ * Source saved
+ *
+ * @param source
+ * the source
+ */
+ void sourceSaved(JFaceDocumentWrapper source) {
+ if (!mmpFileModified && openProjectObject != null
+ && TraceBuilderGlobals.getTraceModel().hasTraces()) {
+ String fileName = source.getFileName();
+ String filepath = source.getFilePath();
+ Path path = new Path(filepath + fileName);
+
+ // Add traces folder include path to MMP file
+ addTracesFolderInclude(path);
+
+ // Add SYSTEMINCLUDE to MMP file if needed
+ addOpenSystemTraceSystemInclude();
+
+ mmpFileModified = true;
+ }
+ }
+
+ /**
+ * Add layer SYSTEMINCLUDE macro to MMP file if needed
+ *
+ */
+ private void addOpenSystemTraceSystemInclude() {
+
+ if (CarbideBuilderPlugin.getBuildManager().isCarbideProject(
+ openProjectObject)
+ && openProjectObject.isAccessible()) {
+ ICarbideProjectInfo cpi = CarbideBuilderPlugin.getBuildManager()
+ .getProjectInfo(openProjectObject);
+ if (cpi != null) {
+
+ // loop through all build configurations since the list of mmp's
+ // could be different depending on the build configuration
+ for (ICarbideBuildConfiguration config : cpi
+ .getBuildConfigurations()) {
+
+ // loop through each mmp file and add the include path if
+ // necessary
+ for (final IPath mmpPath : EpocEngineHelper
+ .getMMPFilesForBuildConfiguration(config)) {
+ final IPath epocroot = WorkbenchUtils
+ .getEpocRootForProject(openProjectObject);
+ String mmpFilePath = epocroot.toOSString()
+ + mmpPath.toOSString();
+ try {
+ // Open the file mmp file
+ FileInputStream fistream = new FileInputStream(
+ mmpFilePath);
+
+ // Get the object of DataInputStream
+ DataInputStream in = new DataInputStream(fistream);
+ BufferedReader br = new BufferedReader(
+ new InputStreamReader(in));
+
+ // Read File Line By Line
+ String strLine;
+ int numberOfLastIncludeLine = 0;
+ boolean headerExist = false;
+ int headerEnd = -1;
+ int line = 0;
+ boolean platformPathsIncludeFound = false;
+ boolean layerSystemIncludeMacroFound = false;
+ Vector<String> mmpFileContent = new Vector<String>();
+ while ((strLine = br.readLine()) != null) {
+ mmpFileContent.add(strLine);
+ line++;
+ strLine = strLine.toUpperCase();
+
+ // Check does MMP file start with file header
+ if (line == 1) {
+ if (strLine
+ .indexOf(MULTILINE_COMMENT_START) != -1) {
+ headerExist = true;
+ } else if (strLine.indexOf(COMMENT) != -1) {
+ headerExist = true;
+ headerEnd = line;
+ }
+ }
+
+ // Get header end, if MMP file starts with file
+ // header that is made by using multiline
+ // comment
+ if (strLine.indexOf(MULTILINE_COMMENT_END) != -1
+ && headerExist && headerEnd == -1) {
+ headerEnd = line;
+ }
+
+ // Get header end, if MMP file starts with file
+ // header that is made by using single
+ // comments
+ if (strLine.indexOf(COMMENT) != -1
+ && headerExist && headerEnd == line - 1) {
+ headerEnd = line;
+ }
+
+ // Get line of last include statement
+ if (strLine.indexOf(INCLUDE) != -1) {
+ numberOfLastIncludeLine = line;
+ }
+
+ // Check does platform_patsh.hrh include already
+ // exist
+ if (strLine.indexOf(PLATFORM_PATHS_HRH) != -1) {
+ platformPathsIncludeFound = true;
+ }
+
+ // Check does layer system include macro already
+ // exist
+ if (strLine
+ .indexOf(APP_LAYER_SYSTEMINCLUDE_MACRO) != -1
+ || strLine
+ .indexOf(MW_LAYER_SYSTEMINCLUDE_MACRO) != -1
+ || strLine
+ .indexOf(OS_LAYER_SYSTEMINCLUDE_MACRO) != -1) {
+ layerSystemIncludeMacroFound = true;
+ break;
+ }
+ }
+
+ // If includes did not exist, but file header exist,
+ // then set number of last include line same as
+ // header end.
+ if (headerExist
+ && numberOfLastIncludeLine < headerEnd) {
+ numberOfLastIncludeLine = headerEnd;
+ }
+
+ // Close the buffered reader
+ br.close();
+
+ // Close the input stream
+ in.close();
+
+ // Close file input stream
+ fistream.close();
+
+ if (!layerSystemIncludeMacroFound) {
+ String layerSystemIncludeMacro = geLayerSystemIncludeMacro(mmpPath
+ .toOSString());
+ FileOutputStream fostream = new FileOutputStream(
+ mmpFilePath);
+ BufferedWriter bw = new BufferedWriter(
+ new OutputStreamWriter(fostream));
+
+ for (line = 0; line < mmpFileContent.size(); line++) {
+ if (line == numberOfLastIncludeLine) {
+ if (!platformPathsIncludeFound) {
+ bw
+ .write(INCLUDE_PLATFORM_PATHS_HRH
+ + SourceConstants.LINE_FEED);
+ }
+ bw.write(SourceConstants.LINE_FEED
+ + layerSystemIncludeMacro
+ + SourceConstants.LINE_FEED);
+ }
+ bw.write(mmpFileContent.get(line)
+ + SourceConstants.LINE_FEED);
+ }
+
+ // Close the buffered writer
+ bw.close();
+
+ // Close file output stream
+ fostream.close();
+ }
+ } catch (Exception e) {// Catch exception if any
+ CarbideBuilderPlugin.log(e);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Get correct layer system include macro
+ *
+ * @param string
+ * MMP path as OS string
+ *
+ * @return correct layer system include macro
+ */
+ private String geLayerSystemIncludeMacro(String mmpPathAsOsString) {
+ String layerSystemIncludeMacro = APP_LAYER_SYSTEMINCLUDE_MACRO;
+ String firstDirectory = mmpPathAsOsString.substring(0,
+ mmpPathAsOsString.indexOf(SourceConstants.BACKSLASH));
+
+ if (firstDirectory.equalsIgnoreCase(SF_FOLDER_NAME)) {
+ String secondDirectory = mmpPathAsOsString.substring(firstDirectory
+ .length() + 1, mmpPathAsOsString.indexOf(
+ SourceConstants.BACKSLASH, firstDirectory.length() + 1));
+ if (secondDirectory.equalsIgnoreCase(MW_FOLDER_NAME)) {
+ layerSystemIncludeMacro = MW_LAYER_SYSTEMINCLUDE_MACRO;
+ } else if (secondDirectory.equalsIgnoreCase(OS_FOLDER_NAME)) {
+ layerSystemIncludeMacro = OS_LAYER_SYSTEMINCLUDE_MACRO;
+ }
+ } else if (firstDirectory.equalsIgnoreCase(NCP_SW_FOLDER_NAME)) {
+ layerSystemIncludeMacro = OS_LAYER_SYSTEMINCLUDE_MACRO;
+ }
+
+ return layerSystemIncludeMacro;
+ }
+
+ /**
+ * Adds traces folder include to MMP files
+ *
+ * @param path
+ * file path
+ */
+ private void addTracesFolderInclude(Path filePath) {
+ IPath mainProjectPath = openProjectObject.getLocation();
+ IPath traceProjectPath = new Path(openProjectPath);
+
+ // Calculate and remove matching segments
+ int matchingSegs = mainProjectPath
+ .matchingFirstSegments(traceProjectPath);
+
+ IPath projectRelativePath = traceProjectPath
+ .removeFirstSegments(matchingSegs);
+
+ // Add Traces directory and remove device ID
+ projectRelativePath = projectRelativePath
+ .append(ProjectEngine.traceFolderName);
+ projectRelativePath = projectRelativePath.setDevice(null);
+
+ // Add include path to the project MMP files
+ addUserIncludeToMmpFiles(filePath, projectRelativePath);
+ }
+
+ /**
+ * Get Carbide project info
+ *
+ * @return Carbide project info
+ */
+ private ICarbideProjectInfo getCarbideProjectInfo() {
+ ICarbideProjectInfo cpi = null;
+ if (CarbideBuilderPlugin.getBuildManager().isCarbideProject(
+ openProjectObject)
+ && openProjectObject.isAccessible()) {
+ cpi = CarbideBuilderPlugin.getBuildManager().getProjectInfo(
+ openProjectObject);
+ }
+ return cpi;
+ }
+
+ /**
+ * Add user include to MMP files, those uses specific source file
+ *
+ * @param filePath
+ * file path of the saved source file
+ * @param projectRelativeIncDirPath
+ * project relative path to the include directory
+ */
+ private void addUserIncludeToMmpFiles(final IPath filePath,
+ final IPath projectRelativeIncDirPath) {
+ if (openProjectObject != null && projectRelativeIncDirPath != null) {
+
+ final IPath epocroot = WorkbenchUtils
+ .getEpocRootForProject(openProjectObject);
+
+ ICarbideProjectInfo cpi = getCarbideProjectInfo();
+
+ // Loop through all build configurations since the list of
+ // mmp's could be different depending on the build
+ // configuration
+ for (ICarbideBuildConfiguration config : cpi
+ .getBuildConfigurations()) {
+
+ // Get name of the MMP files where source file is used
+ final List<IPath> mmpPaths = EpocEngineHelper.getMMPsForSource(
+ openProjectObject, filePath);
+ ArrayList<String> sourceMmpFileNames = new ArrayList<String>();
+ for (int i = 0; i < mmpPaths.size(); i++) {
+ sourceMmpFileNames.add(mmpPaths.get(i).lastSegment());
+ }
+
+ // Go through build configuration's MMP files
+ for (final IPath mmpPath : EpocEngineHelper
+ .getMMPFilesForBuildConfiguration(config)) {
+
+ String mmpFileName = mmpPath.lastSegment();
+
+ if (sourceMmpFileNames.contains(mmpFileName)) {
+
+ EpocEnginePlugin.runWithMMPView(mmpPath,
+ new DefaultMMPViewConfiguration(config,
+ new AcceptedNodesViewFilter()),
+ new MMPViewRunnableAdapter() {
+
+ public Object run(IMMPView view) {
+ MMPViewPathHelper helper = new MMPViewPathHelper(
+ view, epocroot);
+ try {
+
+ // Convert the project relative path
+ // to an mmp view path
+ IPath incPath = helper
+ .convertProjectOrFullPathToMMP(
+ EMMPPathContext.USERINCLUDE, // CodForChk_Dis_LengthyLine
+ projectRelativeIncDirPath); // CodForChk_Dis_LengthyLine
+
+ // Get the list of user include
+ // paths and add it if it's not
+ // already there
+ List<IPath> userIncludes = view
+ .getUserIncludes();
+
+ String incPathAsOSString = incPath
+ .toOSString();
+
+ boolean includeExist = false;
+
+ // Go through existing userincludes
+ // to check if the path to add is
+ // already present
+ for (int i = 0; i < userIncludes
+ .size(); i++) {
+ String pathAsOSString = userIncludes
+ .get(i).toOSString();
+ pathAsOSString = pathAsOSString
+ .toLowerCase();
+ if (pathAsOSString
+ .equalsIgnoreCase(incPathAsOSString)) {
+ includeExist = true;
+ break;
+ }
+ }
+
+ if (!includeExist) {
+ userIncludes.add(incPath);
+ WorkbenchUtils
+ .postUserIncludeMsg(mmpPath);
+
+ // Now commit the changes and
+ // release the file
+ while (true) {
+ try {
+ view.commit();
+ break;
+ } catch (IllegalStateException e) {
+ CarbideBuilderPlugin
+ .log(e);
+ if (!view.merge()) {
+ view.revert();
+ }
+ }
+ }
+ }
+
+ } catch (InvalidDriveInMMPPathException e) {
+
+ // Shouldn't get here; we passed in
+ // a project-relative path
+ CarbideBuilderPlugin.log(e);
+ }
+
+ return null;
+ }
+ });
+ }
+ }
+ }
+ }
+ }
+}
\ No newline at end of file