Examples with JavaMode processing.mode.java.JavaMode used on opensource projects

Example 1 with JavaMode

use of processing.mode.java.JavaMode in project processing by processing.

the class PreprocessingService method preprocessSketch.

/// --------------------------------------------------------------------------
private PreprocessedSketch preprocessSketch(PreprocessedSketch prevResult) {
    boolean firstCheck = prevResult == null;
    PreprocessedSketch.Builder result = new PreprocessedSketch.Builder();
    List<ImportStatement> codeFolderImports = result.codeFolderImports;
    List<ImportStatement> programImports = result.programImports;
    JavaMode javaMode = (JavaMode) editor.getMode();
    Sketch sketch = result.sketch = editor.getSketch();
    String className = sketch.getName();
    StringBuilder workBuffer = new StringBuilder();
    // Combine code into one buffer
    IntList tabStartsList = new IntList();
    for (SketchCode sc : sketch.getCode()) {
        if (sc.isExtension("pde")) {
            tabStartsList.append(workBuffer.length());
            try {
                workBuffer.append(sc.getDocumentText());
            } catch (BadLocationException e) {
                e.printStackTrace();
            }
            workBuffer.append('\n');
        }
    }
    result.tabStartOffsets = tabStartsList.array();
    String pdeStage = result.pdeCode = workBuffer.toString();
    boolean reloadCodeFolder = firstCheck || codeFolderChanged.getAndSet(false);
    boolean reloadLibraries = firstCheck || librariesChanged.getAndSet(false);
    // Core and default imports
    if (coreAndDefaultImports == null) {
        PdePreprocessor p = editor.createPreprocessor(null);
        coreAndDefaultImports = buildCoreAndDefaultImports(p);
    }
    result.coreAndDefaultImports.addAll(coreAndDefaultImports);
    // Prepare code folder imports
    if (reloadCodeFolder) {
        codeFolderImports.addAll(buildCodeFolderImports(sketch));
    } else {
        codeFolderImports.addAll(prevResult.codeFolderImports);
    }
    // TODO: convert unicode escapes to chars
    SourceUtils.scrubCommentsAndStrings(workBuffer);
    Mode sketchMode = PdePreprocessor.parseMode(workBuffer);
    // Prepare transforms to convert pde code into parsable code
    TextTransform toParsable = new TextTransform(pdeStage);
    toParsable.addAll(SourceUtils.insertImports(coreAndDefaultImports));
    toParsable.addAll(SourceUtils.insertImports(codeFolderImports));
    toParsable.addAll(SourceUtils.parseProgramImports(workBuffer, programImports));
    toParsable.addAll(SourceUtils.replaceTypeConstructors(workBuffer));
    toParsable.addAll(SourceUtils.replaceHexLiterals(workBuffer));
    toParsable.addAll(SourceUtils.wrapSketch(sketchMode, className, workBuffer.length()));
    {
        // Refresh sketch classloader and classpath if imports changed
        if (javaRuntimeClassPath == null) {
            javaRuntimeClassPath = buildJavaRuntimeClassPath();
            sketchModeClassPath = buildModeClassPath(javaMode, false);
            searchModeClassPath = buildModeClassPath(javaMode, true);
        }
        if (reloadLibraries) {
            coreLibraryClassPath = buildCoreLibraryClassPath(javaMode);
        }
        boolean rebuildLibraryClassPath = reloadLibraries || checkIfImportsChanged(programImports, prevResult.programImports);
        if (rebuildLibraryClassPath) {
            sketchLibraryClassPath = buildSketchLibraryClassPath(javaMode, programImports);
            searchLibraryClassPath = buildSearchLibraryClassPath(javaMode);
        }
        boolean rebuildClassPath = reloadCodeFolder || rebuildLibraryClassPath || prevResult.classLoader == null || prevResult.classPath == null || prevResult.classPathArray == null || prevResult.searchClassPathArray == null;
        if (reloadCodeFolder) {
            codeFolderClassPath = buildCodeFolderClassPath(sketch);
        }
        if (rebuildClassPath) {
            {
                // Sketch class path
                List<String> sketchClassPath = new ArrayList<>();
                sketchClassPath.addAll(javaRuntimeClassPath);
                sketchClassPath.addAll(sketchModeClassPath);
                sketchClassPath.addAll(sketchLibraryClassPath);
                sketchClassPath.addAll(coreLibraryClassPath);
                sketchClassPath.addAll(codeFolderClassPath);
                String[] classPathArray = sketchClassPath.stream().toArray(String[]::new);
                URL[] urlArray = Arrays.stream(classPathArray).map(path -> {
                    try {
                        return Paths.get(path).toUri().toURL();
                    } catch (MalformedURLException e) {
                        Messages.loge("malformed URL when preparing sketch classloader", e);
                        return null;
                    }
                }).filter(url -> url != null).toArray(URL[]::new);
                result.classLoader = new URLClassLoader(urlArray, null);
                result.classPath = classPathFactory.createFromPaths(classPathArray);
                result.classPathArray = classPathArray;
            }
            {
                // Search class path
                List<String> searchClassPath = new ArrayList<>();
                searchClassPath.addAll(javaRuntimeClassPath);
                searchClassPath.addAll(searchModeClassPath);
                searchClassPath.addAll(searchLibraryClassPath);
                searchClassPath.addAll(coreLibraryClassPath);
                searchClassPath.addAll(codeFolderClassPath);
                result.searchClassPathArray = searchClassPath.stream().toArray(String[]::new);
            }
        } else {
            result.classLoader = prevResult.classLoader;
            result.classPath = prevResult.classPath;
            result.searchClassPathArray = prevResult.searchClassPathArray;
            result.classPathArray = prevResult.classPathArray;
        }
    }
    {
        // Check for missing braces
        List<JavaProblem> missingBraceProblems = SourceUtils.checkForMissingBraces(workBuffer, result.tabStartOffsets);
        if (!missingBraceProblems.isEmpty()) {
            result.missingBraceProblems.addAll(missingBraceProblems);
            result.hasSyntaxErrors = true;
        }
    }
    // Transform code to parsable state
    String parsableStage = toParsable.apply();
    OffsetMapper parsableMapper = toParsable.getMapper();
    // Create intermediate AST for advanced preprocessing
    CompilationUnit parsableCU = makeAST(parser, parsableStage.toCharArray(), COMPILER_OPTIONS);
    // Prepare advanced transforms which operate on AST
    TextTransform toCompilable = new TextTransform(parsableStage);
    toCompilable.addAll(SourceUtils.preprocessAST(parsableCU));
    // Transform code to compilable state
    String compilableStage = toCompilable.apply();
    OffsetMapper compilableMapper = toCompilable.getMapper();
    char[] compilableStageChars = compilableStage.toCharArray();
    // Create compilable AST to get syntax problems
    CompilationUnit compilableCU = makeAST(parser, compilableStageChars, COMPILER_OPTIONS);
    // Get syntax problems from compilable AST
    result.hasSyntaxErrors |= Arrays.stream(compilableCU.getProblems()).anyMatch(IProblem::isError);
    // Generate bindings after getting problems - avoids
    // 'missing type' errors when there are syntax problems
    CompilationUnit bindingsCU = makeASTWithBindings(parser, compilableStageChars, COMPILER_OPTIONS, className, result.classPathArray);
    // Get compilation problems
    List<IProblem> bindingsProblems = Arrays.asList(bindingsCU.getProblems());
    result.hasCompilationErrors = bindingsProblems.stream().anyMatch(IProblem::isError);
    // Update builder
    result.offsetMapper = parsableMapper.thenMapping(compilableMapper);
    result.javaCode = compilableStage;
    result.compilationUnit = bindingsCU;
    // Build it
    return result.build();
}