2.4/dev/core/src/com/google/gwt/dev/jjs/impl/gflow/constants/ConstantsAssumption.java - gwt - Git at Google

 /*
  * Copyright 2008 Google Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * License for the specific language governing permissions and limitations under
  * the License.
  */
 package com.google.gwt.dev.jjs.impl.gflow.constants;

 import com.google.gwt.dev.jjs.ast.HasName;
 import com.google.gwt.dev.jjs.ast.JDoubleLiteral;
 import com.google.gwt.dev.jjs.ast.JFloatLiteral;
 import com.google.gwt.dev.jjs.ast.JValueLiteral;
 import com.google.gwt.dev.jjs.ast.JVariable;
 import com.google.gwt.dev.jjs.impl.gflow.Assumption;
 import com.google.gwt.dev.util.Preconditions;

 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 /**
  * Assumptions for ConstantsAnalysis.
  *
  * Is a map from variable into it's constant value. If variable is not present
  * in the map, then it's not a constant.
  *
  * Empty ConstantsAssumption is a top of the lattice, and is not equals to
  * null assumption (which is the bottom of every lattice).
  */
 public class ConstantsAssumption implements Assumption<ConstantsAssumption> {
   /**
    * Updates the assumption by copying it on first write.
    */
   public static class Updater {
     private ConstantsAssumption assumption;
     private boolean copied = false;

     public Updater(ConstantsAssumption assumption) {
       this.assumption = assumption;
     }

     public Updater copy() {
       return new Updater(assumption);
     }

     public boolean hasAssumption(JVariable target) {
       if (assumption == null) {
         return false;
       }
       return assumption.hasAssumption(target);
     }

     public void set(JVariable target, JValueLiteral literal) {
       copyIfNeeded();
       assumption.set(target, literal);
     }

     public ConstantsAssumption unwrap() {
       if (assumption != null && assumption.isEmpty()) {
         return TOP;
       }
       return assumption;
     }

     private void copyIfNeeded() {
       if (!copied) {
         assumption = new ConstantsAssumption(assumption);
         copied = true;
       }
     }
   }

   /**
    * A wrapper around JValueLiteral to give it equals() method.
    */
   private static class LiteralWrapper {
     private final JValueLiteral literal;

     LiteralWrapper(JValueLiteral literal) {
       Preconditions.checkNotNull(literal);
       this.literal = literal;
     }

     @Override
     public boolean equals(Object obj) {
       if (obj == null) {
         return false;
       }

       if (obj == this) {
         return true;
       }

       LiteralWrapper other = (LiteralWrapper) obj;
       return equal(this.literal, other.literal);
     }

     @Override
     public int hashCode() {
       throw new UnsupportedOperationException();
     }

     @Override
     public String toString() {
       return literal.toString();
     }
   }

   /**
    * A TOP for the lattice. Means that all variables are not constant.
    */
   public static ConstantsAssumption TOP = new ConstantsAssumption();

   private static boolean equal(JValueLiteral literal1, JValueLiteral literal2) {
     if (literal1 == null || literal2 == null) {
       return literal1 == literal2;
     }

     if (literal1 == literal2) {
       return true;
     }

     if (literal1.getClass() != literal2.getClass()) {
       // these are different literal types.
       return false;
     }

     if (literal1 instanceof JFloatLiteral) {
       int bits1 = Float.floatToRawIntBits(
           ((JFloatLiteral) literal1).getValue());
       int bits2 = Float.floatToRawIntBits(
           ((JFloatLiteral) literal2).getValue());
       return bits1 == bits2;
     }

     if (literal1 instanceof JDoubleLiteral) {
       long bits1 = Double.doubleToRawLongBits(
           ((JDoubleLiteral) literal1).getValue());
       long bits2 = Double.doubleToRawLongBits(
           ((JDoubleLiteral) literal2).getValue());
       return bits1 == bits2;
     }

     Object valueObj1 = literal1.getValueObj();
     Object valueObj2 = literal2.getValueObj();
     if (valueObj1 == null || valueObj2 == null) {
       return valueObj1 == valueObj2;
     }

     return valueObj1.equals(valueObj2);
   }

   private static JValueLiteral join(JValueLiteral value1, JValueLiteral value2) {
     if (!equal(value1, value2)) {
       return null;
     }

     return value1;
   }

   private static JValueLiteral join(LiteralWrapper wrapper1,
       LiteralWrapper wrapper2) {
     if (wrapper1 == null || wrapper2 == null) {
       return null;
     }

     return join(wrapper1.literal, wrapper2.literal);
   }

   /**
    * Contains individual assumptions about variables. If variable isn't in the
    * map, then variable assumption is _|_ (bottom), if variable's value is
    * null, then variable assumption is T - variable has non-constant value.
    */
   private final Map<JVariable, LiteralWrapper> values;

   public ConstantsAssumption() {
     values = new HashMap<JVariable, LiteralWrapper>();
   }

   public ConstantsAssumption(ConstantsAssumption a) {
     if (a != null) {
       values = new HashMap<JVariable, LiteralWrapper>(a.values);
     } else {
       values = new HashMap<JVariable, LiteralWrapper>();
     }
   }

   @Override
   public boolean equals(Object obj) {
     if (obj == this) {
       return true;
     }
     if (obj == null) {
       return false;
     }
     ConstantsAssumption other = (ConstantsAssumption) obj;
     return values.equals(other.values);
   }

   /**
    * Get variable constant assumption. <code>null</code> if there's no constant
    * assumption for this variable.
    */
   public JValueLiteral get(JVariable variable) {
     LiteralWrapper wrapper = values.get(variable);
     return wrapper != null ? wrapper.literal : null;
   }

   /**
    * Check if we have constant (i.e. not top and not bottom) assumption about
    * the variable.
    */
   public boolean hasAssumption(JVariable variable) {
     return get(variable) != null;
   }

   @Override
   public int hashCode() {
     return values.hashCode();
   }

   public boolean isEmpty() {
     return values.isEmpty();
   }

   public ConstantsAssumption join(ConstantsAssumption other) {
     if (other == null) {
       return this;
     }

     if (other == TOP || this == TOP || isEmpty() || other.isEmpty()) {
       return TOP;
     }

     ConstantsAssumption result = new ConstantsAssumption();

     for (JVariable var : other.values.keySet()) {
       if (values.containsKey(var)) {
         // Var is present in both assumptions. Join their values.
         JValueLiteral value = join(values.get(var), other.values.get(var));
         if (value != null) {
           result.values.put(var, new LiteralWrapper(value));
         }
       }
     }

     if (result.isEmpty()) {
       return TOP;
     }

     return result;
   }

   public String toDebugString() {
     if (this == TOP || isEmpty()) {
       return "T";
     }
     StringBuffer result = new StringBuffer();

     result.append("{");
     List<JVariable> variables = new ArrayList<JVariable>(values.keySet());
     HasName.Util.sortByName(variables);
     for (JVariable variable : variables) {
       if (result.length() > 1) {
         result.append(", ");
       }
       result.append(variable.getName());
       result.append(" = ");
       if (values.get(variable) == null) {
         result.append("T");
       } else {
         result.append(values.get(variable));
       }
     }
     result.append("}");

     return result.toString();
   }

   @Override
   public String toString() {
     return toDebugString();
   }

   void set(JVariable variable, JValueLiteral literal) {
     if (literal != null) {
       values.put(variable, new LiteralWrapper(literal));
     } else {
       values.remove(variable);
     }
   }
 }
	/*
	* Copyright 2008 Google Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License"); you may not
	* use this file except in compliance with the License. You may obtain a copy of
	* the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	* License for the specific language governing permissions and limitations under
	* the License.
	*/
	package com.google.gwt.dev.jjs.impl.gflow.constants;

	import com.google.gwt.dev.jjs.ast.HasName;
	import com.google.gwt.dev.jjs.ast.JDoubleLiteral;
	import com.google.gwt.dev.jjs.ast.JFloatLiteral;
	import com.google.gwt.dev.jjs.ast.JValueLiteral;
	import com.google.gwt.dev.jjs.ast.JVariable;
	import com.google.gwt.dev.jjs.impl.gflow.Assumption;
	import com.google.gwt.dev.util.Preconditions;

	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	/**
	* Assumptions for ConstantsAnalysis.
	*
	* Is a map from variable into it's constant value. If variable is not present
	* in the map, then it's not a constant.
	*
	* Empty ConstantsAssumption is a top of the lattice, and is not equals to
	* null assumption (which is the bottom of every lattice).
	*/
	public class ConstantsAssumption implements Assumption<ConstantsAssumption> {
	/**
	* Updates the assumption by copying it on first write.
	*/
	public static class Updater {
	private ConstantsAssumption assumption;
	private boolean copied = false;

	public Updater(ConstantsAssumption assumption) {
	this.assumption = assumption;
	}

	public Updater copy() {
	return new Updater(assumption);
	}

	public boolean hasAssumption(JVariable target) {
	if (assumption == null) {
	return false;
	}
	return assumption.hasAssumption(target);
	}

	public void set(JVariable target, JValueLiteral literal) {
	copyIfNeeded();
	assumption.set(target, literal);
	}

	public ConstantsAssumption unwrap() {
	if (assumption != null && assumption.isEmpty()) {
	return TOP;
	}
	return assumption;
	}

	private void copyIfNeeded() {
	if (!copied) {
	assumption = new ConstantsAssumption(assumption);
	copied = true;
	}
	}
	}

	/**
	* A wrapper around JValueLiteral to give it equals() method.
	*/
	private static class LiteralWrapper {
	private final JValueLiteral literal;

	LiteralWrapper(JValueLiteral literal) {
	Preconditions.checkNotNull(literal);
	this.literal = literal;
	}

	@Override
	public boolean equals(Object obj) {
	if (obj == null) {
	return false;
	}

	if (obj == this) {
	return true;
	}

	LiteralWrapper other = (LiteralWrapper) obj;
	return equal(this.literal, other.literal);
	}

	@Override
	public int hashCode() {
	throw new UnsupportedOperationException();
	}

	@Override
	public String toString() {
	return literal.toString();
	}
	}

	/**
	* A TOP for the lattice. Means that all variables are not constant.
	*/
	public static ConstantsAssumption TOP = new ConstantsAssumption();

	private static boolean equal(JValueLiteral literal1, JValueLiteral literal2) {
	if (literal1 == null \|\| literal2 == null) {
	return literal1 == literal2;
	}

	if (literal1 == literal2) {
	return true;
	}

	if (literal1.getClass() != literal2.getClass()) {
	// these are different literal types.
	return false;
	}

	if (literal1 instanceof JFloatLiteral) {
	int bits1 = Float.floatToRawIntBits(
	((JFloatLiteral) literal1).getValue());
	int bits2 = Float.floatToRawIntBits(
	((JFloatLiteral) literal2).getValue());
	return bits1 == bits2;
	}

	if (literal1 instanceof JDoubleLiteral) {
	long bits1 = Double.doubleToRawLongBits(
	((JDoubleLiteral) literal1).getValue());
	long bits2 = Double.doubleToRawLongBits(
	((JDoubleLiteral) literal2).getValue());
	return bits1 == bits2;
	}

	Object valueObj1 = literal1.getValueObj();
	Object valueObj2 = literal2.getValueObj();
	if (valueObj1 == null \|\| valueObj2 == null) {
	return valueObj1 == valueObj2;
	}

	return valueObj1.equals(valueObj2);
	}

	private static JValueLiteral join(JValueLiteral value1, JValueLiteral value2) {
	if (!equal(value1, value2)) {
	return null;
	}

	return value1;
	}

	private static JValueLiteral join(LiteralWrapper wrapper1,
	LiteralWrapper wrapper2) {
	if (wrapper1 == null \|\| wrapper2 == null) {
	return null;
	}

	return join(wrapper1.literal, wrapper2.literal);
	}

	/**
	* Contains individual assumptions about variables. If variable isn't in the
	* map, then variable assumption is _\|_ (bottom), if variable's value is
	* null, then variable assumption is T - variable has non-constant value.
	*/
	private final Map<JVariable, LiteralWrapper> values;

	public ConstantsAssumption() {
	values = new HashMap<JVariable, LiteralWrapper>();
	}

	public ConstantsAssumption(ConstantsAssumption a) {
	if (a != null) {
	values = new HashMap<JVariable, LiteralWrapper>(a.values);
	} else {
	values = new HashMap<JVariable, LiteralWrapper>();
	}
	}

	@Override
	public boolean equals(Object obj) {
	if (obj == this) {
	return true;
	}
	if (obj == null) {
	return false;
	}
	ConstantsAssumption other = (ConstantsAssumption) obj;
	return values.equals(other.values);
	}

	/**
	* Get variable constant assumption. <code>null</code> if there's no constant
	* assumption for this variable.
	*/
	public JValueLiteral get(JVariable variable) {
	LiteralWrapper wrapper = values.get(variable);
	return wrapper != null ? wrapper.literal : null;
	}

	/**
	* Check if we have constant (i.e. not top and not bottom) assumption about
	* the variable.
	*/
	public boolean hasAssumption(JVariable variable) {
	return get(variable) != null;
	}

	@Override
	public int hashCode() {
	return values.hashCode();
	}

	public boolean isEmpty() {
	return values.isEmpty();
	}

	public ConstantsAssumption join(ConstantsAssumption other) {
	if (other == null) {
	return this;
	}

	if (other == TOP \|\| this == TOP \|\| isEmpty() \|\| other.isEmpty()) {
	return TOP;
	}

	ConstantsAssumption result = new ConstantsAssumption();

	for (JVariable var : other.values.keySet()) {
	if (values.containsKey(var)) {
	// Var is present in both assumptions. Join their values.
	JValueLiteral value = join(values.get(var), other.values.get(var));
	if (value != null) {
	result.values.put(var, new LiteralWrapper(value));
	}
	}
	}

	if (result.isEmpty()) {
	return TOP;
	}

	return result;
	}

	public String toDebugString() {
	if (this == TOP \|\| isEmpty()) {
	return "T";
	}
	StringBuffer result = new StringBuffer();

	result.append("{");
	List<JVariable> variables = new ArrayList<JVariable>(values.keySet());
	HasName.Util.sortByName(variables);
	for (JVariable variable : variables) {
	if (result.length() > 1) {
	result.append(", ");
	}
	result.append(variable.getName());
	result.append(" = ");
	if (values.get(variable) == null) {
	result.append("T");
	} else {
	result.append(values.get(variable));
	}
	}
	result.append("}");

	return result.toString();
	}

	@Override
	public String toString() {
	return toDebugString();
	}

	void set(JVariable variable, JValueLiteral literal) {
	if (literal != null) {
	values.put(variable, new LiteralWrapper(literal));
	} else {
	values.remove(variable);
	}
	}
	}