Package org.eclipse.cdt.core.envvar

Examples of org.eclipse.cdt.core.envvar.EnvironmentVariable


      }

      // set warning levels default on
      IEnvironmentVariableManager envManager = CCorePlugin.getDefault().getBuildEnvironmentManager();
      IContributedEnvironment contribEnv = envManager.getContributedEnvironment();
      IEnvironmentVariable var = new EnvironmentVariable(ArduinoConst.ENV_KEY_JANTJE_WARNING_LEVEL, ArduinoConst.ENV_KEY_WARNING_LEVEL_ON);
      contribEnv.addVariable(var, cfgd.getConfiguration());

      prjDesc.setActiveConfiguration(defaultConfigDescription);
      prjDesc.setCdtProjectCreated();
      CoreModel.getDefault().getProjectDescriptionManager().setProjectDescription(project, prjDesc, true, null);
View Full Code Here


     */
    private static void setTheEnvironmentVariablesSetTheDefaults(IContributedEnvironment contribEnv, ICConfigurationDescription confDesc,
      IPath platformFile) {
  // Set some default values because the platform.txt does not contain
  // them
  IEnvironmentVariable var = new EnvironmentVariable(ENV_KEY_ARDUINO_PATH, getArduinoPath().toString());
  contribEnv.addVariable(var, confDesc);

  // from 1.5.3 onwards 3 more environment variables need to be added
  var = new EnvironmentVariable(ENV_KEY_ARCHITECTURE, platformFile.removeLastSegments(1).lastSegment());
  contribEnv.addVariable(var, confDesc);
  var = new EnvironmentVariable(ENV_KEY_BUILD_ARCH, platformFile.removeLastSegments(1).lastSegment().toUpperCase());
  contribEnv.addVariable(var, confDesc);
  var = new EnvironmentVariable(ENV_KEY_HARDWARE_PATH, platformFile.removeLastSegments(3).toString());
  contribEnv.addVariable(var, confDesc);

  // from 1.5.8 onward 1 more environment variable is needed
  var = new EnvironmentVariable(ENV_KEY_PLATFORM_PATH, platformFile.removeLastSegments(1).toString());
  contribEnv.addVariable(var, confDesc);

  // I'm not sure why but till now arduino refused to put this in the platform.txt file
  // I won't call them idiots for this but it is getting close
  var = new EnvironmentVariable(ENV_KEY_SOFTWARE, "ARDUINO");
  contribEnv.addVariable(var, confDesc);
  var = new EnvironmentVariable(ENV_KEY_runtime_ide_version, GetARDUINODefineValue());
  contribEnv.addVariable(var, confDesc);
  // End of section permitting denigrating remarks on arduino software development team

  // // Arduino uses the board approach for the upload tool.
  // // as I'm not I create some special entries to work around it
  // var = new EnvironmentVariable("A.CMD", makeEnvironmentVar("A.TOOLS.BOSSAC.CMD"));
  // contribEnv.addVariable(var, confDesc);
  // var = new EnvironmentVariable("A.PATH", makeEnvironmentVar("A.TOOLS.BOSSAC.PATH"));
  // contribEnv.addVariable(var, confDesc);
  // var = new EnvironmentVariable("A.CMD.PATH", makeEnvironmentVar("A.TOOLS.AVRDUDE.CMD.PATH"));
  // contribEnv.addVariable(var, confDesc);
  // var = new EnvironmentVariable("A.CONFIG.PATH", makeEnvironmentVar("A.TOOLS.AVRDUDE.CONFIG.PATH"));
  // contribEnv.addVariable(var, confDesc); // End of section Arduino uses
  // // the board approach for the
  // // upload tool.

  // For Teensy I added a flag that allows to compile everything in one
  // project not using the archiving functionality
  // I set the default value to: use the archiver
  var = new EnvironmentVariable(ENV_KEY_use_archiver, "true");
  contribEnv.addVariable(var, confDesc);
  // End of Teensy specific settings

  if (platformFile.segment(platformFile.segmentCount() - 2).equals("avr")) {
      var = new EnvironmentVariable(ENV_KEY_compiler_path, makeEnvironmentVar("A.RUNTIME.IDE.PATH") + "/hardware/tools/avr/bin/");
      contribEnv.addVariable(var, confDesc);
  } else if (platformFile.segment(platformFile.segmentCount() - 2).equals("sam")) {
      var = new EnvironmentVariable(ENV_KEY_build_system_path, makeEnvironmentVar("A.RUNTIME.IDE.PATH") + "/hardware/arduino/sam/system");
      contribEnv.addVariable(var, confDesc);
      var = new EnvironmentVariable(ENV_KEY_build_generic_path, makeEnvironmentVar("A.RUNTIME.IDE.PATH")
        + "/hardware/tools/g++_arm_none_eabi/arm-none-eabi/bin");
      contribEnv.addVariable(var, confDesc);
  }

  // some glue to make it work
  String extraPathForOS = "";
  if (Platform.getWS().equals(Platform.WS_WIN32)) {
      extraPathForOS = "${PathDelimiter}${" + ENV_KEY_ARDUINO_PATH + "}/hardware/tools/avr/utils/bin${PathDelimiter}${" + ENV_KEY_ARDUINO_PATH
        + "}";
  }
  var = new EnvironmentVariable("PATH", "${A.COMPILER.PATH}${PathDelimiter}${" + ENV_KEY_build_generic_path + "}" + extraPathForOS
    + "${PathDelimiter}${PATH}");
  contribEnv.addVariable(var, confDesc);

  var = new EnvironmentVariable(ENV_KEY_build_path, "${ProjDirPath}/${ConfigName}");
  contribEnv.addVariable(var, confDesc);

  var = new EnvironmentVariable(ENV_KEY_build_project_name, makeEnvironmentVar("ProjName"));
  contribEnv.addVariable(var, confDesc);

  // if (firstTime) {
  if (getBuildEnvironmentVariable(confDesc, ENV_KEY_JANTJE_SIZE_SWITCH, "").isEmpty()) {
      var = new EnvironmentVariable(ENV_KEY_JANTJE_SIZE_SWITCH, makeEnvironmentVar(ENV_KEY_recipe_size_pattern));
      contribEnv.addVariable(var, confDesc);
  }
  if (getBuildEnvironmentVariable(confDesc, ENV_KEY_JANTJE_SIZE_COMMAND, "").isEmpty()) {
      var = new EnvironmentVariable(ENV_KEY_JANTJE_SIZE_COMMAND, JANTJE_SIZE_COMMAND);
      contribEnv.addVariable(var, confDesc);
  }

  // Set the warning level default off like arduino does
  if (getBuildEnvironmentVariable(confDesc, ENV_KEY_JANTJE_WARNING_LEVEL, "").isEmpty()) {
      var = new EnvironmentVariable(ENV_KEY_JANTJE_WARNING_LEVEL, ENV_KEY_WARNING_LEVEL_OFF);
      contribEnv.addVariable(var, confDesc);
  }

  var = new EnvironmentVariable(ENV_KEY_archive_file, "arduino.ar");
  contribEnv.addVariable(var, confDesc);

  IPathVariableManager pathMan = confDesc.getProjectDescription().getProject().getPathVariableManager();
  URI buildVariantURI = pathMan.getURIValue(ArduinoConst.PATH_VARIABLE_NAME_ARDUINO_PINS);
  buildVariantURI = pathMan.resolveURI(buildVariantURI);
  String buildVariantPath = buildVariantURI.getPath() + "/${" + ArduinoConst.ENV_KEY_build_variant + "}";
  var = new EnvironmentVariable(ENV_KEY_build_variant_path, buildVariantPath);
  contribEnv.addVariable(var, confDesc);
  // IPath platformPath = new Path(arduinoProperties.getPlatformFolder());
  // IPath PinPath = platformPath.append(ArduinoConst.VARIANTS_FOLDER);

    }
View Full Code Here

      if (RealData.length > 0) {
    String Var[] = RealData[0].split("=", 2); // look for assignment
    if (Var.length == 2) {
        String Value = MakeEnvironmentString(Var[1].replace("\"{build.path}/syscalls_sam3.c.o\"",
          "\"{build.path}/arduino/syscalls_sam3.c.o\""));
        var = new EnvironmentVariable(MakeKeyString(Var[0]), Value);
        contribEnv.addVariable(var, confDesc);
    }
      }
  }
  dataInputStream.close(); // Close the platform.txt
View Full Code Here

  for (Entry<String, String> currentPair : boardSectionMap.entrySet()) {
      // if it is not a menu item add it
      if (!currentPair.getKey().startsWith("menu.")) {
    String keyString = MakeKeyString(currentPair.getKey());
    String valueString = MakeEnvironmentString(currentPair.getValue());
    contribEnv.addVariable(new EnvironmentVariable(keyString, valueString), confDesc);
      } else {

    String[] keySplit = currentPair.getKey().split("\\.");
    String menuID = keySplit[1];
    String menuItemID = keySplit[2];
    if (isThisMenuItemSelected(boardsFile, confDesc, boardID, menuID, menuItemID)) {
        // we also need to skip the name
        String StartValue = "menu." + menuID + "." + menuItemID + ".";
        if (currentPair.getKey().startsWith(StartValue)) {
      String keyString = MakeKeyString(currentPair.getKey().substring(StartValue.length()));
      String valueString = MakeEnvironmentString(currentPair.getValue());
      contribEnv.addVariable(new EnvironmentVariable(keyString, valueString), confDesc);
        }
    }
      }
  }

  Map<String, String> menuSectionMap = boardsFile.getSection("menu");
  String[] optionNames = boardsFile.getMenuNames();
  for (int currentOption = 0; currentOption < optionNames.length; currentOption++) {
      String optionName = optionNames[currentOption];
      String optionValue = getBuildEnvironmentVariable(confDesc, ArduinoConst.ENV_KEY_JANTJE_START + optionName, "");
      if (!optionValue.isEmpty()) {
    String optionValueID = null;
    String optionID = null;
    // Look for the option ID
    for (Entry<String, String> curOption : menuSectionMap.entrySet()) {
        if (curOption.getValue().equals(optionName)) {
      String[] keySplit = curOption.getKey().split("\\.");
      if (keySplit.length == 1)
          optionID = keySplit[0];
        }
    }
    if (optionID != null) { // we have the option ID lets look for
          // the option value ID
        for (Entry<String, String> curOption : menuSectionMap.entrySet()) {
      if (curOption.getValue().equals(optionValue)) {
          String[] keySplit = curOption.getKey().split("\\.");
          if (keySplit.length == 3 && keySplit[0].equals(optionID) && keySplit[1].equals(boardID))
        optionValueID = keySplit[2];
      }
        }
    }
    if (optionValueID != null) // now we have all the info to find
             // the key value pairs for the
             // environment vars
    {
        // The arduino menu way
        String keyStartsWithValue = optionID + "." + boardID + "." + optionValueID + ".";
        for (Entry<String, String> curOption : menuSectionMap.entrySet()) {
      if (curOption.getKey().startsWith(keyStartsWithValue)) {
          String key = curOption.getKey().substring(keyStartsWithValue.length());
          contribEnv
            .addVariable(new EnvironmentVariable(MakeKeyString(key), MakeEnvironmentString(curOption.getValue())), confDesc);
      }
        }

    }
      }
View Full Code Here

      String recipe = getBuildEnvironmentVariable(confDesc, recipes[curRecipe], "", false);

      String recipeParts[] = recipe.split("(\"\\$\\{A.OBJECT_FILE}\")|(\\$\\{A.OBJECT_FILES})|(\"\\$\\{A.SOURCE_FILE}\")", 3);
      switch (recipeParts.length) {
      case 0:
    var = new EnvironmentVariable(recipes[curRecipe] + ".1", "echo no command for " + recipes[curRecipe]);
    contribEnv.addVariable(var, confDesc);
    break;
      case 1:
    var = new EnvironmentVariable(recipes[curRecipe] + ".1", recipeParts[0]);
    contribEnv.addVariable(var, confDesc);
    break;
      case 2:
    var = new EnvironmentVariable(recipes[curRecipe] + ".1", recipeParts[0]);
    contribEnv.addVariable(var, confDesc);
    var = new EnvironmentVariable(recipes[curRecipe] + ".2", recipeParts[1]);
    contribEnv.addVariable(var, confDesc);
    break;
      case 3:
    var = new EnvironmentVariable(recipes[curRecipe] + ".1", recipeParts[0]);
    contribEnv.addVariable(var, confDesc);
    var = new EnvironmentVariable(recipes[curRecipe] + ".2", recipeParts[1]);
    contribEnv.addVariable(var, confDesc);
    var = new EnvironmentVariable(recipes[curRecipe] + ".3", recipeParts[2]);
    contribEnv.addVariable(var, confDesc);
    break;
      default:
    // this should never happen as the split is limited to 2

      }

  }
  var = new EnvironmentVariable(ArduinoConst.ENV_KEY_SOFTWARE, "ARDUINO");
  contribEnv.addVariable(var, confDesc);
  String uploadProg = ArduinoInstancePreferences.getLastUsedUploadProgrammer();
  // If the user selected a different upload protocol replace the protocol with the selected one
  if (!uploadProg.equals(ArduinoConst.DEFAULT)) {
      var = new EnvironmentVariable(ArduinoConst.ENV_KEY_ARDUINO_UPLOAD_PROTOCOL, uploadProg);
      contribEnv.addVariable(var, confDesc);
  }

  // Arduino uses the board approach for the upload tool.
  // as I'm not I create some special entries to work around it
  String uploadTool = contribEnv.getVariable(ArduinoConst.ENV_KEY_upload_tool, confDesc).getValue().toUpperCase();
  var = new EnvironmentVariable("A.CMD", makeEnvironmentVar("A.TOOLS." + uploadTool + ".CMD"));
  contribEnv.addVariable(var, confDesc);
  var = new EnvironmentVariable("A.PATH", makeEnvironmentVar("A.TOOLS." + uploadTool + ".PATH"));
  contribEnv.addVariable(var, confDesc);
  var = new EnvironmentVariable("A.CMD.PATH", makeEnvironmentVar("A.TOOLS." + uploadTool + ".CMD.PATH"));
  contribEnv.addVariable(var, confDesc);
  var = new EnvironmentVariable("A.CONFIG.PATH", makeEnvironmentVar("A.TOOLS." + uploadTool + ".CONFIG.PATH"));
  contribEnv.addVariable(var, confDesc); // End of section Arduino uses
                 // the board approach for the
                 // upload tool.

    }
View Full Code Here

  IEnvironmentVariable original = null;
  IEnvironmentVariable replacement = null;

  original = envManager.getVariable(ENV_KEY_ARDUINO_START + "COMPILER.C.FLAGS", confDesc, true);
  if (original != null) {
      replacement = new EnvironmentVariable(original.getName(), original.getValue().replace("-g", "-g2").replace("-Os", ""),
        original.getOperation(), original.getDelimiter());
      contribEnv.addVariable(replacement, confDesc);
  }

  original = envManager.getVariable(ENV_KEY_ARDUINO_START + "COMPILER.CPP.FLAGS", confDesc, true);
  if (original != null) {
      replacement = new EnvironmentVariable(original.getName(), original.getValue().replace("-g", "-g2").replace("-Os", ""),
        original.getOperation(), original.getDelimiter());
      contribEnv.addVariable(replacement, confDesc);
  }
    }
View Full Code Here

        IEnvironmentVariableManager envManager = CCorePlugin
          .getDefault().getBuildEnvironmentManager();
        IContributedEnvironment contribEnv = envManager
          .getContributedEnvironment();
        if (myWarningLevel.getSelection() == true) {
      IEnvironmentVariable var = new EnvironmentVariable(
        ArduinoConst.ENV_KEY_JANTJE_WARNING_LEVEL,
        ArduinoConst.ENV_KEY_WARNING_LEVEL_ON);
      contribEnv.addVariable(var, getResDesc()
        .getConfiguration());
        } else {
      IEnvironmentVariable var = new EnvironmentVariable(
        ArduinoConst.ENV_KEY_JANTJE_WARNING_LEVEL,
        ArduinoConst.ENV_KEY_WARNING_LEVEL_OFF);
      contribEnv.addVariable(var, getResDesc()
        .getConfiguration());
        }
    }
      }
  });

  // checkbox show alternative size
  mySizeCommand = new Button(usercomp, SWT.CHECK);
  mySizeCommand.setText("Use alternative size command?");
  mySizeCommand.setEnabled(true);
  mySizeCommand.setLayoutData(new GridData(SWT.BEGINNING, SWT.BEGINNING,
    false, false, 2, 1));
  mySizeCommand.addListener(UPDATE, new Listener() {
      @Override
      public void handleEvent(Event e) {
    if (getResDesc().getConfiguration() != null) {
        IEnvironmentVariableManager envManager = CCorePlugin
          .getDefault().getBuildEnvironmentManager();
        IContributedEnvironment contribEnv = envManager
          .getContributedEnvironment();
        if (mySizeCommand.getSelection() == true) {
      IEnvironmentVariable var = new EnvironmentVariable(
        ArduinoConst.ENV_KEY_JANTJE_SIZE_SWITCH,
        "${" + ArduinoConst.ENV_KEY_JANTJE_SIZE_COMMAND
          + "}");
      contribEnv.addVariable(var, getResDesc()
        .getConfiguration());
        } else {
      IEnvironmentVariable var = new EnvironmentVariable(
        ArduinoConst.ENV_KEY_JANTJE_SIZE_SWITCH,
        "${" + ArduinoConst.ENV_KEY_recipe_size_pattern
          + "}");
      contribEnv.addVariable(var, getResDesc()
        .getConfiguration());
        }
    }
      }
  });

  createLine(usercomp, 2);
  // edit field add to C & C++ command line
  Label label = new Label(usercomp, SWT.LEFT);
  label.setText("append to C and C++ ");
  label.setLayoutData(new GridData(SWT.BEGINNING, SWT.BEGINNING, false,
    false, 1, 1));
  myCCppCommand = new Text(usercomp, SWT.SINGLE);
  myCCppCommand.setText("");
  myCCppCommand
    .setMessage("This command is added to the C and C++ compile command.");
  myCCppCommand.setEnabled(true);
  myCCppCommand.setLayoutData(new GridData(SWT.BEGINNING, SWT.BEGINNING,
    false, false, 1, 1));
  myCCppCommand.addModifyListener(new ModifyListener() {

      @Override
      public void modifyText(ModifyEvent e) {
    if (getResDesc().getConfiguration() != null) {
        IEnvironmentVariableManager envManager = CCorePlugin
          .getDefault().getBuildEnvironmentManager();
        IContributedEnvironment contribEnv = envManager
          .getContributedEnvironment();

        IEnvironmentVariable var = new EnvironmentVariable(
          ArduinoConst.ENV_KEY_JANTJE_ADDITIONAL_COMPILE_OPTIONS,
          myCCppCommand.getText());
        contribEnv
          .addVariable(var, getResDesc().getConfiguration());
    }

      }
  });

  // edit field add to C++ command line
  label = new Label(usercomp, SWT.LEFT);
  label.setText("append to C++ ");
  label.setLayoutData(new GridData(SWT.BEGINNING, SWT.BEGINNING, false,
    false, 1, 1));
  myCppCommand = new Text(usercomp, SWT.SINGLE);
  myCppCommand.setText("");
  myCppCommand
    .setMessage("This command is added to the C++ compile command.");
  myCppCommand.setEnabled(true);
  myCppCommand.setLayoutData(new GridData(SWT.BEGINNING, SWT.BEGINNING,
    false, false, 1, 1));
  myCppCommand.addModifyListener(new ModifyListener() {

      @Override
      public void modifyText(ModifyEvent e) {
    if (getResDesc().getConfiguration() != null) {
        IEnvironmentVariableManager envManager = CCorePlugin
          .getDefault().getBuildEnvironmentManager();
        IContributedEnvironment contribEnv = envManager
          .getContributedEnvironment();

        IEnvironmentVariable var = new EnvironmentVariable(
          ArduinoConst.ENV_KEY_JANTJE_ADDITIONAL_CPP_COMPILE_OPTIONS,
          myCppCommand.getText());
        contribEnv
          .addVariable(var, getResDesc().getConfiguration());
    }

      }
  });

  // edit field add to C command line
  label = new Label(usercomp, SWT.LEFT);
  label.setText("append to C ");
  label.setLayoutData(new GridData(SWT.BEGINNING, SWT.BEGINNING, false,
    false, 1, 1));
  myCCommand = new Text(usercomp, SWT.SINGLE);
  myCCommand.setText("");
  myCCommand
    .setMessage("This command is added to the C compile command.");
  myCCommand.setEnabled(true);
  myCCommand.setLayoutData(new GridData(SWT.BEGINNING, SWT.BEGINNING,
    false, false, 1, 1));
  myCCommand.addModifyListener(new ModifyListener() {

      @Override
      public void modifyText(ModifyEvent e) {
    if (getResDesc().getConfiguration() != null) {
        IEnvironmentVariableManager envManager = CCorePlugin
          .getDefault().getBuildEnvironmentManager();
        IContributedEnvironment contribEnv = envManager
          .getContributedEnvironment();

        IEnvironmentVariable var = new EnvironmentVariable(
          ArduinoConst.ENV_KEY_JANTJE_ADDITIONAL_C_COMPILE_OPTIONS,
          myCCommand.getText());
        contribEnv
          .addVariable(var, getResDesc().getConfiguration());
    }
View Full Code Here

      // Set the path variables
      IProject project = confdesc.getProjectDescription().getProject();
      IPath platformPath = new Path(new File(mControlBoardsTxtFile.getText().trim()).getParent()).append(ArduinoConst.PLATFORM_FILE_NAME);

      IEnvironmentVariable var = new EnvironmentVariable(ArduinoConst.ENV_KEY_JANTJE_BOARDS_FILE, boardFile);
      contribEnv.addVariable(var, confdesc);
      var = new EnvironmentVariable(ArduinoConst.ENV_KEY_JANTJE_BOARD_NAME, boardName);
      contribEnv.addVariable(var, confdesc);
      var = new EnvironmentVariable(ArduinoConst.ENV_KEY_JANTJE_COM_PORT, uploadPort);
      contribEnv.addVariable(var, confdesc);
      var = new EnvironmentVariable(ArduinoConst.ENV_KEY_JANTJE_COM_PROG, uploadProg);
      contribEnv.addVariable(var, confdesc);

      for (int curBoardFile = 0; curBoardFile < allBoardsFiles.length; curBoardFile++) {
    for (int curCombo = 0; curCombo < boardOptionCombos[curBoardFile].length; curCombo++) {
        String OptionName = (String) boardOptionCombos[curBoardFile][curCombo].mCombo.getData("Menu");
        var = new EnvironmentVariable(ArduinoConst.ENV_KEY_JANTJE_START + OptionName, "");
        contribEnv.addVariable(var, confdesc);
    }
      }

      for (int curCombo = 0; curCombo < boardOptionCombos[selectedBoardFile].length; curCombo++) {
    String OptionName = (String) boardOptionCombos[selectedBoardFile][curCombo].mCombo.getData("Menu");
    String optionValue = boardOptionCombos[selectedBoardFile][curCombo].mCombo.getText();
    var = new EnvironmentVariable(ArduinoConst.ENV_KEY_JANTJE_START + OptionName, optionValue);
    contribEnv.addVariable(var, confdesc);

      }

      // below are calculated values
      var = new EnvironmentVariable(ArduinoConst.ENV_KEY_JANTJE_PLATFORM_FILE, platformPath.toString());
      contribEnv.addVariable(var, confdesc);

      ArduinoHelpers.setProjectPathVariables(project, platformPath.removeLastSegments(1));
      ArduinoHelpers.setTheEnvironmentVariables(project, confdesc, false);
View Full Code Here

TOP

Related Classes of org.eclipse.cdt.core.envvar.EnvironmentVariable

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.