--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/sysperfana/analyzetoolext/com.nokia.s60tools.analyzetool/src/com/nokia/s60tools/analyzetool/global/Util.java Thu Feb 11 15:22:14 2010 +0200
@@ -0,0 +1,1271 @@
+/*
+ * Copyright (c) 2008-2009 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: Definitions for the class Util
+ *
+ */
+
+package com.nokia.s60tools.analyzetool.global;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.net.URL;
+import java.nio.channels.FileChannel;
+import java.util.AbstractList;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+import org.eclipse.cdt.core.model.ICModelMarker;
+import org.eclipse.core.resources.IMarker;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.FileLocator;
+import org.eclipse.core.runtime.IBundleGroup;
+import org.eclipse.core.runtime.IBundleGroupProvider;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.core.runtime.jobs.Job;
+import org.eclipse.jface.dialogs.MessageDialog;
+import org.eclipse.jface.preference.IPreferenceStore;
+import org.eclipse.jface.viewers.ArrayContentProvider;
+import org.eclipse.jface.viewers.LabelProvider;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.widgets.FileDialog;
+import org.eclipse.swt.widgets.Shell;
+import org.eclipse.ui.IWorkbenchPage;
+import org.eclipse.ui.IWorkbenchPart;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.dialogs.ListDialog;
+import org.osgi.framework.Bundle;
+
+import com.nokia.carbide.cdt.builder.CarbideBuilderPlugin;
+import com.nokia.carbide.cdt.builder.DefaultMMPViewConfiguration;
+import com.nokia.carbide.cdt.builder.EpocEngineHelper;
+import com.nokia.carbide.cdt.builder.builder.CarbideCPPBuilder;
+import com.nokia.carbide.cdt.builder.builder.CarbideCommandLauncher;
+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.model.mmp.EMMPStatement;
+import com.nokia.carbide.cpp.epoc.engine.model.mmp.IMMPData;
+import com.nokia.carbide.cpp.epoc.engine.preprocessor.AcceptedNodesViewFilter;
+import com.nokia.s60tools.analyzetool.Activator;
+import com.nokia.s60tools.analyzetool.builder.AnalyzeToolBuilder;
+import com.nokia.s60tools.analyzetool.engine.MMPInfo;
+import com.nokia.s60tools.analyzetool.engine.UseAtool;
+import com.nokia.s60tools.analyzetool.global.Constants.COMMAND_LINE_ERROR_CODE;
+
+/**
+ * Provides commonly used functions.
+ *
+ * @author kihe
+ *
+ */
+public class Util {
+
+ /** Contains user selection in the confirmation dialog. */
+ private static boolean ret;
+
+ /** Contains user selection (integer) in the selection dialog. */
+ private static int retValue;
+
+ /** Contains user selection (String) in the selection dialog. */
+ private static String userSelection = "";
+
+ /** Contains StringBuffer size. */
+ private static int bufferSize = 32;
+
+ /**
+ * Checks is module built.
+ *
+ * @param modules
+ * Project modules
+ * @param oneModuleName
+ * Current module
+ * @return True if module found and it is build
+ */
+ public static boolean chechModuleBuildState(
+ final AbstractList<MMPInfo> modules, final String oneModuleName) {
+ Iterator<MMPInfo> iterModules = modules.iterator();
+ while (iterModules.hasNext()) {
+ MMPInfo oneMMPInfo = iterModules.next();
+ String target = oneMMPInfo.getTarget();
+ if (target == null) {
+ continue;
+ } else if (oneMMPInfo.getTarget().equalsIgnoreCase(oneModuleName)) {
+ return oneMMPInfo.isBuildSuccesfully();
+ }
+
+ // target not found try remove {}
+ // for example process name is
+ // "AToolMemoryLeakerDll2.dll{000a0000}[04463b81]"
+ // but target name is AToolMemoryLeakerDll2.dll
+ CharSequence brace = "{";
+ if (oneModuleName.contains(brace)) {
+ // parse braces
+ String tmpTargetName = oneModuleName.substring(0, oneModuleName
+ .indexOf('{'));
+ if (tmpTargetName != null
+ && oneMMPInfo.getTarget().equalsIgnoreCase(
+ tmpTargetName)) {
+ return oneMMPInfo.isBuildSuccesfully();
+ }
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Checks is AnalyzeTool libraries installed from the current SDK.
+ *
+ * @param cpi
+ * {@link ICarbideProjectInfo} reference
+ * @return True if libraries are installed otherwise false.
+ */
+ public static boolean checkAtoolLibs(final ICarbideProjectInfo cpi) {
+ // get active platform
+ String platform = cpi.getDefaultConfiguration().getPlatformString();
+
+ // get epoc root
+ IPath epocRootPath = EpocEngineHelper.getEpocRootForProject(cpi.getProject());
+
+ //check that epocroot path found
+ if( epocRootPath == null ) {
+ return false;
+ }
+
+ String epocroot = epocRootPath.toOSString();
+ boolean found = true;
+ StringBuffer fileBuffer = new StringBuffer(bufferSize);
+ fileBuffer.append(Constants.CAN_NOT_FIND_LIBRARIES_MARKER);
+ fileBuffer.append(": ");
+ if ((Constants.BUILD_TARGET_WINSCW).equalsIgnoreCase(platform)) {
+ for (int i = 0; i < Constants.atoolLibsSbs2.length; i++) {
+ java.io.File file = new java.io.File(epocroot
+ + Constants.atoolLibsWinscw[i]);
+ if (!file.exists()) {
+ found = false;
+ fileBuffer.append(epocroot);
+ fileBuffer.append(Constants.atoolLibsWinscw[i]);
+ fileBuffer.append(' ');
+ }
+ }
+ } else if ((Constants.BUILD_TARGET_ARMV5).equalsIgnoreCase(platform)) {
+ if (AnalyzeToolBuilder.isSBSBuildActivated(cpi)) {
+ for (int i = 0; i < Constants.atoolLibsSbs2.length; i++) {
+ java.io.File file = new java.io.File(epocroot
+ + Constants.atoolLibsSbs2[i]);
+ if (!file.exists()) {
+ found = false;
+ fileBuffer.append(epocroot);
+ fileBuffer.append(Constants.atoolLibsSbs2[i]);
+ fileBuffer.append(' ');
+ }
+ }
+ } else {
+ for (int i = 0; i < Constants.atoolLibs.length; i++) {
+ java.io.File file = new java.io.File(epocroot
+ + Constants.atoolLibs[i]);
+ if (!file.exists()) {
+ found = false;
+ fileBuffer.append(epocroot);
+ fileBuffer.append(Constants.atoolLibs[i]);
+ fileBuffer.append(' ');
+ }
+ }
+ }
+ }
+ if (!found) {
+ createErrorMarker(cpi.getProject(), fileBuffer.toString());
+ }
+
+ return found;
+ }
+
+ /**
+ * Copies stored memory leak analysis file to given folder.
+ *
+ * @param resultFile
+ * Existing results file
+ * @param targetPath
+ * Where to save xml file
+ * @return True if copy success otherwise False
+ */
+ public static boolean copyFileToFolder(final String resultFile,
+ final String targetPath) {
+ FileChannel inputChannel = null;
+ FileChannel ouputChannel = null;
+ FileInputStream inStream = null;
+ FileOutputStream outStream = null;
+ boolean returnValue = true;
+ try {
+
+ // get channel to existing file
+ inStream = new FileInputStream(resultFile);
+ inputChannel = inStream.getChannel();
+
+ // get channel to new file
+ outStream = new FileOutputStream(targetPath, false);
+ ouputChannel = outStream.getChannel();
+
+ // get existing file size
+ final long size = inputChannel.size();
+
+ // position inside the file
+ long position = 0;
+
+ // copy file contents if there are data to copy
+ while (position < size) {
+ position += ouputChannel.transferFrom(inputChannel, position,
+ size - position);
+ }
+
+ // close opened channels
+ inputChannel.close();
+ inStream.close();
+ ouputChannel.close();
+ outStream.close();
+ } catch (FileNotFoundException fnfe) {
+ returnValue = false;
+ } catch (IOException ioe) {
+ returnValue = false;
+ } finally {
+ try {
+ if (inputChannel != null) {
+ inputChannel.close();
+ inputChannel = null;
+ }
+ } catch (IOException ioe) {
+ returnValue = false;
+ }
+
+ try {
+ if (inStream != null) {
+ inStream.close();
+ inStream = null;
+ }
+ } catch (IOException ioe) {
+ returnValue = false;
+ }
+
+ try {
+ if (ouputChannel != null) {
+ ouputChannel.close();
+ ouputChannel = null;
+ }
+ } catch (IOException ioe) {
+ returnValue = false;
+ }
+
+ try {
+ if (outStream != null) {
+ outStream.close();
+ outStream = null;
+ }
+ } catch (IOException ioe) {
+ returnValue = false;
+ }
+
+ }
+
+ return returnValue;
+ }
+
+ /**
+ * Creates AnalyzeTool related error marker for the selected project.
+ *
+ * @param project
+ * Project reference
+ * @param errorText
+ * Error information
+ */
+ public static void createErrorMarker(final IProject project,
+ final String errorText) {
+ try {
+ // check project validity
+ if (project == null || !project.isOpen()) {
+ return;
+ }
+
+ // create marker for the project
+ IMarker marker = project
+ .createMarker(ICModelMarker.C_MODEL_PROBLEM_MARKER);
+ if (marker.exists()) {
+ // set marker attributes
+ marker.setAttribute(IMarker.SEVERITY, IMarker.PRIORITY_HIGH);
+ marker.setAttribute(IMarker.TEXT, errorText);
+ marker.setAttribute(IMarker.MESSAGE, errorText);
+ }
+ } catch (CoreException ce) {
+ // #ifdef DEBUG
+ ce.printStackTrace();
+ // #endif
+ }
+ }
+
+ /**
+ * Deletes existing data file.
+ *
+ * @param project
+ * Project reference
+ */
+ public static void deleteDataFile(final IProject project) {
+ String bldInfFolder = getBldInfFolder(project, false);
+ String dataFileLocation = bldInfFolder + Constants.FILENAME;
+ java.io.File tmpFile = new java.io.File(dataFileLocation);
+ if (tmpFile.exists()) {
+ tmpFile.delete();
+ }
+
+ String xmlFileLocation = bldInfFolder + Constants.FILENAME_CARBIDE;
+ java.io.File tmpXMLFile = new java.io.File(xmlFileLocation);
+ if (tmpXMLFile.exists()) {
+ tmpXMLFile.delete();
+ }
+
+ tmpFile = null;
+ tmpXMLFile = null;
+ }
+
+
+ /**
+ * Open file save dialog.
+ *
+ * @param title
+ * Save dialog title
+ * @param ext
+ * Used extension filters
+ *
+ * @param shell
+ * Used Shell reference
+ *
+ * @return User selected path
+ */
+ public static String fileSaveDialog(final String title, final String[] ext,
+ final Shell shell) {
+ FileDialog fileDialog = new FileDialog(shell, SWT.SAVE);
+ fileDialog.setText(title);
+ fileDialog.setFilterExtensions(ext);
+ return fileDialog.open();
+
+ }
+
+ /**
+ * Gets atool.exe installation folder which is specified on preferences
+ * page.
+ *
+ * @return Atool.exe installation folder
+ */
+ public static String getAtoolInstallFolder() {
+ // get preference store
+ IPreferenceStore store = Activator.getPreferences();
+
+ // create new string buffer
+ StringBuffer atoolInstallFolder = new StringBuffer();
+
+ boolean useInternal = store.getBoolean(Constants.USE_INTERNAL);
+
+ // append atool.exe installation folder
+ String folder = store.getString(Constants.ATOOL_FOLDER);
+ if (useInternal) {
+ atoolInstallFolder.append(getDefaultAtoolLocation());
+ } else if (("").equals(folder)) {
+ store.setValue(Constants.USE_INTERNAL, true);
+ atoolInstallFolder.append(getDefaultAtoolLocation());
+ } else if (folder.equals(Constants.DEFAULT_ATOOL_FOLDER)) {
+ java.io.File file = new java.io.File(Constants.DEFAULT_ATOOL_FOLDER);
+ if (file.exists()) {
+ atoolInstallFolder.append(Constants.DEFAULT_ATOOL_FOLDER);
+ } else {
+ store.setValue(Constants.USE_INTERNAL, true);
+ atoolInstallFolder.append(getDefaultAtoolLocation());
+ }
+ } else {
+ atoolInstallFolder.append(folder);
+ }
+ // append atool.exe to installation path
+ atoolInstallFolder.append("\\atool.exe");
+ return atoolInstallFolder.toString();
+ }
+
+ /**
+ * Returns atool.exe version number Executes atool.exe via Process class and
+ * parses atool.exe output to get version number.
+ *
+ * @param path
+ * Atool.exe path
+ * @return Atool.exe version number if found otherwise "Not available"
+ */
+ public static String getAtoolVersionNumber(final String path) {
+
+ BufferedInputStream br = null;
+
+ try {
+ // used atool.exe location
+ String usedPath = null;
+
+ // if path not given => use default location
+ if (path == null) {
+ usedPath = getDefaultAtoolLocation() + "\\atool.exe";
+ }
+ else if( path.contains("atool.exe") ){
+ usedPath = path;
+ }
+ // else use given location
+ else {
+ usedPath = path + "\\atool.exe";
+ }
+
+ // command
+ String[] args = { "cmd", "/c", usedPath, "-v" };
+
+ // execute command
+ Process pr = Runtime.getRuntime().exec(args);
+
+ // get atool.exe response to buffer
+ br = new BufferedInputStream(pr
+ .getInputStream());
+
+ // wait that all the input is captured
+ pr.waitFor();
+
+ // create new stringbuffer for the input
+ StringBuffer bf = new StringBuffer("");
+ int r = -1;
+
+ // read atool.exe response to stringbufffer
+ while ((r = br.read()) != -1) {
+ bf.append((char) r);
+ }
+
+ // because atool.exe response is following format
+ // Version: [version number]
+ // Path: [location]
+ // Modified: [date and time]
+ // we only need to get first row of response
+ String[] array = bf.toString().split("\r\n");
+
+ // check array
+ if (array != null && array.length > 0) {
+
+ String version = "Version:";
+
+ // get first array
+ String versionStr = array[0];
+
+ // if first row contains "version:"
+ if (versionStr.contains(version)) {
+
+ // get atool.exe version number
+ String atoolVersionNbr = versionStr.substring(version
+ .length() + 1, versionStr.length());
+
+ if( atoolVersionNbr == null || ("").equals(atoolVersionNbr ) ) {
+ return Constants.PREFS_ATOOL_VER_NOT_FOUND;
+ }
+
+ return atoolVersionNbr;
+ }
+ }
+ br.close();
+ } catch (Exception e) {
+ e.printStackTrace();
+ } finally {
+ try {
+ if( br != null ) {
+ br.close();
+ br = null;
+ }
+ }catch( IOException ioe ) {
+ ioe.printStackTrace();
+ }
+
+ }
+ return Constants.PREFS_ATOOL_VER_NOT_FOUND;
+ }
+
+ /**
+ * Returns the version number of the AnalyzeTool host-side feature, or "Unknown" if it cannot be determined
+ * @return feature version string
+ */
+ public static String getAToolFeatureVersionNumber(){
+ String version = Constants.UNKNOWN;
+ IBundleGroupProvider[] providers = Platform.getBundleGroupProviders();
+ if (providers != null) {
+ for (IBundleGroupProvider bundleGroupProvider : providers) {
+ for (IBundleGroup feature : bundleGroupProvider.getBundleGroups()) {
+ if (feature.getIdentifier().equals("com.nokia.carbide.extensions.analyzetool")){
+ version = feature.getVersion();
+ break;
+ }
+ }
+ }
+ }
+ return version;
+ }
+
+ /**
+ * Gets project bld.inf folder path.
+ *
+ * @param project
+ * Project reference
+ * @param createTempFolder
+ * Flag to create atool_temp folder
+ * @return Project bld.inf folder path
+ */
+ public static String getBldInfFolder(final IProject project,
+ final boolean createTempFolder) {
+ // get bld.inf directory
+ ICarbideProjectInfo cpi = CarbideBuilderPlugin.getBuildManager()
+ .getProjectInfo(project);
+ if (cpi == null) {
+ return "";
+ }
+
+ String infDir = cpi.getINFWorkingDirectory().toOSString();
+
+ // create atool_temp folder if it does not exists
+ if (createTempFolder) {
+ UseAtool.createAToolFolderIfNeeded(infDir);
+ }
+
+ return infDir + "\\atool_temp\\";
+ }
+
+ /**
+ * Gets cpp file name and path.
+ *
+ * @param resource
+ * One resource file
+ * @return MMP file name and path if resource is mmp file, otherwise null
+ */
+ public static String getCPPFileNameAndPath(final IResource resource) {
+ // get file extension
+ String fileExt = resource.getFileExtension();
+ String cppFileAndPath = null;
+
+ // if file contains extension and it equals to mmp
+ if (fileExt != null && fileExt.compareTo("cpp") == 0) {
+ // get resource location/path
+ String resourcePath = resource.getLocation().toString();
+
+ // if resource path does not contain atool_temp folder
+ // save resource location
+ if (resourcePath.indexOf(Constants.ATOOL_TEMP) == -1) {
+ cppFileAndPath = resource.getProjectRelativePath().toString();
+ }
+
+ }
+
+ // return cpp file name and path
+ return cppFileAndPath;
+ }
+
+ /**
+ * Returns atool.exe location inside the plugin.
+ *
+ * @return Atool.exe location folder could be found otherwise ""
+ */
+ public static String getDefaultAtoolLocation() {
+ try {
+ // AnalyzeTool bundle
+ Bundle bunble = Platform
+ .getBundle("com.nokia.s60tools.analyzetool.corecomponents"); //$NON-NLS-1$
+
+ // if bundle not found return empty path
+ if( bunble == null ) {
+ return "";
+ }
+ // get bundle URL
+ URL bundleURL = bunble.getEntry("/");
+
+ // get file URL
+ URL fileURL = FileLocator.toFileURL(bundleURL);
+
+ // create new file
+ File file = new File(fileURL.getPath());
+
+ // if file exists return file path + atool.exe folder name
+ if (file.exists()) {
+ return file.getAbsolutePath();
+ }
+ return "";
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ return "";
+ }
+ }
+
+ /**
+ * Gets last slash index for current string.
+ *
+ * @param line
+ * Line where to find slash index
+ * @return Integer value of slash index
+ */
+ public static int getLastSlashIndex(final String line) {
+ // get last slash index
+ char slash = '/';
+ int slashIndex = line.lastIndexOf(slash);
+ if (slashIndex == -1) {
+ char backSlash = '\\';
+ slashIndex = line.lastIndexOf(backSlash);
+ }
+
+ return slashIndex;
+ }
+
+ /**
+ * Check is atool.exe available.
+ *
+ * @return True if atool.exe found otherwise False
+ */
+ public static boolean isAtoolAvailable() {
+ IPreferenceStore store = Activator.getPreferences();
+ String folderLocation = store.getString(Constants.ATOOL_FOLDER);
+
+ if (folderLocation.length() > 0) {
+ if (!folderLocation.endsWith("\\")) {
+ folderLocation += "\\";
+ }
+
+ IPath atoolPath = new Path(folderLocation + "atool.exe");
+
+ // if folder does not exists
+ if (atoolPath.toFile().exists()) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * Checks is data file available.
+ *
+ * @param project
+ * Project reference
+ * @return Data file path if it's available otherwise null
+ */
+ public static String isDataFileAvailable(final IProject project) {
+ String bldInfFolder = getBldInfFolder(project, false);
+ String dataFileLocation = bldInfFolder + Constants.FILENAME;
+ java.io.File dataFile = new java.io.File(dataFileLocation);
+ if (dataFile.exists() && dataFile.length() > 0 ) {
+ return dataFileLocation;
+ }
+ return null;
+ }
+
+ /**
+ * Checks is file extension .xml.
+ *
+ * @param filePath
+ * File location
+ * @return True if file contains xml extension otherwise false
+ */
+ public static boolean isFileXML(final String filePath) {
+ String fileNameAndExt = null;
+ // get index of last backslash
+ int index = Util.getLastSlashIndex(filePath);
+
+ // if backslash found
+ if (index != -1) {
+
+ // get file name
+ fileNameAndExt = filePath.substring(index + 1, filePath.length());
+
+ // if file name contains xml extension
+ if (fileNameAndExt.contains(".xml")) {
+ return true;
+ }
+ }
+ return false;
+
+ }
+
+ /**
+ * Check if current module is build.
+ *
+ * @param mmpFile
+ * MMP file name and path
+ * @return True if module is build otherwise False
+ */
+ public static boolean isModuleBuild(final String mmpFile) {
+ String path = null;
+ // remove mmp file name for path
+ int slash = Util.getLastSlashIndex(mmpFile);
+ if (slash == -1) {
+ return false;
+ }
+ path = mmpFile.substring(0, slash);
+ String buildFile = path + "\\atool_temp\\BuildComplete";
+ java.io.File file = new java.io.File(buildFile);
+ return file.exists();
+ }
+
+ /**
+ * Checks that belongs given module to selected project.
+ *
+ * @param modules
+ * Project modules
+ * @param oneModuleName
+ * One module name
+ * @return True if module belongs to selected project otherwise false
+ */
+ public static boolean isModulePartOfProject(
+ final AbstractList<MMPInfo> modules, final String oneModuleName) {
+ Iterator<MMPInfo> iterModules = modules.iterator();
+ while (iterModules.hasNext()) {
+ MMPInfo oneMMPInfo = iterModules.next();
+ String target = oneMMPInfo.getTarget();
+ if (target == null) {
+ continue;
+ } else if (oneMMPInfo.getTarget().equalsIgnoreCase(oneModuleName)) {
+ return true;
+ }
+
+ // target not found try remove {}
+ // for example process name is
+ // "AToolMemoryLeakerDll2.dll{000a0000}[04463b81]"
+ // but target name is AToolMemoryLeakerDll2.dll
+ CharSequence brace = "{";
+ if (oneModuleName.contains(brace)) {
+ // parse braces
+ String tmpTargetName = oneModuleName.substring(0, oneModuleName
+ .indexOf('{'));
+ if (tmpTargetName != null
+ && oneMMPInfo.getTarget().equalsIgnoreCase(
+ tmpTargetName)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Gets current project targets info.
+ *
+ * @param project
+ * Project reference
+ *
+ * @return AbstractList<MMPInfo> List of project targets
+ */
+ public static AbstractList<MMPInfo> loadProjectTargetsInfo(
+ final IProject project) {
+ AbstractList<MMPInfo> targets = new ArrayList<MMPInfo>();
+ if (project == null || !project.isOpen()) {
+ return targets;
+ }
+
+ // Assumes buildConfig (ICarbideBuildConfiguration) is known
+ ICarbideProjectInfo cpi = CarbideBuilderPlugin.getBuildManager()
+ .getProjectInfo(project);
+ if (cpi == null) {
+ return new ArrayList<MMPInfo>();
+ }
+
+ ICarbideBuildConfiguration buildConfig = cpi.getDefaultConfiguration();
+
+ for (IPath mmpPath : EpocEngineHelper
+ .getMMPFilesForBuildConfiguration(buildConfig)) {
+ Object data = EpocEnginePlugin.runWithMMPData(mmpPath,
+ new DefaultMMPViewConfiguration(buildConfig
+ .getCarbideProject().getProject(), buildConfig,
+ new AcceptedNodesViewFilter()),
+ new MMPDataRunnableAdapter() {
+ public Object run(IMMPData mmpData) {
+ // The real return value, getting a single argument
+ // setting
+ return mmpData.getSingleArgumentSettings().get(
+ EMMPStatement.TARGET);
+
+ }
+ });
+
+ // Make sure to test for and cast to proper Object type!
+ int index = Util.getLastSlashIndex(mmpPath.toOSString());
+ String mmpFileName = "";
+ if (index != -1) {
+ mmpFileName = mmpPath.toOSString().substring(index + 1,
+ mmpPath.toOSString().length());
+ }
+ MMPInfo oneMMPInfo = new MMPInfo(mmpFileName);
+ oneMMPInfo.setLocation(mmpPath.toOSString());
+
+ String mmpStatement = (String) data; // Now we should have the
+ // TARGETTYPE
+ oneMMPInfo.setTarget(mmpStatement);
+ targets.add(oneMMPInfo);
+ }
+ return targets;
+ }
+
+ /**
+ * Opens confirmation Dialog.
+ *
+ * @param text
+ * Dialog info text
+ * @return boolean True if user selects "Yes" False if user selects "No"
+ */
+ public static boolean openConfirmationDialog(final String text) {
+
+ Activator.getDefault().getWorkbench().getDisplay().syncExec(
+ new Runnable() {
+ public void run() {
+ ret = MessageDialog.openQuestion(new Shell(),
+ Constants.ANALYZE_TOOL_TITLE, text);
+ }
+ });
+ return ret;
+ }
+
+ /**
+ * Opens confirmation Dialog.
+ *
+ * @param text
+ * Dialog info text
+ * @return int User selected index
+ */
+ public static int openConfirmationDialogWithCancel(final String text) {
+
+ Activator.getDefault().getWorkbench().getDisplay().syncExec(
+ new Runnable() {
+ public void run() {
+
+ String[] labels = new String[3];
+ labels[0] = "Yes";
+ labels[1] = "No";
+ labels[2] = "Cancel";
+ MessageDialog mDialog = new MessageDialog(new Shell(),
+ Constants.ANALYZE_TOOL_TITLE, null, text, 0,
+ labels, 0);
+ mDialog.open();
+ mDialog.create();
+ retValue = mDialog.getReturnCode();
+ }
+ });
+ return retValue;
+ }
+
+ /**
+ * Opens console view.
+ */
+ public static void openConsoleView() {
+ // sync with UI thread
+ PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable(){
+ public void run() {
+
+ try {
+ // get active workspace page
+ IWorkbenchPage page = Activator.getDefault().getWorkbench()
+ .getActiveWorkbenchWindow().getActivePage();
+
+
+ // display main view
+ if (page != null) {
+ IWorkbenchPart part = page.getActivePart();
+
+
+ String activePageID = part.getSite().getId();
+
+ if( activePageID.equals(Constants.ANALYZE_TOOL_VIEW_ID) || part instanceof org.eclipse.ui.navigator.CommonNavigator) {
+ page
+ .showView(org.eclipse.ui.console.IConsoleConstants.ID_CONSOLE_VIEW);
+ }
+
+ }
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ });
+ }
+
+ /**
+ * Opens selection dialog.
+ *
+ * @param shell
+ * Shell reference
+ * @param title
+ * Dialog title
+ * @param defaultLocation
+ * Dialog default location
+ * @return User selection
+ */
+ public static String openFileDialog(final Shell shell, final String title,
+ final String defaultLocation) {
+ FileDialog fileDialog = new FileDialog(shell);
+ fileDialog.setText(title);
+ // set the file extension filter
+ String[] filterExt = { "*.*", "*.dat", "*.xml" };
+ fileDialog.setFilterExtensions(filterExt);
+
+ // fileDialog.setFilterPath( defaultLocation );
+ return fileDialog.open();
+ }
+
+ /**
+ * Opens selection dialog.
+ *
+ * @param title
+ * Dialog title
+ * @param message
+ * Dialog message text
+ * @param input
+ * Dialog input
+ * @return Selected item
+ */
+ public static String openSelectionDialog(final String title,
+ final String message, final AbstractList<String> input) {
+ Activator.getDefault().getWorkbench().getDisplay().syncExec(
+ new Runnable() {
+ public void run() {
+ userSelection = "";
+
+ ListDialog ld = new ListDialog(new Shell());
+ ld.setAddCancelButton(true);
+ ld.setContentProvider(new ArrayContentProvider());
+ ld.setLabelProvider(new LabelProvider());
+
+ int width = 0;
+ // calculate dialog width
+ for (int i = 0; i < input.size(); i++) {
+ String tempStr = input.get(i);
+
+ if (tempStr.length() > width) {
+ width = tempStr.length();
+ }
+ }
+
+ // set dialog width
+ // ld.setWidthInChars( width + 2 );
+ ld.setInput(input);
+ ld.setTitle(title);
+ if (message != null) {
+ ld.setMessage(message);
+ }
+
+ ld.setHelpAvailable(false);
+ ld.open();
+
+ Object[] objs = ld.getResult();
+ if (objs != null) {
+ userSelection = objs[0].toString();
+ }
+
+ }
+ });
+ return userSelection;
+ }
+
+ /**
+ * Displays error message.
+ *
+ * @param message
+ * Error note content
+ */
+ public static void showErrorMessage(final String message) {
+
+ PlatformUI.getWorkbench().getDisplay().asyncExec( new Runnable() {
+ public void run() {
+ MessageDialog
+ .openError(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), Constants.DIALOG_TITLE, message);
+ }
+ });
+
+ }
+
+ /**
+ * Displays information note.
+ *
+ * @param message
+ * Information note content
+ */
+ public static void showMessage(final String message) {
+
+ //sync with the UI thread
+ PlatformUI.getWorkbench().getDisplay().syncExec( new Runnable() {
+ public void run() {
+
+ MessageDialog
+ .openInformation(Activator.getDefault().getWorkbench()
+ .getDisplay().getActiveShell(), Constants.DIALOG_TITLE,
+ message);
+ }
+ });
+
+ }
+
+ /**
+ * Check is atool.exe verbose output checked.
+ *
+ * @return True verbose output is checked otherwise False
+ */
+ public static boolean verboseAtoolOutput() {
+ IPreferenceStore store = Activator.getPreferences();
+ return store.getBoolean(Constants.ATOOL_VERBOSE);
+ }
+
+ /**
+ * Creates progress dialog and clears atool.exe made changes.
+ *
+ * @param newProject
+ * Project reference
+ */
+ public final void clearAtoolChanges(final IProject newProject) {
+
+ // project reference
+ final IProject project = newProject;
+
+ Job cleanJob = new Job(Constants.PROGRESSDIALOG_CLEAR_CHANGES) {
+ @Override
+ protected IStatus run(IProgressMonitor monitor) {
+
+ // update progress monitor state
+ monitor.beginTask(Constants.PROGRESSDIALOG_CLEAR_CHANGES, IProgressMonitor.UNKNOWN);
+
+ // get project info
+ ICarbideProjectInfo cpi = CarbideBuilderPlugin
+ .getBuildManager().getProjectInfo(project);
+ if (cpi == null) {
+ return new Status(IStatus.OK, Constants.ANALYZE_CONSOLE_ID,
+ IStatus.OK,
+ Constants.PROGRESSDIALOG_CLEAN_COMPLETE, null);
+ }
+
+ // new command launcher
+ CarbideCommandLauncher cmdLauncher = new CarbideCommandLauncher(
+ project, monitor, Constants.atoolParserIds, cpi
+ .getINFWorkingDirectory());
+ cmdLauncher.startTimingStats();
+
+ cmdLauncher.showCommand(true);
+
+ cmdLauncher.writeToConsole(cmdLauncher.getTimingStats());
+
+ AbstractList<String> usedArguments = new ArrayList<String>();
+ usedArguments.add("-c");
+ if (Util.verboseAtoolOutput()) {
+ usedArguments.add(Constants.ATOOL_SHOW_DEBUG);
+ }
+
+ String[] arguments = new String[usedArguments.size()];
+ usedArguments.toArray(arguments);
+ int error = Constants.COMMAND_LINE_ERROR_CODE.OK.getCode();
+ error = cmdLauncher.executeCommand(new Path(Util
+ .getAtoolInstallFolder()), arguments,
+ CarbideCPPBuilder.getResolvedEnvVars(cpi
+ .getDefaultConfiguration()), cpi
+ .getINFWorkingDirectory());
+
+ // if command line engine returns some error code => display the error
+ if( error != Constants.COMMAND_LINE_ERROR_CODE.OK.getCode() ) {
+ Constants.COMMAND_LINE_ERROR_CODE errorCode = Util.getErrorCode(error);
+ Util.displayCommandLineError(errorCode);
+ }
+
+ return new Status(IStatus.OK, Constants.ANALYZE_CONSOLE_ID,
+ IStatus.OK, Constants.PROGRESSDIALOG_CLEAN_COMPLETE,
+ null);
+ }
+ };
+ cleanJob.setUser(true);
+ cleanJob.schedule();
+ }
+
+
+ /**
+ * Compares two atool.exe version numbers and returns
+ * higher one.
+ * @param firstVersion First version number
+ * @param secondVersion Second version number
+ * @return 0 if the first one is higher, 1 if the second one is higher otherwise -1
+ */
+ public static int compareVersionNumber(String firstVersion, String secondVersion)
+ {
+
+ // split version numbers
+ String first[] = firstVersion.split("[.]");
+ String second[] = secondVersion.split("[.]");
+
+ // check that version numbers contains valid formatting
+ if( first == null || second == null || first.length <1 || second.length < 1 || (first.length != second.length) ) {
+ return Constants.VERSION_NUMBERS_INVALID;
+ }
+ // if version number equals => no need to check which one is higher
+ if( firstVersion.equalsIgnoreCase(secondVersion) )
+ {
+ return Constants.VERSION_NUMBERS_EQUALS;
+ }
+ // thru splitted version number
+ for( int i=0; i<first.length; i++ ) {
+ try{
+ int firstNumber = Integer.parseInt( first[i] );
+ int secondNumber = Integer.parseInt( second[i] );
+
+ // if first and second given number equals => skip to next number
+ if( firstNumber == secondNumber ) {
+ continue;
+ }
+ else if( firstNumber > secondNumber ) {
+ return Constants.VERSION_NUMBERS_FIRST;
+ }
+ else {
+ return Constants.VERSION_NUMBERS_SECOND;
+ }
+
+ }catch(NumberFormatException nfe) {
+ nfe.printStackTrace();
+ return Constants.VERSION_NUMBERS_INVALID;
+ }
+ }
+ return Constants.VERSION_NUMBERS_INVALID;
+ }
+
+
+ /**
+ * Displays corresponding error message.
+ * @param errorCode Error code
+ */
+ public static final void displayCommandLineError( Constants.COMMAND_LINE_ERROR_CODE errorCode ) {
+ switch(errorCode) {
+ case EXECUTE_ERROR:
+ Util.showErrorMessage(Constants.ERROR_ATOOL_NOT_AVAILABLE);
+ break;
+ case OK:
+ // everything is OK, no need to do anything
+ break;
+
+ case INVALID_ARGUMENT_ERROR:
+ Util.showErrorMessage("AnalyzeTool tried to execute command line engine with invalid parameters. \n\nTo avoid this go to AnalyzeTool preference page and select \"Use internal " +
+ "command line engine\".");
+ Activator.getDefault().logInfo(IStatus.ERROR, IStatus.ERROR, "AnalyzeTool - Extension tried to execute command line engine with invalid parameters.");
+ break;
+
+ case CANNOT_FIND_EPOCROOT:
+ Util.showErrorMessage("AnalyzeTool can not find epocroot. \nCheck SDK preferences and build project again.");
+ Activator.getDefault().logInfo(IStatus.ERROR, IStatus.ERROR, "AnalyzeTool - Can not find epocroot.");
+ break;
+
+ case MAKEFILE_ERROR:
+ Util.showErrorMessage("AnalyzeTool command line engine fails to create makefiles.\n\nTry to clean AnalyzeTool changes and build project again." +
+ "\nIf problem still occurs contact AnalyzeTool development team.");
+ Activator.getDefault().logInfo(IStatus.ERROR, IStatus.ERROR, "AnalyzeTool - Make file error.");
+ break;
+
+ case NO_SUPPORTED_MODULES_ERROR:
+ Util.showErrorMessage("Project contains unsupported modules, this project could not build with AnalyzeTool!");
+ Activator.getDefault().logInfo(IStatus.ERROR, IStatus.ERROR, "AnalyzeTool - No supported modules error.");
+ break;
+
+ case WRONG_DATA_FILE_VERSION:
+ Util.showErrorMessage("Selected data file contains invalid version number. \nThis usually means that data file " +
+ "format is changed and AnalyzeTool command line engine can not resolve that. \n\nTry run tests again with the newest version of AnalyzeTool.");
+ Activator.getDefault().logInfo(IStatus.ERROR, IStatus.ERROR, "AnalyzeTool - Wrong data file version.");
+ break;
+
+ case ANALYZE_ERROR:
+ Util.showErrorMessage("AnalyzeTool can not analyze the selected data file.\nThis problem usually occurs when selected file contains corrupted AnalyzeTool data. \nTry to run " +
+ "tests again with the newest version of AnalyzeTool.");
+ Activator.getDefault().logInfo(IStatus.ERROR, IStatus.ERROR, "AnalyzeTool - General Analyze Error.");
+ break;
+
+ case SYMBOL_FILE_ERROR:
+ Util.showErrorMessage("AnalyzeTool can not resolve selected symbol file(s). \n\nGo to AnalyzeTool advanced preference page and check selected symbol file(s).");
+ Activator.getDefault().logInfo(IStatus.ERROR, IStatus.ERROR, "AnalyzeTool - Symbol file error.");
+ break;
+
+ case DATA_FILE_EMPTY:
+ Util.showErrorMessage("Can not analyze. \n\nSelected file is empty.");
+ Activator.getDefault().logInfo(IStatus.ERROR, IStatus.ERROR, "AnalyzeTool - Selected file is empty.");
+ break;
+
+ case DATA_FILE_INVALID:
+ Util.showErrorMessage("Can not analyze. \n\nSelected data file does not contain AnalyzeTool data.");
+ Activator.getDefault().logInfo(IStatus.ERROR, IStatus.ERROR, "AnalyzeTool - Invalid data file.");
+ break;
+
+ case RELEASABLES_ERROR:
+ Util.showErrorMessage("AnalyzeTool can not copy needed files, therefore callstack can not be displayed when analyzing data." +
+ "\n\nTry to clean AnalyzeTool made changes and build project again.");
+ Activator.getDefault().logInfo(IStatus.ERROR, IStatus.ERROR, "AnalyzeTool - Releasebles error.");
+ break;
+
+ case RESTORE_MODULES_ERROR:
+ Activator.getDefault().logInfo(IStatus.ERROR, IStatus.ERROR, "AnalyzeTool - Restore module error.");
+ break;
+
+ case CREATING_TEMP_CPP_ERROR:
+ Activator.getDefault().logInfo(IStatus.ERROR, IStatus.ERROR, "AnalyzeTool - Creating temp cpp file error.");
+ break;
+
+ case CLEANING_TEMP_ERROR:
+ Util.showErrorMessage("AnalyzeTool failed to clean project. You may have to clean changes manually.");
+ Activator.getDefault().logInfo(IStatus.ERROR, IStatus.ERROR, "AnalyzeTool - Clean error.");
+ break;
+
+ case READ_MAKEFILE_ERROR:
+ Util.showErrorMessage("AnalyzeTool command line engine can not read project make files. \n\nTry to clean AnalyzeTool" +
+ " made changes and build project again.");
+ Activator.getDefault().logInfo(IStatus.ERROR, IStatus.ERROR, "AnalyzeTool - Read make file error.");
+ break;
+
+ case MODIFY_MODULES_ERROR:
+ Util.showErrorMessage("AnalyzeTool command line engine can not modify project modules.");
+ Activator.getDefault().logInfo(IStatus.ERROR, IStatus.ERROR, "AnalyzeTool - Modify modules error.");
+ break;
+
+ case INVALID_MMP_DEFINED:
+ // I think this case is not possible in extension side.
+ // because we ask mmp files from Carbide
+ // however if this case happens we just log it Carbide error log
+ Activator.getDefault().logInfo(IStatus.ERROR, IStatus.ERROR, "AnalyzeTool - Invalid mmp file.");
+ break;
+
+ case UNKNOWN_ERROR:
+ Util.showErrorMessage("Unable to execute action for current project.");
+ Activator.getDefault().logInfo(IStatus.ERROR, IStatus.ERROR, "AnalyzeTool - unknown error.");
+ break;
+
+ }
+ }
+
+ /**
+ * Finds correct Enum value for integer value.
+ *
+ * @param value Value to find from enum values
+ * @return Enum value if found otherwise COMMAND_LINE_ERROR_CODE.UNKNOWN_ERROR
+ */
+ public static COMMAND_LINE_ERROR_CODE getErrorCode(final int value) {
+ for( COMMAND_LINE_ERROR_CODE errorCode : COMMAND_LINE_ERROR_CODE.values() ) {
+ if( errorCode.getCode() == value ) {
+ return errorCode;
+ }
+ }
+ return COMMAND_LINE_ERROR_CODE.UNKNOWN_ERROR;
+ }
+}