contikimotetype.java

Contiki是一个开源

    Pattern pattern = Pattern.compile(GUI
        .getExternalToolsSetting("COMMAND_VAR_NAME_ADDRESS"));
    for (String commandLine : commandData) {
      Matcher matcher = pattern.matcher(commandLine);

      if (matcher.find()) {
        // logger.debug("Parsing line: " + commandLine);
        String varName = matcher.group(2);
        int varAddress = Integer.parseInt(matcher.group(1), 16);

        if (!varAddresses.containsKey(varName)) {
          nrNew++;
          varAddresses.put(varName, new Integer(varAddress));
        } else {
          int oldAddress = (Integer) varAddresses.get(varName);
          if (oldAddress != varAddress) {
            logger.warn("Warning, command response not matching previous entry of: "
                + varName);
            nrMismatch++;
          }

          nrOld++;
        }
      }
    }

    if (nrMismatch > 0) {
      logger.debug("Command response parsing summary: Added " + nrNew
          + " variables. Found " + nrOld
          + " old variables. MISMATCHING ADDRESSES: " + nrMismatch);
    } else {
      logger.debug("Command response parsing summary: Added " + nrNew
          + " variables. Found " + nrOld + " old variables");
    }

    return (nrNew + nrOld) > 0;
  }

  /**
   * Copy core memory to given memory. This should not be used directly, but
   * instead via ContikiMote.getMemory().
   *
   * @param mem
   *          Memory to set
   */
  public void getCoreMemory(SectionMoteMemory mem) {
    for (int i = 0; i < mem.getNumberOfSections(); i++) {
      int startAddr = mem.getStartAddrOfSection(i);
      int size = mem.getSizeOfSection(i);
      byte[] data = mem.getDataOfSection(i);

      getCoreMemory(startAddr + offsetRelToAbs, size, data);
    }
  }

  public String getIdentifier() {
    return identifier;
  }

  public void setIdentifier(String identifier) {
    logger.warn("Contiki mote type is read-only");
  }

  /**
   * @param using
   *          Core library has system symbols information
   */
  public void setHasSystemSymbols(boolean using) {
    hasSystemSymbols = using;
  }

  /**
   * @return Whether core library has system symbols information
   */
  public boolean hasSystemSymbols() {
    return hasSystemSymbols;
  }

  /**
   * @param commStack
   *          Communication stack
   */
  public void setCommunicationStack(CommunicationStack commStack) {
    this.commStack = commStack;
  }

  /**
   * @return Contiki communication stack
   */
  public CommunicationStack getCommunicationStack() {
    return commStack;
  }

  /**
   * @return Contiki mote type's library class name
   */
  public String getLibraryClassName() {
    return libraryClassName;
  }

  /**
   * Get relative address of variable with given name.
   *
   * @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) {
    int varAddr;
    String varAddrString;
    if ((varAddrString = varAddresses.getProperty(varName)) != null) {
      varAddr = Integer.parseInt(varAddrString);
      return varAddr;
    }

    String regExp = GUI.getExternalToolsSetting("MAPFILE_VAR_ADDRESS_1")
        + varName + GUI.getExternalToolsSetting("MAPFILE_VAR_ADDRESS_2");
    String retString = getFirstMatchGroup(mapFileData, regExp, 1);

    if (retString != null) {
      varAddresses.setProperty(varName, Integer.toString(Integer.parseInt(
          retString.trim(), 16)));
      return Integer.parseInt(retString.trim(), 16);
    } else {
      return -1;
    }
  }

  private int getReferenceAbsAddr() {
    return myCoreComm.getReferenceAbsAddr();
  }

  private void getCoreMemory(int start, int length, byte[] data) {
    myCoreComm.getMemory(start, length, data);
  }

  private void setCoreMemory(int start, int length, byte[] mem) {
    myCoreComm.setMemory(start, length, mem);
  }

  private static String getFirstMatchGroup(Vector<String> lines, String regexp,
      int groupNr) {
    Pattern pattern = Pattern.compile(regexp);
    for (int i = 0; i < lines.size(); i++) {
      Matcher matcher = pattern.matcher(lines.elementAt(i));
      if (matcher.find()) {
        return matcher.group(groupNr);
      }
    }
    return null;
  }

  /**
   * Returns all variable names in both data and BSS section by parsing the map
   * file. These values should not be trusted completely as the parsing may
   * fail.
   *
   * @return Variable names found in the data and bss section
   */
  public static Vector<String> getMapFileVarNames(Vector<String> mapFileData) {

    Vector<String> varNames = getAllVariableNames(mapFileData,
        loadRelDataSectionAddr(mapFileData),
        loadRelDataSectionAddr(mapFileData) + loadDataSectionSize(mapFileData));

    varNames.addAll(getAllVariableNames(mapFileData,
        loadRelBssSectionAddr(mapFileData), loadRelBssSectionAddr(mapFileData)
            + loadBssSectionSize(mapFileData)));

    return varNames;
  }

  public static Vector<String> getAllVariableNames(Vector<String> lines,
      int startAddress, int endAddress) {
    Vector<String> varNames = new Vector<String>();

    Pattern pattern = Pattern.compile(GUI
        .getExternalToolsSetting("MAPFILE_VAR_NAME"));
    for (int i = 0; i < lines.size(); i++) {
      Matcher matcher = pattern.matcher(lines.elementAt(i));
      if (matcher.find()) {
        if (Integer.decode(matcher.group(1)).intValue() >= startAddress
            && Integer.decode(matcher.group(1)).intValue() <= endAddress) {
          varNames.add(matcher.group(2));
        }
      }
    }
    return varNames;
  }

  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"));
    for (int i = 0; i < lines.size(); i++) {
      Matcher matcher = pattern.matcher(lines.elementAt(i));
      if (matcher.find()) {
        return Integer.decode(matcher.group(1));
      }
    }
    return -1;
  }

  public static int loadRelDataSectionAddr(Vector<String> mapFileData) {
    String retString = getFirstMatchGroup(mapFileData, GUI
        .getExternalToolsSetting("MAPFILE_DATA_START"), 1);

    if (retString != null) {
      return Integer.parseInt(retString.trim(), 16);
    } else {
      return -1;
    }
  }

  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 {
      return -1;
    }
  }

  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 {
      return -1;
    }
  }

  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 {
      return -1;
    }
  }

  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 {
      return -1;
    }
  }

  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 {
      return -1;
    }

    retString = getFirstMatchGroup(commandData, GUI
        .getExternalToolsSetting("COMMAND_DATA_END"), 1);
    if (retString != null) {
      end = Integer.parseInt(retString.trim(), 16);
    } else {
      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");
    String retString = getFirstMatchGroup(mapFileData, regExp, 1);

    if (retString != null) {
      return Integer.parseInt(retString.trim(), 16);
    } else {
      return -1;
    }
  }

  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);
      return null;
    }

    return mapFileData;
  }

  /**
   * Executes parse command on given file and returns the result.
   *
   * @param libraryFile
   *          File
   * @return Execution response
   */
  public static Vector<String> loadCommandData(File libraryFile) {
    Vector<String> commandData = new Vector<String>();

    try {
      String command = GUI.getExternalToolsSetting("PARSE_COMMAND");

      if (command == null) {
        return null;
      }

      // Prepare command
      command = command.replace("$(LIBFILE)", libraryFile.getPath().replace(File.separatorChar, '/'));

      String line;
      Process p = Runtime.getRuntime().exec(command.split(" "));
      BufferedReader input = new BufferedReader(new InputStreamReader(p
          .getInputStream()));
      p.getErrorStream().close(); // Ignore error stream
      while ((line = input.readLine()) != null) {
        commandData.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("")) {
        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();
    } catch (Exception err) {
      err.printStackTrace();
      return null;
    }

    if (objdumpData == null || objdumpData.size() == 0) {
      return null;
    }

    return objdumpData;
  }

  /**
   * Returns simulation holding this mote type
   *
   * @return Simulation
   */
  public Simulation getSimulation() {
    return mySimulation;
  }

  /**
   * Sets simulation holding this mote type
   *
   * @param simulation
   *          Simulation holding this mote type
   */
  public void setSimulation(Simulation simulation) {
    mySimulation = simulation;
  }

  public String getDescription() {
    return description;
  }

  public void setDescription(String newDescription) {
    description = newDescription;
  }

  /**
   * Returns path to contiki base dir
   *
   * @return String containing path
   */
  public String getContikiBaseDir() {
    return contikiBaseDir;
  }

  /**
   * Sets contiki base dir to path.
   *
   * @param path
   *          Contiki base dir