Esempio n. 1
0
  /**
   * Creates an array access with a single index expression.
   *
   * @param array An expression evaluating to an address.
   * @param index The expression with which to index the array.
   */
  public ArrayAccess(Expression array, Expression index) {
    super(2);

    object_print_method = class_print_method;

    children.add(array);
    array.setParent(this);

    children.add(index);
    index.setParent(this);
  }
Esempio n. 2
0
 /*
  * If we visit a nested abstraction, we just launch a new lift operation on
  * this abstraction using current context as namespace and returns an
  * Application object
  *
  * @see jaskell.compiler.JaskellVisitor#visit(jaskell.compiler.core.Abstraction)
  */
 public Object visit(Abstraction a) {
   if (!lift) {
       /* top level abstractions */
     lift = true;
     a.setBody((Expression) a.getBody().visit(this));
     return a;
   }
   /* first visit body */
   a.setBody((Expression) a.getBody().visit(this));
   /* retrieve outer LocalBindings */
   Set captured = new HashSet();
   CaptureCollector cc = new CaptureCollector(captured);
   a.visit(cc);
   /* return the newly computed abstraction as an application spine */
   String vname;
   try {
     vname = lift(a, captured);
     Expression ex = applyLifted(vname, captured);
     ex.setParent(a.getParent());
     return ex;
   } catch (SymbolException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
     return null;
   }
 }
Esempio n. 3
0
  public OffsetofExpression(List<Specifier> pspecs, Expression expr) {
    object_print_method = class_print_method;

    children.add(expr);
    expr.setParent(this);

    specs = new LinkedList<Specifier>();
    specs.addAll(pspecs);
  }
Esempio n. 4
0
  /**
   * Creates an array access with multiple index expressions.
   *
   * @param array An expression evaluating to an address.
   * @param indices A list of expressions with which to index the array.
   */
  public ArrayAccess(Expression array, List indices) {
    super(indices.size() + 1);

    object_print_method = class_print_method;

    children.add(array);
    array.setParent(this);

    setIndices(indices);
  }
Esempio n. 5
0
 /*
  * Definitions in the let block are lifted to top-level and the corresponding
  * references in the body are replaced by new definitions.
  *
  * @see jaskell.compiler.JaskellVisitor#visit(jaskell.compiler.core.Let)
  */
 public Object visit(Let let) {
   HashMap subst = new HashMap(); /* substitution map */
   Set lambdas = new HashSet(); /* newly created toplevels ? */
   Iterator it = let.getBindings().entrySet().iterator();
   /* first lift all definitions in this let */
   while (it.hasNext()) {
     Map.Entry entry = (Map.Entry) it.next();
     String name = (String) entry.getKey();
     Expression e = (Expression) entry.getValue();
     /* reset lift flag */
     lift = false;
     Expression ndef = (Expression) e.visit(this);
     ndef.setParent(let);
     /* lift new definition */
     Set captured = new HashSet();
     CaptureCollector cc = new CaptureCollector(captured);
     ndef.visit(cc);
     String vname;
     try {
       vname = lift(ndef, captured);
       lambdas.add(vname);
       /*
        * store new application spine in a map for later substitution
        */
       subst.put(name, applyLifted(vname, captured));
     } catch (SymbolException e1) {
       e1.printStackTrace();
     }
   }
   /* second, replace old occurences in new definitions */
   it = lambdas.iterator();
   while (it.hasNext()) {
     String n = (String) it.next();
     Expression e;
     try {
       e = (Expression) ns.resolve(n);
       ns.rebind(n, (Expression) e.visit(new Substitution(subst)));
     } catch (SymbolException e1) {
       // TODO Auto-generated catch block
       e1.printStackTrace();
     }
   }
   /* thirs, replace occurences in body of let and return it */
   return let.getBody().visit(new Substitution(subst));
 }
Esempio n. 6
0
  /**
   * Set the list of index expressions.
   *
   * @param indices A list of expressions.
   */
  public void setIndices(List indices) {
    /* clear out everything but the first item */
    Expression name = (Expression) children.get(0);
    children.clear();
    children.add(name);

    Iterator iter = indices.iterator();
    while (iter.hasNext()) {
      Expression expr = null;
      try {
        expr = (Expression) iter.next();
      } catch (ClassCastException e) {
        throw new IllegalArgumentException();
      }

      children.add(expr);
      expr.setParent(this);
    }
  }
Esempio n. 7
0
  public void addIndex(Expression expr) {
    if (expr.getParent() != null) throw new NotAnOrphanException();

    children.add(expr);
    expr.setParent(this);
  }
Esempio n. 8
0
  /**
   * Sets the nth index expression of this array access.
   *
   * @param n The position of the index expression.
   * @param expr The expression to use for the index.
   * @throws IndexOutOfBoundsException if there is no expression at that position.
   */
  public void setIndex(int n, Expression expr) {
    if (expr.getParent() != null) throw new NotAnOrphanException();

    children.set(n + 1, expr);
    expr.setParent(this);
  }