예제 #1
0
    @Override
    protected void addForLineNumber(int $line, java.util.List<AbstractAST> $result) {
      if (getLocation().getBeginLine() == $line) {
        $result.add(this);
      }
      ISourceLocation $l;

      $l = constant.getLocation();
      if ($l.hasLineColumn() && $l.getBeginLine() <= $line && $l.getEndLine() >= $line) {
        constant.addForLineNumber($line, $result);
      }
      if ($l.getBeginLine() > $line) {
        return;
      }
    }
예제 #2
0
 private IValue read(Type resultType, ISourceLocation loc, IMap options, IEvaluatorContext ctx) {
   setOptions(options);
   Reader reader = null;
   try {
     reader = ctx.getResolverRegistry().getCharacterReader(loc.getURI());
     List<Record> records = loadRecords(reader);
     if (resultType == null) {
       resultType = inferType(records, ctx);
       ctx.getStdOut().println("readCSV inferred the relation type: " + resultType);
       ctx.getStdOut().flush();
     } else if (header) {
       records.remove(0);
     }
     return buildCollection(resultType, records, ctx);
   } catch (IOException e) {
     throw RuntimeExceptionFactory.io(
         values.string(e.getMessage()), ctx.getCurrentAST(), ctx.getStackTrace());
   } finally {
     if (reader != null) {
       try {
         reader.close();
       } catch (IOException e) {
         throw RuntimeExceptionFactory.io(
             values.string(e.getMessage()), ctx.getCurrentAST(), ctx.getStackTrace());
       }
     }
   }
 }
예제 #3
0
 @Override
 public InputStream getInputStream(ISourceLocation uri) throws IOException {
   String contents = modules.get(uri.getPath());
   if (contents != null) {
     return new ByteArrayInputStream(contents.getBytes());
   }
   return null;
 }
예제 #4
0
  @Override
  public String getMessage() {
    if (loc != null) {
      URI url = loc.getURI();

      return (url.getScheme().equals("file") ? (url.getAuthority() + url.getPath()) : url)
          + ":"
          + loc.getBeginLine()
          + ","
          + loc.getBeginColumn()
          + ": "
          + super.getMessage();
    }

    // TODO remove once all errors have locations
    return super.getMessage();
  }
예제 #5
0
  public void report() {

    List<Map.Entry<AbstractAST, Count>> sortedData = sortData();

    int maxURL = 1;
    long nTicks = 0;

    for (Map.Entry<AbstractAST, Count> e : sortedData) {
      URI url = e.getKey().getLocation().getURI();
      int sz = url.toString().length();
      if (sz > maxURL) maxURL = sz;
      nTicks += e.getValue().getTicks();
    }
    PrintWriter out = eval.getStdOut();
    String URLFormat = "%" + maxURL + "s";
    out.printf(
        "PROFILE: %d data points, %d ticks, tick = %d milliSecs\n",
        data.size(), nTicks, resolution);
    out.printf(URLFormat + "%11s%8s%9s  %s\n", " Source File", "Lines", "Ticks", "%", "Source");

    for (Map.Entry<AbstractAST, Count> e : sortedData) {
      ISourceLocation L = e.getKey().getLocation();

      String uri = L.getURI().toString();
      String filePrefix = "file://";
      if (uri.startsWith(filePrefix)) uri = uri.substring(filePrefix.length());

      int bgn = L.getBeginLine();
      int end = L.getEndLine();
      String range = (end == bgn) ? Integer.toString(bgn) : bgn + ".." + end;

      int ticks = e.getValue().getTicks();
      double perc = (ticks * 100.0) / nTicks;

      String source =
          String.format(
              "%-30.30s",
              e.getKey().toString().replaceFirst("^[\\s]+", "").replaceAll("[\\s]+", " "));

      out.printf(URLFormat + "%11s%8d%8.1f%%  %s\n", uri, range, ticks, perc, source);
    }
    // Make sure that our output is seen:
    out.flush();
  }
 @Override
 protected String getPath(ISourceLocation uri) {
   String path = uri.getPath();
   if (path == null || path.isEmpty() || path.equals("/")) {
     return "";
   }
   while (path.startsWith("/")) {
     path = path.substring(1);
   }
   return path;
 }
  public static IConstructor loadForRascal(IValueFactory vf, IString src, ISourceLocation loc) {
    IGTD<IConstructor, IConstructor, ISourceLocation> gtd = new ClojureParser();
    IConstructor file =
        (IConstructor)
            gtd.parse(
                START_SORT,
                loc.getURI(),
                src.getValue().toCharArray(),
                new DefaultNodeFlattener<IConstructor, IConstructor, ISourceLocation>(),
                new UPTRNodeFactory());

    String path = loc.getURI().getPath();
    IConstructor[] fileRef = new IConstructor[] {file};

    // ignore the clojure result
    ISetWriter errors = vf.setWriter(Message.Message);
    new UPTRCompiler(vf, errors).loadPT(fileRef, path, new File(path).getName());

    // return the updated parse tree.
    return fileRef[0].setAnnotation("messages", errors.done());
  }
예제 #8
0
  @Override
  protected IStatus run(IProgressMonitor monitor) {
    monitor.beginTask("Parsing", 105);

    try {
      handler.clearMessages();

      IGTD<IConstructor, IConstructor, ISourceLocation> gtd = new ClojureParser();
      parseTree =
          (IConstructor)
              gtd.parse(
                  START_SORT,
                  URI.create(path.toString()),
                  input.toCharArray(),
                  new DefaultNodeFlattener<IConstructor, IConstructor, ISourceLocation>(),
                  new UPTRNodeFactory());

    } catch (ParseError pe) {
      int offset = pe.getOffset();
      if (offset == input.length()) --offset;

      handler.handleSimpleMessage(
          "parse error",
          offset,
          offset + pe.getLength(),
          pe.getBeginColumn(),
          pe.getEndColumn(),
          pe.getBeginLine() + 1,
          pe.getEndLine() + 1);
    } catch (Throw e) {
      IValue exc = e.getException();

      if (exc.getType() == RuntimeExceptionFactory.Exception) {
        if (((IConstructor) exc).getConstructorType() == RuntimeExceptionFactory.ParseError) {
          ISourceLocation loc = (ISourceLocation) ((IConstructor) e.getException()).get(0);
          handler.handleSimpleMessage(
              "parse error: " + loc,
              loc.getOffset(),
              loc.getOffset() + loc.getLength(),
              loc.getBeginColumn(),
              loc.getEndColumn(),
              loc.getBeginLine(),
              loc.getEndLine());
        } else {
          Activator.getInstance().logException(e.getMessage(), e);
        }
      }
    } catch (Throwable e) {
      Activator.getInstance().logException("parsing failed: " + e.getMessage(), e);
    } finally {
      monitor.done();
    }

    return Status.OK_STATUS;
  }
  private JarEntry getEntry(JarInputStream stream, ISourceLocation subPath) throws IOException {
    int pos =
        ((JarInputStreamTreeHierachy) getFileHierchyCache(new File(subPath.getPath())))
            .getPosition(getPath(subPath));

    if (pos != -1) {
      JarEntry entry;
      do {
        entry = stream.getNextJarEntry();
      } while (pos-- > 0);

      return entry;
    }

    return null;
  }
예제 #10
0
파일: IO.java 프로젝트: sharwell/rascal
 public void writeTextJSonFile(ISourceLocation loc, IValue value, IEvaluatorContext ctx) {
   OutputStream out = null;
   try {
     out = ctx.getResolverRegistry().getOutputStream(loc.getURI(), false);
     new JSonWriter().write(value, new OutputStreamWriter(out, "UTF8"));
   } catch (IOException e) {
     throw RuntimeExceptionFactory.io(values.string(e.getMessage()), null, null);
   } finally {
     if (out != null) {
       try {
         out.close();
       } catch (IOException ioex) {
         throw RuntimeExceptionFactory.io(values.string(ioex.getMessage()), null, null);
       }
     }
   }
 }
예제 #11
0
파일: IO.java 프로젝트: sharwell/rascal
 public IValue readTextJSonFile(IValue type, ISourceLocation loc, IEvaluatorContext ctx) {
   // TypeStore store = new TypeStore();
   TypeStore store = ctx.getCurrentEnvt().getStore();
   Type start = new TypeReifier(ctx.getValueFactory()).valueToType((IConstructor) type, store);
   Reader read = null;
   try {
     read = ctx.getResolverRegistry().getCharacterReader(loc.getURI());
     return new JSonReader().read(values, store, start, read);
   } catch (IOException e) {
     throw RuntimeExceptionFactory.io(values.string(e.getMessage()), null, null);
   } finally {
     if (read != null) {
       try {
         read.close();
       } catch (IOException ioex) {
         throw RuntimeExceptionFactory.io(values.string(ioex.getMessage()), null, null);
       }
     }
   }
 }
예제 #12
0
  public IValue readTextATermFile(IValue type, ISourceLocation loc, IEvaluatorContext ctx) {
    TypeStore store = new TypeStore();
    Type start = new TypeReifier(ctx.getValueFactory()).valueToType((IConstructor) type, store);

    InputStream in = null;
    try {
      in = ctx.getResolverRegistry().getInputStream(loc.getURI());
      return new ATermReader().read(values, store, start, in);
    } catch (IOException e) {
      throw RuntimeExceptionFactory.io(values.string(e.getMessage()), null, null);
    } finally {
      if (in != null) {
        try {
          in.close();
        } catch (IOException ioex) {
          throw RuntimeExceptionFactory.io(values.string(ioex.getMessage()), null, null);
        }
      }
    }
  }
예제 #13
0
  public void generateTypedInterfaceInternal(
      IString tag, ISourceLocation uriLoc, IEvaluatorContext ctx) {
    IResource handler = Resource.getResourceHandler(uriLoc);
    String tagStr = tag.getValue();
    Type t = handler.getResourceType(ctx, uriLoc);
    PrintWriter currentOutStream = ctx.getStdOut();

    // Declare an alias to the type of the resource
    TypeStore ts = ctx.getCurrentEnvt().getStore();
    Type alias2t = TypeFactory.getInstance().aliasType(ts, tagStr + "Type", t);

    currentOutStream.println(
        "Generated type alias " + alias2t.toString() + ": " + alias2t.getAliased().toString());
    currentOutStream.flush();

    // Declare a function that just uses the given URI. This way, if we provide
    // the complete URI up front, we don't need to keep providing it later.
    StringBuilder sb = new StringBuilder();
    sb.append("public ").append(tagStr).append("Type ").append(tagStr).append("() { ");
    sb.append(" return getTypedResource(")
        .append(uriLoc.toString())
        .append(",#")
        .append(tagStr)
        .append("Type); }");
    IConstructor declTree =
        ctx.getEvaluator()
            .parseCommand(
                ctx.getEvaluator().getMonitor(),
                sb.toString(),
                ctx.getCurrentAST().getLocation().getURI());
    Command cmd = ctx.getEvaluator().getBuilder().buildCommand(declTree);
    Environment env = ctx.getCurrentEnvt();
    ctx.setCurrentEnvt(env.getRoot());
    Result<IValue> fun0 = ctx.getEvaluator().eval(ctx.getEvaluator().getMonitor(), cmd);
    ctx.unwind(env);

    currentOutStream.println("Generated function " + fun0.toString());
    currentOutStream.flush();
  }
예제 #14
0
 @Override
 public boolean exists(ISourceLocation uri) {
   return modules.containsKey(uri.getPath());
 }
 @Override
 protected File getJar(ISourceLocation uri) throws IOException {
   return new File(jarURI.getPath());
 }
예제 #16
0
  public void write(IValue rel, ISourceLocation loc, IEvaluatorContext ctx) {

    OutputStream out = null;

    Type paramType = ctx.getCurrentEnvt().getTypeBindings().get(types.parameterType("T"));
    if (!paramType.isRelation() && !paramType.isListRelation()) {
      throw RuntimeExceptionFactory.illegalTypeArgument(
          "A relation type is required instead of " + paramType,
          ctx.getCurrentAST(),
          ctx.getStackTrace());
    }

    try {
      boolean isListRel = rel instanceof IList;
      out = ctx.getResolverRegistry().getOutputStream(loc.getURI(), false);
      ISet irel = null;
      IList lrel = null;
      if (isListRel) {
        lrel = (IList) rel;
      } else {
        irel = (ISet) rel;
      }

      int nfields = isListRel ? lrel.asRelation().arity() : irel.asRelation().arity();
      if (header) {
        for (int i = 0; i < nfields; i++) {
          if (i > 0) out.write(separator);
          String label = paramType.getFieldName(i);
          if (label == null || label.isEmpty()) label = "field" + i;
          writeString(out, label);
        }
        out.write('\n');
      }
      String separatorAsString = new String(Character.toChars(separator));
      for (IValue v : (isListRel ? lrel : irel)) {
        ITuple tup = (ITuple) v;
        int sep = 0;
        for (IValue w : tup) {
          if (sep == 0) sep = separator;
          else out.write(sep);
          if (w.getType().isString()) {
            String s = ((IString) w).getValue();

            if (s.contains(separatorAsString)
                || s.contains("\n")
                || s.contains("\r")
                || s.contains("\"")) {
              s = s.replaceAll("\"", "\"\"");
              out.write('"');
              writeString(out, s);
              out.write('"');
            } else writeString(out, s);
          } else {
            writeString(out, w.toString());
          }
        }
        out.write('\n');
      }
      out.flush();
      out.close();
    } catch (IOException e) {
      throw RuntimeExceptionFactory.io(values.string(e.getMessage()), null, null);
    } finally {
      if (out != null) {
        try {
          out.flush();
          out.close();
        } catch (IOException ioex) {
          throw RuntimeExceptionFactory.io(values.string(ioex.getMessage()), null, null);
        }
      }
    }
  }
  public Object loadPT(IConstructor[] fileRef, String sourcePath, String sourceName) {
    IConstructor file = fileRef[0];
    ISourceLocation loc = TreeAdapter.getLocation(file);
    int lineNumber = loc.getBeginLine();

    Object ret = null;

    Var.pushThreadBindings(
        RT.map(
            LOADER,
            RT.makeClassLoader(),
            SOURCE_PATH,
            sourcePath,
            SOURCE,
            sourceName,
            METHOD,
            null,
            LOCAL_ENV,
            null,
            LOOP_LOCALS,
            null,
            NEXT_LOCAL_NUM,
            0,
            RT.CURRENT_NS,
            RT.CURRENT_NS.deref(),
            LINE_BEFORE,
            lineNumber,
            LINE_AFTER,
            lineNumber,
            RT.UNCHECKED_MATH,
            RT.UNCHECKED_MATH.deref(),
            RT.WARN_ON_REFLECTION,
            RT.WARN_ON_REFLECTION.deref(),
            RT.DATA_READERS,
            RT.DATA_READERS.deref()));

    UPTRLispReader reader = new UPTRLispReader(vf, errors);

    try {

      if (TreeAdapter.isAmb(file)) {
        System.err.println("Amb");
      }

      // File is start[File], so
      IConstructor file2 = (IConstructor) TreeAdapter.getArgs(file).get(1);
      IList args = TreeAdapter.getArgs(file2);
      // Probably only this is the list of forms; don't forget to fix
      // below.
      IList forms = TreeAdapter.getArgs((IConstructor) args.get(0));

      IListWriter newArgs = vf.listWriter();
      for (int i = 0; i < forms.length(); i++) {
        IConstructor form = (IConstructor) forms.get(i);
        // only forms, no literals at this level.
        UPTRLispReader.Pair p = reader.read(form);
        newArgs.append(p.tree);
        LINE_AFTER.set(TreeAdapter.getLocation(form).getEndLine());
        ret = eval(p.obj, false);
        LINE_BEFORE.set(TreeAdapter.getLocation(form).getBeginLine());
        if (i < forms.length() - 2) {
          i++;
          newArgs.append(forms.get(i)); // layout
        }
      }
      // Fix tree
      file2 = file2.set("args", newArgs.done());
      file =
          file.set(
              "args",
              vf.list(TreeAdapter.getArgs(file).get(0), file2, TreeAdapter.getArgs(file).get(2)));

    } catch (UPTRLispReader.ReaderException e) {
      throw new CompilerException(sourcePath, e.line, e.getCause());
    } finally {
      Var.popThreadBindings();
    }
    fileRef[0] = file;
    return ret;
  }
예제 #18
0
 public static IResource getResourceHandler(ISourceLocation uri) {
   for (String key : resourceHandlers.keySet()) {
     if (uri.getURI().getHost().equals(key)) return resourceHandlers.get(key);
   }
   return null; // TODO: Throw here!
 }