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<String> 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<String> 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<String> mapFileData,
+  public static boolean parseMapFileData(String[] mapFileData,
       Properties varAddresses) {
-    Vector<String> 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<String> 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<String> 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<String> 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<String> getMapFileVarNames(Vector<String> mapFileData) {
+  public static String[] getMapFileVarNames(String[] mapFileData) {
+    ArrayList<String> varNames = new ArrayList<String>();
 
-    Vector<String> 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<String> getAllVariableNames(Vector<String> lines,
+  public static String[] getAllVariableNames(String[] lines,
       int startAddress, int endAddress) {
-    Vector<String> varNames = new Vector<String>();
+    ArrayList<String> varNames = new ArrayList<String>();
 
-    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<String> 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<String> 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<String> 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<String> 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<String> 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<String> 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<String> 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<String> 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<String> 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<String> 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<String> loadMapFile(File mapFile) {
-    Vector<String> mapFileData = new Vector<String>();
-
-    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<String> loadCommandData(File libraryFile) {
-    Vector<String> commandData = new Vector<String>();
+  public static String[] loadCommandData(File libraryFile) {
+    ArrayList<String> output = new ArrayList<String>();
 
     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<String> loadObjdumpData(File libraryFile) {
-    Vector<String> objdumpData = new Vector<String>();
-
-    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);
     }