Esempio n. 1
0
  /**
   * Fetches code from the editor tabs and pre-processes it into parsable pure java source. And
   * there's a difference between parsable and compilable. XQPrerocessor.java makes this code
   * compilable. <br>
   * Handles:
   * <li>Removal of import statements
   * <li>Conversion of int(), char(), etc to (int)(), (char)(), etc.
   * <li>Replacing '#' with 0xff for color representation
   * <li>Converts all 'color' datatypes to int (experimental)
   * <li>Appends class declaration statement after determining the mode the sketch is in - ACTIVE or
   *     STATIC
   *
   * @return String - Pure java representation of PDE code. Note that this code is not yet compile
   *     ready.
   */
  private String preprocessCode() {

    String sourceAlt = "";
    programImports = new ArrayList<ImportStatement>();
    if (editor == null) {
      try {
        sourceAlt = readFile(PATH);
      } catch (IOException e) {
        e.printStackTrace();
      }
      System.out.println(sourceAlt);
      System.out.println("-----------PreProcessed----------");
      return sourceAlt;
    }
    // Super wicked regular expressions! (Used from Processing source)
    final Pattern FUNCTION_DECL =
        Pattern.compile(
            "(^|;)\\s*((public|private|protected|final|static)\\s+)*"
                + "(void|int|float|double|String|char|byte)"
                + "(\\s*\\[\\s*\\])?\\s+[a-zA-Z0-9]+\\s*\\(",
            Pattern.MULTILINE);

    // Handle code input from editor/java file
    try {
      if (editor == null) {
        System.out.println("Reading .java file: " + PATH);
      } else {
        rawCode = new StringBuffer();

        for (SketchCode sc : editor.getSketch().getCode()) {
          if (sc.isExtension("pde")) {
            sc.setPreprocOffset(scPreProcOffset);

            try {

              if (editor.getSketch().getCurrentCode().equals(sc)) {

                // rawCode.append(sc.getDocument().getText(0,
                // sc.getDocument().getLength()));
                rawCode.append(
                    scrapImportStatements(
                        sc.getDocument().getText(0, sc.getDocument().getLength()),
                        editor.getSketch().getCodeIndex(sc)));
              } else {

                // rawCode.append(sc.getProgram());
                rawCode.append(
                    scrapImportStatements(sc.getProgram(), editor.getSketch().getCodeIndex(sc)));
              }
              rawCode.append('\n');
            } catch (Exception e) {
              System.err.println("Exception in preprocessCode() - bigCode " + e.toString());
            }
            rawCode.append('\n');
            scPreProcOffset += sc.getLineCount();
          }
        }

        sourceAlt = rawCode.toString();
        // System.out.println("Obtaining source from editor.");
      }
    } catch (Exception e) {

      System.out.println("Exception in preprocessCode()");
    }

    // Replace comments with whitespaces
    // sourceAlt = scrubComments(sourceAlt);

    // Find all int(*), replace with PApplet.parseInt(*)

    // \bint\s*\(\s*\b , i.e all exclusive "int("

    String dataTypeFunc[] = {"int", "char", "float", "boolean", "byte"};
    for (String dataType : dataTypeFunc) {
      String dataTypeRegexp = "\\b" + dataType + "\\s*\\(";
      Pattern pattern = Pattern.compile(dataTypeRegexp);
      Matcher matcher = pattern.matcher(sourceAlt);

      // while (matcher.find()) {
      // System.out.print("Start index: " + matcher.start());
      // System.out.println(" End index: " + matcher.end() + " ");
      // System.out.println("-->" + matcher.group() + "<--");
      // }
      sourceAlt =
          matcher.replaceAll(
              "PApplet.parse"
                  + Character.toUpperCase(dataType.charAt(0))
                  + dataType.substring(1)
                  + "(");
    }

    // Find all #[web color] and replace with 0xff[webcolor]
    // Should be 6 digits only.
    final String webColorRegexp = "#{1}[A-F|a-f|0-9]{6}\\W";
    Pattern webPattern = Pattern.compile(webColorRegexp);
    Matcher webMatcher = webPattern.matcher(sourceAlt);
    while (webMatcher.find()) {
      // System.out.println("Found at: " + webMatcher.start());
      String found = sourceAlt.substring(webMatcher.start(), webMatcher.end());
      // System.out.println("-> " + found);
      sourceAlt = webMatcher.replaceFirst("0xff" + found.substring(1));
      webMatcher = webPattern.matcher(sourceAlt);
    }

    // TODO: Experimental.
    // Replace all color data types with int
    // Regex, Y U SO powerful?
    final String colorTypeRegex = "color(?![a-zA-Z0-9_])(?=\\[*)(?!(\\s*\\())";
    Pattern colorPattern = Pattern.compile(colorTypeRegex);
    Matcher colorMatcher = colorPattern.matcher(sourceAlt);
    sourceAlt = colorMatcher.replaceAll("int");

    checkForChangedImports();

    className = (editor == null) ? "DefaultClass" : editor.getSketch().getName();

    // Check whether the code is being written in STATIC mode(no function
    // declarations) - append class declaration and void setup() declaration
    Matcher matcher = FUNCTION_DECL.matcher(sourceAlt);
    if (!matcher.find()) {
      sourceAlt =
          "public class "
              + className
              + " extends PApplet {\n"
              + "public void setup() {\n"
              + sourceAlt
              + "\nnoLoop();\n}\n"
              + "\n}\n";
      staticMode = true;
      mainClassOffset = 2;

    } else {
      sourceAlt = "public class " + className + " extends PApplet {\n" + sourceAlt + "\n}";
      staticMode = false;
      mainClassOffset = 1;
    }

    // Handle unicode characters
    sourceAlt = substituteUnicode(sourceAlt);

    // System.out.println("-->\n" + sourceAlt + "\n<--");
    // System.out.println("PDE code processed - "
    // + editor.getSketch().getName());
    sourceCode = sourceAlt;
    return sourceAlt;
  }
Esempio n. 2
0
  /**
   * Calculates the tab number and line number of the error in that particular tab. Provides mapping
   * between pure java and pde code.
   *
   * @param problem - IProblem
   * @return int[0] - tab number, int[1] - line number
   */
  public int[] calculateTabIndexAndLineNumber(IProblem problem) {
    // String[] lines = {};// = PApplet.split(sourceString, '\n');
    int codeIndex = 0;
    int bigCount = 0;

    int x = problem.getSourceLineNumber() - mainClassOffset;
    if (x < 0) {
      // System.out.println("Negative line number "
      // + problem.getSourceLineNumber() + " , offset "
      // + mainClassOffset);
      x = problem.getSourceLineNumber() - 2; // Another -1 for 0 index
      if (x < programImports.size() && x >= 0) {
        ImportStatement is = programImports.get(x);
        // System.out.println(is.importName + ", " + is.tab + ", "
        // + is.lineNumber);
        return new int[] {is.tab, is.lineNumber};
      } else {

        // Some seriously ugly stray error, just can't find the source
        // line! Simply return first line for first tab.
        return new int[] {0, 1};
      }
    }

    try {
      for (SketchCode sc : editor.getSketch().getCode()) {
        if (sc.isExtension("pde")) {
          sc.setPreprocOffset(bigCount);
          int len = 0;
          if (editor.getSketch().getCurrentCode().equals(sc)) {
            len = Base.countLines(sc.getDocument().getText(0, sc.getDocument().getLength())) + 1;
          } else {
            len = Base.countLines(sc.getProgram()) + 1;
          }

          // System.out.println("x,len, CI: " + x + "," + len + ","
          // + codeIndex);

          if (x >= len) {

            // We're in the last tab and the line count is greater
            // than the no.
            // of lines in the tab,
            if (codeIndex >= editor.getSketch().getCodeCount() - 1) {
              // System.out.println("Exceeds lc " + x + "," + len
              // + problem.toString());
              // x = len
              x = editor.getSketch().getCode(codeIndex).getLineCount();
              // TODO: Obtain line having last non-white space
              // character in the code.
              break;
            } else {
              x -= len;
              codeIndex++;
            }
          } else {

            if (codeIndex >= editor.getSketch().getCodeCount())
              codeIndex = editor.getSketch().getCodeCount() - 1;
            break;
          }
        }
        bigCount += sc.getLineCount();
      }
    } catch (Exception e) {
      System.err.println(
          "Things got messed up in ErrorCheckerService.calculateTabIndexAndLineNumber()");
    }

    return new int[] {codeIndex, x};
  }