Examples of com.dragome.compiler.ast.Assignment

com.dragome.compiler.ast.Assignment

    return op;
  }


  private boolean reduceXCrement(VariableDeclaration decl)
  {
    Assignment a1= null;
    Assignment a2= null;
    VariableBinding vb1= null;
    VariableBinding vb2= null;


    Assignable fa1= null;
    Assignable fa2= null;


    InfixExpression sum= null;


    Iterator iter= decl.vbs.iterator();


    while (iter.hasNext())
    {
      VariableBinding vb= (VariableBinding) iter.next();


      if (vb.getParentNode() instanceof Assignment)
      {
        Assignment a= (Assignment) vb.getParentNode();
        if (a.getLeftHandSide() == vb && a.getRightHandSide() instanceof Assignable)
        {
          vb1= vb;
          a1= a;
          fa1= (Assignable) a.getRightHandSide();
          continue;
        }
      }


      if (vb.getParentNode() instanceof InfixExpression)
      {
        InfixExpression infix= (InfixExpression) vb.getParentNode();
        if (infix.getParentNode() instanceof Assignment)
        {
          Assignment a= (Assignment) infix.getParentNode();
          if (a.getLeftHandSide() instanceof Assignable)
          {
            vb2= vb;
            fa2= (Assignable) a.getLeftHandSide();
            a2= a;
            sum= infix;
            continue;
          }
        }

View Full Code Here

    return true;
  }


  private boolean reduceYCrement(VariableDeclaration decl)
  {
    Assignment a1= null;
    Assignment a2= null;
    VariableBinding vb1= null;
    VariableBinding vb2= null;


    Assignable fa1= null;
    Assignable fa2= null;


    InfixExpression infixExpr= null;


    Iterator iter= decl.vbs.iterator();


    while (iter.hasNext())
    {
      VariableBinding vb= (VariableBinding) iter.next();


      if (!(vb.getParentNode() instanceof Assignment))
        continue;


      Assignment a= (Assignment) vb.getParentNode();
      if (a.getRightHandSide() == vb && a.getLeftHandSide() instanceof Assignable)
      {
        vb2= vb;
        a2= a;
        fa2= (Assignable) a.getLeftHandSide();
        continue;
      }


      if (a.getLeftHandSide() == vb && a.getRightHandSide() instanceof InfixExpression)
      {
        InfixExpression infix= (InfixExpression) a.getRightHandSide();
        if (!(infix.getLeftOperand() instanceof Assignable))
          continue;
        vb1= vb;
        a1= a;
        fa1= (Assignable) infix.getLeftOperand();
        infixExpr= infix;
        continue;
      }
    }


    if (a1 == null || a2 == null)
      return false;
    if (!fa1.isSame(fa2))
      return false;


    decl.vbs.remove(vb1);
    decl.vbs.remove(vb2);
    VariableBinding vb= decl.vbs.get(0);
    Expression replacement= null;


    PStarExpression.Operator operator= getOp(infixExpr);
    if (operator != null)
    {
      PrefixExpression p= new PrefixExpression();
      p.setOperand((Expression) fa1);
      p.setOperator(operator);
      replacement= p;
    }
    else
    {
      InfixExpression.Operator op= infixExpr.getOperator();
      Assignment.Operator opp= Assignment.Operator.lookup(op.toString() + '=');
      Assignment a= new Assignment(opp);
      a.setLeftHandSide((Expression) fa2);
      a.setRightHandSide(infixExpr.getRightOperand());
      replacement= a;
    }


    vb.getParentBlock().replaceChild(replacement, vb);

View Full Code Here

        continue;
      }


      VariableBinding vb= methodDecl.createAnonymousVariableBinding(expr.getTypeBinding(), true);
      logger.debug("\t" + expr + ' ' + vb.getName());
      Assignment a= new Assignment(Assignment.Operator.ASSIGN);
      a.setLeftHandSide(vb);
      a.setRightHandSide(expr);


      node.block.appendChild(a);
      node.stack.set(i, clone ? (VariableBinding) vb.clone() : vb);
    }

View Full Code Here

        while (iter.hasNext())
        {
          Node node= (Node) iter.next();
          Expression expr= (Expression) node.stack.get(index);


          Assignment a= new Assignment(Assignment.Operator.ASSIGN);
          a.setLeftHandSide((VariableBinding) vb.clone());
          if (expr instanceof VariableBinding)
            expr= (VariableBinding) expr.clone();
          a.setRightHandSide(expr);


          node.block.appendChild(a);
        }
        logger.debug("\t" + vb.getName());
      }

View Full Code Here

      VariableBinding vb1= (VariableBinding) e;
      VariableBinding vb2= (VariableBinding) vb1.clone();
      return new VariableBinding[] { vb1, vb2 };
    }


    Assignment a= new Assignment(Assignment.Operator.ASSIGN);
    a.setRange(bytes.getIndex(), bytes.getIndex());
    VariableBinding vb1= methodDecl.createAnonymousVariableBinding(e.getTypeBinding(), true);
    VariableBinding vb2= (VariableBinding) vb1.clone();
    VariableBinding vb3= (VariableBinding) vb1.clone();
    tempDecls.add(vb1.getVariableDeclaration());
    vb1.getVariableDeclaration().setParentNode(methodDecl);
    a.setLeftHandSide(vb1);
    a.setRightHandSide(e);
    cNode.block.appendChild(a);
    return new VariableBinding[] { vb2, vb3 };
  }

View Full Code Here

      case Const.PUTSTATIC:


      case Const.PUTFIELD:
      {


        Assignment a= new Assignment(Assignment.Operator.ASSIGN);
        Expression rhs= stack.pop();


        int index= bytes.readUnsignedShort();
        ConstantFieldref fieldRef= (ConstantFieldref) constantPool.getConstant(index, Constants.CONSTANT_Fieldref);


        FieldAccess fa= new FieldWrite();
        fa.setName(getFieldName(fieldRef));
        fa.setType(new ObjectType(fieldRef.getClass(constantPool)));
        fa.initialize(methodDecl);


        if (opcode == Const.PUTFIELD)
        {
          fa.setExpression(stack.pop());
        }


        a.setLeftHandSide(fa);
        a.setRightHandSide(rhs);


        instruction= a;
        break;
      }


      case Const.GETFIELD:
      {


        int index= bytes.readUnsignedShort();
        ConstantFieldref fieldRef= (ConstantFieldref) constantPool.getConstant(index, Constants.CONSTANT_Fieldref);


        Expression ex= stack.pop();
        FieldAccess fa= new FieldRead();
        fa.setType(new ObjectType(fieldRef.getClass(constantPool)));
        fa.setName(getFieldName(fieldRef));
        fa.setExpression(ex);
        fa.initialize(methodDecl);
        instruction= fa;
        break;
      }


      case Const.GETSTATIC:
      {


        int index= bytes.readUnsignedShort();
        ConstantFieldref fieldRef= (ConstantFieldref) constantPool.getConstant(index, Constants.CONSTANT_Fieldref);


        FieldAccess fa= new FieldRead();
        fa.setType(new ObjectType(fieldRef.getClass(constantPool)));
        fa.setName(getFieldName(fieldRef));
        fa.initialize(methodDecl);


        instruction= fa;
        break;
      }


      case Const.DUP:
      {


        dup1();
        instruction= stack.pop();
        break;
      }


      case Const.DUP2:


        if (form.getIndex() == 0)
        {
          dup2();
          instruction= stack.pop();
        }
        else
        {
          dup1();
          instruction= stack.pop();
        }
        break;


      case Const.DUP_X1:
      {


        dup1();
        stack.rotate(2);
        instruction= stack.pop();
        break;
      }


      case Const.DUP_X2:
      {


        if (form.getIndex() == 0)
        {
          dup1();
          stack.rotate(3);
        }
        else
        {
          dup1();
          stack.rotate(2);
        }
        instruction= stack.pop();
        break;
      }


      case Const.DUP2_X1:


        if (form.getIndex() == 0)
        {
          dup2();
          stack.rotate(4);
          stack.rotate(4);
        }
        else
        {
          dup1();
          stack.rotate(2);
        }
        instruction= stack.pop();
        break;


      case Const.DUP2_X2:


        if (form.getIndex() == 0)
        {
          dup2();
          stack.rotate(5);
          stack.rotate(5);
        }
        else if (form.getIndex() == 1)
        {
          dup1();
          stack.rotate(3);
        }
        else if (form.getIndex() == 2)
        {
          dup2();
          stack.rotate(4);
          stack.rotate(4);
        }
        else
        {
          dup1();
          stack.rotate(2);
        }


        instruction= stack.pop();
        break;


      case Const.SWAP:
      {


        stack.rotate(1);
        instruction= new NoOperation();
        break;
      }


      case Const.I2S:


      case Const.I2F:


      case Const.L2I:


      case Const.F2I:


      case Const.F2L:


      case Const.L2F:


      case Const.L2D:


      case Const.D2I:


      case Const.D2L:


      case Const.D2F:


      case Const.I2B:


      case Const.I2C:


        instruction= new PrimitiveCast(opcode, stack.pop(), form.getResultType());
        break;


      case Const.I2L:


        stack.peek().setTypeBinding(Type.LONG);
        instruction= new NoOperation();
        break;
      case Const.I2D:


      case Const.F2D:


        stack.peek().setTypeBinding(Type.DOUBLE);
        instruction= new NoOperation();
        break;


      case Const.INEG:


      case Const.LNEG:


      case Const.FNEG:


      case Const.DNEG:


        instruction= createPrefix(PrefixExpression.MINUS, stack.pop(), form.getResultType());
        break;


      case Const.ISHR:


      case Const.LSHR:


        instruction= createInfixRightLeft(InfixExpression.Operator.RIGHT_SHIFT_SIGNED, stack.pop(), stack.pop(), form.getResultType());
        break;


      case Const.ISHL:


      case Const.LSHL:


        instruction= createInfixRightLeft(InfixExpression.Operator.LEFT_SHIFT, stack.pop(), stack.pop(), form.getResultType());
        break;


      case Const.IUSHR:


      case Const.LUSHR:


        instruction= createInfixRightLeft(InfixExpression.Operator.RIGHT_SHIFT_UNSIGNED, stack.pop(), stack.pop(), form.getResultType());
        break;


      case Const.IADD:


      case Const.LADD:


      case Const.FADD:


      case Const.DADD:


        instruction= createInfixRightLeft(InfixExpression.Operator.PLUS, stack.pop(), stack.pop(), form.getResultType());
        break;


      case Const.ISUB:


      case Const.LSUB:


      case Const.FSUB:


      case Const.DSUB:


        instruction= createInfixRightLeft(InfixExpression.Operator.MINUS, stack.pop(), stack.pop(), form.getResultType());
        break;


      case Const.IMUL:


      case Const.LMUL:


      case Const.FMUL:


      case Const.DMUL:


        instruction= createInfixRightLeft(InfixExpression.Operator.TIMES, stack.pop(), stack.pop(), form.getResultType());
        break;


      case Const.IDIV:


      case Const.LDIV:


      case Const.FDIV:


      case Const.DDIV:


        instruction= createInfixRightLeft(InfixExpression.Operator.DIVIDE, stack.pop(), stack.pop(), form.getResultType());
        break;


      case Const.IREM:


      case Const.LREM:


      case Const.FREM:


      case Const.DREM:


        instruction= createInfixRightLeft(InfixExpression.Operator.REMAINDER, stack.pop(), stack.pop(), form.getResultType());
        break;


      case Const.IXOR:


      case Const.LXOR:


        instruction= createInfixRightLeft(InfixExpression.Operator.XOR, stack.pop(), stack.pop(), form.getResultType());
        break;


      case Const.IAND:


      case Const.LAND:


        instruction= createInfixRightLeft(InfixExpression.Operator.AND, stack.pop(), stack.pop(), form.getResultType());
        break;


      case Const.IOR:


      case Const.LOR:


        instruction= createInfixRightLeft(InfixExpression.Operator.OR, stack.pop(), stack.pop(), form.getResultType());
        break;


      case Const.IINC:
      {


        boolean isWide= wide;
        int index= readUnsigned();


        wide= isWide;
        int constByte= readSigned();


        VariableBinding reference= createVariableBinding(index, Type.INT, true);
        reference.setField(false);


        Assignment assign= new Assignment(Assignment.Operator.PLUS_ASSIGN);
        assign.setLeftHandSide(reference);
        assign.setRightHandSide(NumberLiteral.create(new Integer(constByte)));
        instruction= assign;
        break;
      }


      case Const.ARRAYLENGTH:
      {


        Expression arrayRef= stack.pop();
        FieldAccess access= new FieldRead();
        access.setExpression(arrayRef);
        access.setName("length");


        instruction= access;
        break;
      }


      case Const.WIDE:


        wide= true;
        return new NoOperation();


      case Const.ILOAD_0:


      case Const.ILOAD_1:


      case Const.ILOAD_2:


      case Const.ILOAD_3:
      {


        VariableBinding reference= createVariableBinding(opcode - Const.ILOAD_0, Type.INT, false);
        reference.setField(false);
        instruction= reference;
        break;
      }


      case Const.LLOAD_0:


      case Const.LLOAD_1:


      case Const.LLOAD_2:


      case Const.LLOAD_3:
      {


        VariableBinding reference= createVariableBinding(opcode - Const.LLOAD_0, Type.LONG, false);
        reference.setField(false);
        instruction= reference;
        break;
      }


      case Const.FLOAD_0:


      case Const.FLOAD_1:


      case Const.FLOAD_2:


      case Const.FLOAD_3:
      {


        VariableBinding reference= createVariableBinding(opcode - Const.FLOAD_0, Type.FLOAT, false);
        reference.setField(false);
        instruction= reference;
        break;
      }


      case Const.DLOAD_0:


      case Const.DLOAD_1:


      case Const.DLOAD_2:


      case Const.DLOAD_3:
      {


        VariableBinding reference= createVariableBinding(opcode - Const.DLOAD_0, Type.DOUBLE, false);
        reference.setField(false);
        instruction= reference;
        break;
      }


      case Const.ALOAD_0:


      case Const.ALOAD_1:


      case Const.ALOAD_2:


      case Const.ALOAD_3:
      {


        if (opcode == Const.ALOAD_0 && !Modifier.isStatic(methodDecl.getAccess()))
        {
          ThisExpression reference= new ThisExpression();
          instruction= reference;
        }
        else
        {
          VariableBinding reference= createVariableBinding(opcode - Const.ALOAD_0, Type.OBJECT, false);
          reference.setField(true);
          instruction= reference;
        }
        break;
      }


      case Const.ILOAD:


      case Const.LLOAD:


      case Const.FLOAD:


      case Const.DLOAD:
      {


        VariableBinding reference= createVariableBinding(readUnsigned(), form.getResultType(), false);
        reference.setField(false);
        instruction= reference;
        break;
      }


      case Const.ALOAD:
      {


        VariableBinding reference= createVariableBinding(readUnsigned(), Type.OBJECT, false);
        reference.setField(true);
        instruction= reference;
        break;
      }


      case Const.BALOAD:


      case Const.CALOAD:


      case Const.SALOAD:


      case Const.IALOAD:


      case Const.LALOAD:


      case Const.FALOAD:


      case Const.DALOAD:


      case Const.AALOAD:
      {


        Expression index= stack.pop();
        Expression arrayRef= stack.pop();
        ArrayAccess aa;
        aa= new ArrayAccess();
        aa.setTypeBinding(form.getResultType());
        aa.setArray(arrayRef);
        aa.setIndex(index);


        instruction= aa;
        break;
      }


      case Const.BASTORE:


      case Const.CASTORE:


      case Const.SASTORE:


      case Const.IASTORE:


      case Const.LASTORE:


      case Const.FASTORE:


      case Const.DASTORE:


      case Const.AASTORE:
      {


        Expression value= stack.pop();
        Expression index= stack.pop();
        Expression arrayRef= stack.pop();
        if (arrayRef instanceof ArrayCreation)
        {
          ArrayCreation ac= (ArrayCreation) arrayRef;
          if (ac.getInitializer() == null)
          {
            ac.setInitializer(new ArrayInitializer());
          }
          ac.getInitializer().getExpressions().add(value);
          instruction= new NoOperation();
          break;
        }
        Assignment a= new Assignment(Assignment.Operator.ASSIGN);


        ArrayAccess aa;
        aa= new ArrayAccess();
        aa.setArray(arrayRef);
        aa.setIndex(index);


        a.setLeftHandSide(aa);
        a.setRightHandSide(value);
        instruction= a;
        break;
      }


      case Const.DSTORE:


      case Const.DSTORE_0:


      case Const.DSTORE_1:


      case Const.DSTORE_2:


      case Const.DSTORE_3:
      {


        int index;
        if (opcode == Const.DSTORE)
        {
          index= readUnsigned();
        }
        else
        {
          index= opcode - Const.DSTORE_0;
        }
        Assignment a= new Assignment(Assignment.Operator.ASSIGN);
        VariableBinding reference= createVariableBinding(index, Type.DOUBLE, true);
        reference.setField(false);
        a.setLeftHandSide(reference);
        a.setRightHandSide(stack.pop());
        instruction= a;
        break;
      }


      case Const.FSTORE:


      case Const.FSTORE_0:


      case Const.FSTORE_1:


      case Const.FSTORE_2:


      case Const.FSTORE_3:
      {


        int index;
        if (opcode == Const.FSTORE)
        {
          index= readUnsigned();
        }
        else
        {
          index= opcode - Const.FSTORE_0;
        }
        Assignment a= new Assignment(Assignment.Operator.ASSIGN);
        VariableBinding reference= createVariableBinding(index, Type.FLOAT, true);
        reference.setField(false);
        a.setLeftHandSide(reference);
        a.setRightHandSide(stack.pop());
        instruction= a;
        break;
      }


      case Const.ISTORE:


      case Const.ISTORE_0:


      case Const.ISTORE_1:


      case Const.ISTORE_2:


      case Const.ISTORE_3:
      {


        int index;
        if (opcode == Const.ISTORE)
        {
          index= readUnsigned();
        }
        else
        {
          index= opcode - Const.ISTORE_0;
        }
        Assignment a= new Assignment(Assignment.Operator.ASSIGN);
        VariableBinding reference= createVariableBinding(index, Type.INT, true);
        reference.setField(false);
        a.setLeftHandSide(reference);
        a.setRightHandSide(stack.pop());
        instruction= a;
        break;
      }


      case Const.LSTORE:


      case Const.LSTORE_0:


      case Const.LSTORE_1:


      case Const.LSTORE_2:


      case Const.LSTORE_3:
      {


        int index;
        if (opcode == Const.LSTORE)
        {
          index= readUnsigned();
        }
        else
        {
          index= opcode - Const.LSTORE_0;
        }
        Assignment a= new Assignment(Assignment.Operator.ASSIGN);
        VariableBinding reference= createVariableBinding(index, Type.LONG, true);
        reference.setField(false);
        a.setLeftHandSide(reference);
        a.setRightHandSide(stack.pop());
        instruction= a;
        break;
      }


      case Const.ASTORE:


      case Const.ASTORE_0:


      case Const.ASTORE_1:


      case Const.ASTORE_2:


      case Const.ASTORE_3:
      {


        Assignment a= new Assignment(Assignment.Operator.ASSIGN);
        int index;
        if (opcode == Const.ASTORE)
        {
          index= readUnsigned();
        }
        else
        {
          index= (opcode - Const.ASTORE_0);
        }
        VariableBinding reference= createVariableBinding(index, Type.OBJECT, true);
        a.setLeftHandSide(reference);


        if (stack.size() > 0)
        {
          a.setRightHandSide(stack.pop());
        }
        instruction= a;
        break;
      }

View Full Code Here

TOP

Related Classes of com.dragome.compiler.ast.Assignment

com.dragome.compiler.parser.Optimizer

com.dragome.compiler.parser.Pass1

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.