コード例 #1
0
ファイル: Shell.java プロジェクト: dbremner/fortress
  /** Automatically generate an API from a component. */
  private static void api(List<String> args, Option<String> out, Option<String> prepend)
      throws UserError, InterruptedException, IOException {
    if (args.size() == 0) {
      throw new UserError("Need a file to generate an API.");
    }
    String s = args.get(0);
    List<String> rest = args.subList(1, args.size());

    if (s.startsWith("-")) {
      if (s.equals("-debug")) {
        rest = Debug.parseOptions(rest);
      } else if (s.equals("-out") && !rest.isEmpty()) {
        out = Option.<String>some(rest.get(0));
        rest = rest.subList(1, rest.size());
      } else if (s.equals("-prepend") && !rest.isEmpty()) {
        prepend = Option.<String>some(rest.get(0));
        rest = rest.subList(1, rest.size());
      } else invalidFlag(s, "api");
      api(rest, out, prepend);
    } else {
      api(s, out, prepend);
    }
  }
コード例 #2
0
ファイル: Shell.java プロジェクト: dbremner/fortress
  /**
   * @param tokens
   * @return
   * @throws InterruptedException
   * @throws Throwable
   */
  public static int subMain(String[] tokens) throws InterruptedException, Throwable {
    int return_code = 0;

    // Now match the assembled string.
    try {
      String what = tokens[0];
      List<String> args = Arrays.asList(tokens).subList(1, tokens.length);
      if (what.equals("compile")) {
        useCompilerLibraries();
        setTypeChecking(true);
        setPhaseOrder(PhaseOrder.compilerPhaseOrder);
        return_code = compilerPhases(args, Option.<String>none(), what);
      } else if (what.equals("junit")) {
        return_code = junit(args);
      } else if (what.equals("link")) {
        useCompilerLibraries();
        setTypeChecking(true);
        setPhaseOrder(PhaseOrder.compilerPhaseOrder);
        return_code = link(args);
      } else if (what.equals("build")) {
        useCompilerLibraries();
        setTypeChecking(true);
        setPhaseOrder(PhaseOrder.compilerPhaseOrder);
        return_code = link(args);
      } else if (what.equals("walk")) {
        useInterpreterLibraries();
        setScala(false);
        setPhaseOrder(PhaseOrder.interpreterPhaseOrder);
        walk(args);
      } else if (what.equals("api")) {
        useCompilerLibraries();
        api(args, Option.<String>none(), Option.<String>none());
      } else if (what.equals("compare")) {
        useCompilerLibraries();
        compare(args);
      } else if (what.equals("parse")) {
        useCompilerLibraries();
        return_code = parse(args, Option.<String>none());
      } else if (what.equals("unparse")) {
        useCompilerLibraries();
        unparse(args, Option.<String>none(), false, false);
      } else if (what.equals("disambiguate")) {
        useCompilerLibraries();
        setPhaseOrder(PhaseOrder.disambiguatePhaseOrder);
        return_code = compilerPhases(args, Option.<String>none(), what);
      } else if (what.equals("desugar")) {
        useCompilerLibraries();
        setTypeChecking(true);
        setObjExprDesugaring(true);
        setPhaseOrder(PhaseOrder.desugarPhaseOrder);

        return_code = compilerPhases(args, Option.<String>none(), what);
      } else if (what.equals("grammar")) {
        useCompilerLibraries();
        setPhaseOrder(PhaseOrder.grammarPhaseOrder);

        return_code = compilerPhases(args, Option.<String>none(), what);
      } else if (what.equals("typecheck")) {
        useCompilerLibraries();
        setTypeChecking(true);
        setPhaseOrder(PhaseOrder.typecheckPhaseOrder);

        return_code = compilerPhases(args, Option.<String>none(), what);
      } else if (what.equals("test-coercion")) {
        useCompilerLibraries();
        setTypeChecking(true);
        setPhaseOrder(PhaseOrder.typecheckPhaseOrder);

        return_code = compilerPhases(args, Option.<String>none(), what);
      } else if (what.equals("typecheck-old")) {
        useInterpreterLibraries();
        setScala(false);
        /* TODO: remove the next line once type checking is permanently turned on */
        setTypeChecking(true);
        setPhaseOrder(PhaseOrder.typecheckPhaseOrder);

        return_code = compilerPhases(args, Option.<String>none(), what);
      } else if (what.equals("test")) {
        useInterpreterLibraries();
        setScala(false);
        setPhaseOrder(PhaseOrder.interpreterPhaseOrder);
        walkTests(args, false);
      } else if (what.contains(ProjectProperties.COMP_SOURCE_SUFFIX)
          || (what.startsWith("-") && tokens.length > 1)) {
        useInterpreterLibraries();
        setScala(false);
        setPhaseOrder(PhaseOrder.interpreterPhaseOrder);
        walk(Arrays.asList(tokens));
      } else if (what.equals("help")) {
        useCompilerLibraries();
        printHelpMessage();
      } else if (what.equals("expand") && tokens.length == 2) {
        System.out.println(ProjectProperties.get(tokens[1], ""));
      } else {
        useCompilerLibraries();
        printUsageMessage();
      }
    } catch (StaticError e) {
      System.err.println(e);
      if (Debug.stackTraceOn()) {
        e.printStackTrace();
      }
      return_code = -1;
    } catch (UserError error) {
      System.err.println(error.getMessage());
      return_code = -1;
    } catch (IOException error) {
      System.err.println(error.getMessage());
      return_code = -2;
    } catch (CompilerBug error) {
      System.err.println(error.getMessage());
      if (Debug.stackTraceOn()) {
        error.printStackTrace();
      }
      return_code = -3;
    }

    Init.allowForLeakChecks();
    return return_code;
  }