From efdb9f6e04b2aae730da2bc4be3ee0498c4a9c93 Mon Sep 17 00:00:00 2001 From: fros4943 Date: Wed, 20 Jan 2010 16:21:36 +0000 Subject: [PATCH] added support for a third optional memory section (currently only used on mac os x) + added section address parsing debugging output + removed unused code and + increased code readability --- .../cooja/contikimote/ContikiMoteType.java | 570 +++++++++--------- 1 file changed, 279 insertions(+), 291 deletions(-) diff --git a/tools/cooja/java/se/sics/cooja/contikimote/ContikiMoteType.java b/tools/cooja/java/se/sics/cooja/contikimote/ContikiMoteType.java index cfd84f367..3c5a4cd14 100644 --- a/tools/cooja/java/se/sics/cooja/contikimote/ContikiMoteType.java +++ b/tools/cooja/java/se/sics/cooja/contikimote/ContikiMoteType.java @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: ContikiMoteType.java,v 1.37 2009/06/03 17:27:37 fros4943 Exp $ + * $Id: ContikiMoteType.java,v 1.38 2010/01/20 16:21:36 fros4943 Exp $ */ package se.sics.cooja.contikimote; @@ -34,20 +34,46 @@ package se.sics.cooja.contikimote; import java.awt.BorderLayout; import java.awt.Container; import java.awt.Dimension; -import java.io.*; +import java.io.BufferedReader; +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; import java.lang.reflect.Method; -import java.security.*; -import java.util.*; -import java.util.regex.*; -import javax.swing.*; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Properties; +import java.util.Random; +import java.util.Vector; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import javax.swing.Box; +import javax.swing.BoxLayout; +import javax.swing.JLabel; +import javax.swing.JPanel; + import org.apache.log4j.Logger; import org.jdom.Element; -import se.sics.cooja.*; +import se.sics.cooja.AbstractionLevelDescription; +import se.sics.cooja.ClassDescription; +import se.sics.cooja.CoreComm; +import se.sics.cooja.GUI; +import se.sics.cooja.Mote; +import se.sics.cooja.MoteInterface; +import se.sics.cooja.MoteType; +import se.sics.cooja.ProjectConfig; +import se.sics.cooja.SectionMoteMemory; +import se.sics.cooja.Simulation; import se.sics.cooja.dialogs.CompileContiki; import se.sics.cooja.dialogs.ContikiMoteCompileDialog; import se.sics.cooja.dialogs.MessageList; import se.sics.cooja.dialogs.MessageList.MessageContainer; +import se.sics.cooja.util.StringUtils; /** * The Contiki mote type holds the native library used to communicate with an @@ -172,7 +198,7 @@ public class ContikiMoteType implements MoteType { // Type specific class configuration private ProjectConfig myConfig = null; - private int relAddressOfRefenceVariable = 0; + private int relAddressOfReferenceVariable = 0; private CoreComm myCoreComm = null; @@ -211,10 +237,6 @@ public class ContikiMoteType implements MoteType { return false; } - /* Load compiled library */ - doInit(); - return true; - } else { if (getIdentifier() == null) { throw new MoteTypeCreationException("No identifier specified"); @@ -328,11 +350,11 @@ public class ContikiMoteType implements MoteType { !getContikiFirmwareFile().exists()) { throw new MoteTypeCreationException("Contiki firmware file does not exist: " + getContikiFirmwareFile()); } - - /* Load compiled library */ - doInit(); - return true; } + + /* Load compiled library */ + doInit(); + return true; } public static File getExpectedFirmwareFile(File source) { @@ -350,7 +372,7 @@ public class ContikiMoteType implements MoteType { * * @throws MoteTypeCreationException */ - public void doInit() throws MoteTypeCreationException { + private void doInit() throws MoteTypeCreationException { if (myCoreComm != null) { throw new MoteTypeCreationException( @@ -370,90 +392,102 @@ public class ContikiMoteType implements MoteType { logger.info("Creating core communicator between Java class '" + javaClassName + "' and Contiki library '" + getContikiFirmwareFile().getName() + "'"); myCoreComm = CoreComm.createCoreComm(this.javaClassName, getContikiFirmwareFile()); - // Should we parse addresses using map file or command? + /* Parse addresses using map file or command */ boolean useCommand = Boolean.parseBoolean(GUI.getExternalToolsSetting("PARSE_WITH_COMMAND", "false")); - int relDataSectionAddr = -1; - int dataSectionSize = -1; - int relBssSectionAddr = -1; - int bssSectionSize = -1; + int dataSectionAddr = -1, dataSectionSize = -1; + int bssSectionAddr = -1, bssSectionSize = -1; + int commonSectionAddr = -1, commonSectionSize = -1; if (useCommand) { - // Parse command output - Vector commandData = loadCommandData(getContikiFirmwareFile()); - if (commandData == null) { - logger.fatal("No parse command output could be loaded"); + /* Parse command output */ + String[] output = loadCommandData(getContikiFirmwareFile()); + if (output == null) { throw new MoteTypeCreationException("No parse command output loaded"); } - - boolean parseOK = parseCommandData(commandData, varAddresses); + boolean parseOK = parseCommandData(output, varAddresses); if (!parseOK) { logger.fatal("Command output parsing failed"); throw new MoteTypeCreationException("Command output parsing failed"); } - relDataSectionAddr = loadCommandRelDataSectionAddr(commandData); - dataSectionSize = loadCommandDataSectionSize(commandData); - relBssSectionAddr = loadCommandRelBssSectionAddr(commandData); - bssSectionSize = loadCommandBssSectionSize(commandData); + dataSectionAddr = parseCommandDataSectionAddr(output); + dataSectionSize = parseCommandDataSectionSize(output); + bssSectionAddr = parseCommandBssSectionAddr(output); + bssSectionSize = parseCommandBssSectionSize(output); + commonSectionAddr = parseCommandCommonSectionAddr(output); + commonSectionSize = parseCommandCommonSectionSize(output); + } else { - // Parse map file + /* Parse command output */ if (mapFile == null || !mapFile.exists()) { - logger.fatal("Map file " + mapFile.getAbsolutePath() + " could not be found!"); - throw new MoteTypeCreationException("Map file " + mapFile.getAbsolutePath() + " could not be found!"); + throw new MoteTypeCreationException("Map file " + mapFile + " could not be found!"); } - - Vector mapData = loadMapFile(mapFile); + String[] mapData = loadMapFile(mapFile); if (mapData == null) { logger.fatal("No map data could be loaded"); - throw new MoteTypeCreationException("No map data could be loaded"); + throw new MoteTypeCreationException("No map data could be loaded: " + mapFile); } - boolean parseOK = parseMapFileData(mapData, varAddresses); if (!parseOK) { logger.fatal("Map data parsing failed"); - throw new MoteTypeCreationException("Map data parsing failed"); + throw new MoteTypeCreationException("Map data parsing failed: " + mapFile); } - relDataSectionAddr = loadRelDataSectionAddr(mapData); - dataSectionSize = loadDataSectionSize(mapData); - relBssSectionAddr = loadRelBssSectionAddr(mapData); - bssSectionSize = loadBssSectionSize(mapData); + dataSectionAddr = parseMapDataSectionAddr(mapData); + dataSectionSize = parseMapDataSectionSize(mapData); + bssSectionAddr = parseMapBssSectionAddr(mapData); + bssSectionSize = parseMapBssSectionSize(mapData); + commonSectionAddr = parseMapCommonSectionAddr(mapData); + commonSectionSize = parseMapCommonSectionSize(mapData); + } - // Create variable names to addresses mappings if (varAddresses.size() == 0) { - throw new MoteTypeCreationException( - "Variable name to addresses mappings could not be created"); + throw new MoteTypeCreationException("Library variables parsing failed"); } try { - // Get offset between relative and absolute addresses - relAddressOfRefenceVariable = (Integer) varAddresses.get("referenceVar"); + /* Relative <-> absolute addresses offset */ + relAddressOfReferenceVariable = (Integer) varAddresses.get("referenceVar"); } catch (Exception e) { throw (MoteTypeCreationException) new MoteTypeCreationException( "JNI call error: " + e.getMessage()).initCause(e); } - if (relDataSectionAddr <= 0 || dataSectionSize <= 0 - || relBssSectionAddr <= 0 || bssSectionSize <= 0) { - throw new MoteTypeCreationException( - "Could not parse section addresses correctly"); + if (dataSectionAddr <= 0 || dataSectionSize <= 0 + || bssSectionAddr <= 0 || bssSectionSize <= 0) { + throw new MoteTypeCreationException("Library section addresses parsing failed"); } - myCoreComm.setReferenceAddress(relAddressOfRefenceVariable); + myCoreComm.setReferenceAddress(relAddressOfReferenceVariable); - // Create initial memory - byte[] initialDataSection = new byte[dataSectionSize]; - getCoreMemory(relDataSectionAddr, dataSectionSize, - initialDataSection); - byte[] initialBssSection = new byte[bssSectionSize]; - getCoreMemory(relBssSectionAddr, bssSectionSize, - initialBssSection); + /* Create initial memory: data+bss+optional common */ initialMemory = new SectionMoteMemory(varAddresses); - initialMemory.setMemorySegment(relDataSectionAddr, initialDataSection); - initialMemory.setMemorySegment(relBssSectionAddr, initialBssSection); + + byte[] initialDataSection = new byte[dataSectionSize]; + getCoreMemory(dataSectionAddr, dataSectionSize, initialDataSection); + initialMemory.setMemorySegment(dataSectionAddr, initialDataSection); + logger.info(getContikiFirmwareFile().getName() + + ": data section at 0x" + Integer.toHexString(dataSectionAddr) + + " (0x" + dataSectionSize + " bytes)"); + + byte[] initialBssSection = new byte[bssSectionSize]; + getCoreMemory(bssSectionAddr, bssSectionSize, initialBssSection); + initialMemory.setMemorySegment(bssSectionAddr, initialBssSection); + logger.info(getContikiFirmwareFile().getName() + + ": BSS section at 0x" + Integer.toHexString(bssSectionAddr) + + " (0x" + bssSectionSize + " bytes)"); + + if (commonSectionAddr > 0 && commonSectionSize > 0) { + byte[] initialCommonSection = new byte[commonSectionSize]; + getCoreMemory(commonSectionAddr, commonSectionSize, initialCommonSection); + initialMemory.setMemorySegment(commonSectionAddr, initialCommonSection); + logger.info(getContikiFirmwareFile().getName() + + ": common section at 0x" + Integer.toHexString(commonSectionAddr) + + " (0x" + commonSectionSize + " bytes)"); + } } /** @@ -499,10 +533,10 @@ public class ContikiMoteType implements MoteType { * @param varAddresses * Properties that should contain the name to addresses mappings. */ - public static boolean parseMapFileData(Vector mapFileData, + public static boolean parseMapFileData(String[] mapFileData, Properties varAddresses) { - Vector varNames = getMapFileVarNames(mapFileData); - if (varNames == null || varNames.size() == 0) { + String[] varNames = getMapFileVarNames(mapFileData); + if (varNames == null || varNames.length == 0) { return false; } @@ -520,40 +554,36 @@ public class ContikiMoteType implements MoteType { } /** - * Parses specified parse command output for variable - * name to addresses mappings. The mappings are added - * to the given properties object. + * Parses parse command output for variable name to addresses mappings. + * The mappings are written to the given properties object. * - * @param commandData - * Output from parse command on object file - * @param varAddresses - * Properties that should contain the name to addresses mappings. + * @param output Command output + * @param addresses Variable addresses mappings */ - public static boolean parseCommandData(Vector commandData, - Properties varAddresses) { + public static boolean parseCommandData(String[] output, Properties addresses) { int nrNew = 0, nrOld = 0, nrMismatch = 0; - Pattern pattern = Pattern.compile(GUI - .getExternalToolsSetting("COMMAND_VAR_NAME_ADDRESS")); - for (String commandLine : commandData) { - Matcher matcher = pattern.matcher(commandLine); + Pattern pattern = + Pattern.compile(GUI.getExternalToolsSetting("COMMAND_VAR_NAME_ADDRESS")); + + for (String line : output) { + Matcher matcher = pattern.matcher(line); if (matcher.find()) { - // logger.debug("Parsing line: " + commandLine); - String varName = matcher.group(2); - int varAddress = Integer.parseInt(matcher.group(1), 16); + /* Line matched variable address */ + String symbol = matcher.group(2); + int address = Integer.parseInt(matcher.group(1), 16); - if (!varAddresses.containsKey(varName)) { + if (!addresses.containsKey(symbol)) { nrNew++; - varAddresses.put(varName, new Integer(varAddress)); + addresses.put(symbol, new Integer(address)); } else { - int oldAddress = (Integer) varAddresses.get(varName); - if (oldAddress != varAddress) { + int oldAddress = (Integer) addresses.get(symbol); + if (oldAddress != address) { /*logger.warn("Warning, command response not matching previous entry of: " + varName);*/ nrMismatch++; } - nrOld++; } } @@ -651,11 +681,10 @@ public class ContikiMoteType implements MoteType { /** * Get relative address of variable with given name. * - * @param varName - * Name of variable + * @param varName Name of variable * @return Relative memory address of variable or -1 if not found */ - public static int getMapFileVarAddress(Vector mapFileData, String varName, Properties varAddresses) { + public static int getMapFileVarAddress(String[] mapFileData, String varName, Properties varAddresses) { int varAddr; String varAddrString; if ((varAddrString = varAddresses.getProperty(varName)) != null) { @@ -663,8 +692,10 @@ public class ContikiMoteType implements MoteType { return varAddr; } - String regExp = GUI.getExternalToolsSetting("MAPFILE_VAR_ADDRESS_1") - + varName + GUI.getExternalToolsSetting("MAPFILE_VAR_ADDRESS_2"); + String regExp = + GUI.getExternalToolsSetting("MAPFILE_VAR_ADDRESS_1") + + varName + + GUI.getExternalToolsSetting("MAPFILE_VAR_ADDRESS_2"); String retString = getFirstMatchGroup(mapFileData, regExp, 1); if (retString != null) { @@ -684,11 +715,10 @@ public class ContikiMoteType implements MoteType { myCoreComm.setMemory(relAddr, length, mem); } - private static String getFirstMatchGroup(Vector lines, String regexp, - int groupNr) { + private static String getFirstMatchGroup(String[] lines, String regexp, int groupNr) { Pattern pattern = Pattern.compile(regexp); - for (int i = 0; i < lines.size(); i++) { - Matcher matcher = pattern.matcher(lines.get(i)); + for (String line : lines) { + Matcher matcher = pattern.matcher(line); if (matcher.find()) { return matcher.group(groupNr); } @@ -703,27 +733,35 @@ public class ContikiMoteType implements MoteType { * * @return Variable names found in the data and bss section */ - public static Vector getMapFileVarNames(Vector mapFileData) { + public static String[] getMapFileVarNames(String[] mapFileData) { + ArrayList varNames = new ArrayList(); - Vector varNames = getAllVariableNames(mapFileData, - loadRelDataSectionAddr(mapFileData), - loadRelDataSectionAddr(mapFileData) + loadDataSectionSize(mapFileData)); + String[] dataVariables = getAllVariableNames( + mapFileData, + parseMapDataSectionAddr(mapFileData), + parseMapDataSectionAddr(mapFileData) + parseMapDataSectionSize(mapFileData)); + for (String v: dataVariables) { + varNames.add(v); + } - varNames.addAll(getAllVariableNames(mapFileData, - loadRelBssSectionAddr(mapFileData), loadRelBssSectionAddr(mapFileData) - + loadBssSectionSize(mapFileData))); + String[] bssVariables = getAllVariableNames( + mapFileData, + parseMapBssSectionAddr(mapFileData), + parseMapBssSectionAddr(mapFileData) + parseMapBssSectionSize(mapFileData)); + for (String v: bssVariables) { + varNames.add(v); + } - return varNames; + return varNames.toArray(new String[0]); } - public static Vector getAllVariableNames(Vector lines, + public static String[] getAllVariableNames(String[] lines, int startAddress, int endAddress) { - Vector varNames = new Vector(); + ArrayList varNames = new ArrayList(); - Pattern pattern = Pattern.compile(GUI - .getExternalToolsSetting("MAPFILE_VAR_NAME")); - for (int i = 0; i < lines.size(); i++) { - Matcher matcher = pattern.matcher(lines.get(i)); + Pattern pattern = Pattern.compile(GUI.getExternalToolsSetting("MAPFILE_VAR_NAME")); + for (String line : lines) { + Matcher matcher = pattern.matcher(line); if (matcher.find()) { if (Integer.decode(matcher.group(1)).intValue() >= startAddress && Integer.decode(matcher.group(1)).intValue() <= endAddress) { @@ -731,13 +769,14 @@ public class ContikiMoteType implements MoteType { } } } - return varNames; + return varNames.toArray(new String[0]); } protected int getVariableSize(Vector lines, String varName) { - Pattern pattern = Pattern.compile(GUI - .getExternalToolsSetting("MAPFILE_VAR_SIZE_1") - + varName + GUI.getExternalToolsSetting("MAPFILE_VAR_SIZE_2")); + Pattern pattern = Pattern.compile( + GUI.getExternalToolsSetting("MAPFILE_VAR_SIZE_1") + + varName + + GUI.getExternalToolsSetting("MAPFILE_VAR_SIZE_2")); for (int i = 0; i < lines.size(); i++) { Matcher matcher = pattern.matcher(lines.get(i)); if (matcher.find()) { @@ -747,9 +786,9 @@ public class ContikiMoteType implements MoteType { return -1; } - public static int loadRelDataSectionAddr(Vector mapFileData) { - String retString = getFirstMatchGroup(mapFileData, GUI - .getExternalToolsSetting("MAPFILE_DATA_START"), 1); + private static int parseFirstHexInt(String regexp, String[] data) { + String retString = + getFirstMatchGroup(data, regexp, 1); if (retString != null) { return Integer.parseInt(retString.trim(), 16); @@ -758,110 +797,124 @@ public class ContikiMoteType implements MoteType { } } - public static int loadDataSectionSize(Vector mapFileData) { - String retString = getFirstMatchGroup(mapFileData, GUI - .getExternalToolsSetting("MAPFILE_DATA_SIZE"), 1); - - if (retString != null) { - return Integer.parseInt(retString.trim(), 16); - } else { + public static int parseMapDataSectionAddr(String[] mapFileData) { + String regexp = GUI.getExternalToolsSetting("MAPFILE_DATA_START", ""); + if (regexp.equals("")) { return -1; } + return parseFirstHexInt(regexp, mapFileData); + } + public static int parseMapDataSectionSize(String[] mapFileData) { + String regexp = GUI.getExternalToolsSetting("MAPFILE_DATA_SIZE", ""); + if (regexp.equals("")) { + return -1; + } + return parseFirstHexInt(regexp, mapFileData); + } + public static int parseMapBssSectionAddr(String[] mapFileData) { + String regexp = GUI.getExternalToolsSetting("MAPFILE_BSS_START", ""); + if (regexp.equals("")) { + return -1; + } + return parseFirstHexInt(regexp, mapFileData); + } + public static int parseMapBssSectionSize(String[] mapFileData) { + String regexp = GUI.getExternalToolsSetting("MAPFILE_BSS_SIZE", ""); + if (regexp.equals("")) { + return -1; + } + return parseFirstHexInt(regexp, mapFileData); + } + public static int parseMapCommonSectionAddr(String[] mapFileData) { + String regexp = GUI.getExternalToolsSetting("MAPFILE_COMMON_START", ""); + if (regexp.equals("")) { + return -1; + } + return parseFirstHexInt(regexp, mapFileData); + } + public static int parseMapCommonSectionSize(String[] mapFileData) { + String regexp = GUI.getExternalToolsSetting("MAPFILE_COMMON_SIZE", ""); + if (regexp.equals("")) { + return -1; + } + return parseFirstHexInt(regexp, mapFileData); } - public static int loadRelBssSectionAddr(Vector mapFileData) { - String retString = getFirstMatchGroup(mapFileData, GUI - .getExternalToolsSetting("MAPFILE_BSS_START"), 1); - - if (retString != null) { - return Integer.parseInt(retString.trim(), 16); - } else { + public static int parseCommandDataSectionAddr(String[] output) { + String regexp = GUI.getExternalToolsSetting("COMMAND_DATA_START", ""); + if (regexp.equals("")) { return -1; } + return parseFirstHexInt(regexp, output); } - - public static int loadBssSectionSize(Vector mapFileData) { - String retString = getFirstMatchGroup(mapFileData, GUI - .getExternalToolsSetting("MAPFILE_BSS_SIZE"), 1); - - if (retString != null) { - return Integer.parseInt(retString.trim(), 16); - } else { + public static int parseCommandDataSectionSize(String[] output) { + String regexp = GUI.getExternalToolsSetting("COMMAND_DATA_END", ""); + if (regexp.equals("")) { return -1; } + int start = parseCommandDataSectionAddr(output); + if (start < 0) { + return -1; + } + + int end = parseFirstHexInt(regexp, output); + if (end < 0) { + return -1; + } + return end - start; } - - public static int loadCommandRelDataSectionAddr(Vector commandData) { - String retString = getFirstMatchGroup(commandData, GUI - .getExternalToolsSetting("COMMAND_DATA_START"), 1); - - if (retString != null) { - return Integer.parseInt(retString.trim(), 16); - } else { + public static int parseCommandBssSectionAddr(String[] output) { + String regexp = GUI.getExternalToolsSetting("COMMAND_BSS_START", ""); + if (regexp.equals("")) { return -1; } + return parseFirstHexInt(regexp, output); } - - public static int loadCommandDataSectionSize(Vector commandData) { - String retString; - int start, end; - - retString = getFirstMatchGroup(commandData, GUI - .getExternalToolsSetting("COMMAND_DATA_START"), 1); - if (retString != null) { - start = Integer.parseInt(retString.trim(), 16); - } else { + public static int parseCommandBssSectionSize(String[] output) { + String regexp = GUI.getExternalToolsSetting("COMMAND_BSS_END", ""); + if (regexp.equals("")) { + return -1; + } + int start = parseCommandBssSectionAddr(output); + if (start < 0) { return -1; } - retString = getFirstMatchGroup(commandData, GUI - .getExternalToolsSetting("COMMAND_DATA_END"), 1); - if (retString != null) { - end = Integer.parseInt(retString.trim(), 16); - } else { + int end = parseFirstHexInt(regexp, output); + if (end < 0) { + return -1; + } + return end - start; + } + public static int parseCommandCommonSectionAddr(String[] output) { + String regexp = GUI.getExternalToolsSetting("COMMAND_COMMON_START", ""); + if (regexp.equals("")) { + return -1; + } + return parseFirstHexInt(regexp, output); + } + public static int parseCommandCommonSectionSize(String[] output) { + String regexp = GUI.getExternalToolsSetting("COMMAND_COMMON_END", ""); + if (regexp.equals("")) { + return -1; + } + int start = parseCommandCommonSectionAddr(output); + if (start < 0) { return -1; } + int end = parseFirstHexInt(regexp, output); + if (end < 0) { + return -1; + } return end - start; } - public static int loadCommandRelBssSectionAddr(Vector commandData) { - String retString = getFirstMatchGroup(commandData, GUI - .getExternalToolsSetting("COMMAND_BSS_START"), 1); - - if (retString != null) { - return Integer.parseInt(retString.trim(), 16); - } else { - return -1; - } - } - - public static int loadCommandBssSectionSize(Vector commandData) { - String retString; - int start, end; - - retString = getFirstMatchGroup(commandData, GUI - .getExternalToolsSetting("COMMAND_BSS_START"), 1); - if (retString != null) { - start = Integer.parseInt(retString.trim(), 16); - } else { - return -1; - } - - retString = getFirstMatchGroup(commandData, GUI - .getExternalToolsSetting("COMMAND_BSS_END"), 1); - if (retString != null) { - end = Integer.parseInt(retString.trim(), 16); - } else { - return -1; - } - - return end - start; - } - - private static int getRelVarAddr(Vector mapFileData, String varName) { - String regExp = GUI.getExternalToolsSetting("MAPFILE_VAR_ADDRESS_1") - + varName + GUI.getExternalToolsSetting("MAPFILE_VAR_ADDRESS_2"); + private static int getRelVarAddr(String mapFileData[], String varName) { + String regExp = + GUI.getExternalToolsSetting("MAPFILE_VAR_ADDRESS_1") + + varName + + GUI.getExternalToolsSetting("MAPFILE_VAR_ADDRESS_2"); String retString = getFirstMatchGroup(mapFileData, regExp, 1); if (retString != null) { @@ -871,122 +924,57 @@ public class ContikiMoteType implements MoteType { } } - public static Vector loadMapFile(File mapFile) { - Vector mapFileData = new Vector(); - - try { - BufferedReader in = new BufferedReader(new InputStreamReader( - new FileInputStream(mapFile))); - - while (in.ready()) { - mapFileData.add(in.readLine()); - } - } catch (FileNotFoundException e) { - logger.fatal("File not found: " + e); - return null; - } catch (IOException e) { - logger.fatal("IO error: " + e); + public static String[] loadMapFile(File mapFile) { + String contents = StringUtils.loadFromFile(mapFile); + if (contents == null) { return null; } - - return mapFileData; + return contents.split("\n"); } /** - * Executes parse command on given file and returns the result. + * Executes configured command on given file and returns the result. * - * @param libraryFile - * File - * @return Execution response + * @param libraryFile Contiki library + * @return Execution response, or null at failure */ - public static Vector loadCommandData(File libraryFile) { - Vector commandData = new Vector(); + public static String[] loadCommandData(File libraryFile) { + ArrayList output = new ArrayList(); try { String command = GUI.getExternalToolsSetting("PARSE_COMMAND"); - if (command == null) { return null; } - // Prepare command - command = command.replace("$(LIBFILE)", libraryFile.getName().replace(File.separatorChar, '/')); + /* Prepare command */ + command = command.replace("$(LIBFILE)", + libraryFile.getName().replace(File.separatorChar, '/')); + /* Execute command, read response */ String line; - Process p = Runtime.getRuntime().exec(command.split(" "), null, libraryFile.getParentFile()); - BufferedReader input = new BufferedReader(new InputStreamReader(p.getInputStream())); - p.getErrorStream().close(); // Ignore error stream + Process p = Runtime.getRuntime().exec( + command.split(" "), + null, + libraryFile.getParentFile() + ); + BufferedReader input = new BufferedReader( + new InputStreamReader(p.getInputStream()) + ); + p.getErrorStream().close(); while ((line = input.readLine()) != null) { - commandData.add(line); + output.add(line); } input.close(); - } catch (Exception err) { - err.printStackTrace(); - return null; - } - if (commandData == null || commandData.size() == 0) { - return null; - } - - return commandData; - } - - /** - * Runs external tool objdump on given file and returns the result. - * - * @param libraryFile - * File - * @return Execution response - */ - public static Vector loadObjdumpData(File libraryFile) { - Vector objdumpData = new Vector(); - - try { - String objdumpPath = GUI.getExternalToolsSetting("PATH_OBJDUMP"); - String objdumpArgs = GUI.getExternalToolsSetting("OBJDUMP_ARGS"); - - if (objdumpPath == null || objdumpPath.equals("")) { + if (output == null || output.size() == 0) { return null; } - - String[] objdumpExecArray; - if (!objdumpArgs.trim().equals("")) { - // Arguments need to be passed to program - String[] splittedObjdumpArgs = objdumpArgs.split(" "); - objdumpExecArray = new String[1 + splittedObjdumpArgs.length + 1]; - - objdumpExecArray[0] = objdumpPath.trim(); - - objdumpExecArray[objdumpExecArray.length - 1] = libraryFile - .getAbsolutePath(); - System.arraycopy(splittedObjdumpArgs, 0, objdumpExecArray, 1, - splittedObjdumpArgs.length); - } else { - objdumpExecArray = new String[2]; - objdumpExecArray[0] = objdumpPath.trim(); - objdumpExecArray[1] = libraryFile.getAbsolutePath(); - } - - String line; - Process p = Runtime.getRuntime().exec(objdumpExecArray); - BufferedReader input = new BufferedReader(new InputStreamReader(p - .getInputStream())); - p.getErrorStream().close(); // Ignore error stream - while ((line = input.readLine()) != null) { - objdumpData.add(line); - } - input.close(); + return output.toArray(new String[0]); } catch (Exception err) { - err.printStackTrace(); + logger.fatal("Command error: " + err.getMessage(), err); return null; } - - if (objdumpData == null || objdumpData.size() == 0) { - return null; - } - - return objdumpData; } public String getDescription() { @@ -1374,7 +1362,7 @@ public class ContikiMoteType implements MoteType { /* Guess compile commands */ String compileCommands = - "make " + getExpectedFirmwareFile(oldVersionSource).getName() + " TARGET=cooja"; + "make " + getExpectedFirmwareFile(oldVersionSource).getName() + " TARGET=cooja"; logger.info("Guessing compile commands: " + compileCommands); setCompileCommands(compileCommands); }