---

Ref.java

package edu.ksu.cis.bandera.bir;

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * Bandera, a Java(TM) analysis and transformation toolkit           *
 * Copyright (C) 1998, 1999   James Corbett (corbett@hawaii.edu)     *
 * All rights reserved.                                              *
 *                                                                   *
 * This work was done as a project in the SAnToS Laboratory,         *
 * Department of Computing and Information Sciences, Kansas State    *
 * University, USA (http://www.cis.ksu.edu/santos).                  *
 * It is understood that any modification not identified as such is  *
 * not covered by the preceding statement.                           *
 *                                                                   *
 * This work is free software; you can redistribute it and/or        *
 * modify it under the terms of the GNU Library General Public       *
 * License as published by the Free Software Foundation; either      *
 * version 2 of the License, or (at your option) any later version.  *
 *                                                                   *
 * This work is distributed in the hope that it will be useful,      *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of    *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU *
 * Library General Public License for more details.                  *
 *                                                                   *
 * You should have received a copy of the GNU Library General Public *
 * License along with this toolkit; if not, write to the             *
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,      *
 * Boston, MA  02111-1307, USA.                                      *
 *                                                                   *
 * Java is a trademark of Sun Microsystems, Inc.                     *
 *                                                                   *
 * To submit a bug report, send a comment, or get the latest news on *
 * this project and other SAnToS projects, please visit the web-site *
 *                http://www.cis.ksu.edu/santos                      *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
import ca.mcgill.sable.util.*;
import ca.mcgill.sable.soot.SootClass;

import java.io.*;
import java.util.*;

import edu.ksu.cis.bandera.birc.TypeExtractor;
import edu.ksu.cis.bandera.prog.HierarchyQuery;

/**
 * A reference type.
 * <p>
 * A reference in BIR is defined with a set of state variables (which
 * must be records or arrays) to which it can refer.  A reference
 * can also refer to a collection, in which case the reference points
 * to an element of the collection.
 * <p>
 * Since reference types can be declared before the state variables
 * to which they refer, reference types must be resolved by finding
 * the variables named in the type and connecting them to the reference
 * type.
 */

public class Ref extends Type implements BirConstants {

    TransSystem system;
    StateVarVector targets;
    Vector targetNames;
    Type targetType;
    SootClass sootType;
    /**
     * Create a resolved reference type that can refer to 
     * a specific state variable.
     */
    public Ref(StateVar target) {
    this.targetNames = new Vector(10);
    this.targetNames.addElement(target.getName());
    this.targets = new StateVarVector(1);
    this.targets.addElement(target);
    this.targetType = liftCollectionType(target.getType());
    this.system = target.getSystem();
    }
    /**
     * Create a resolved reference type that can refer to 
     * a specific set of state variables.
     */
    public Ref(StateVarVector targets, TransSystem system) {
    this.targets = targets;
    this.targetType = new Record();
    this.system = system;
    }
    /**
     * Create an empty, unresolved reference type
     */
    public Ref(TransSystem system) {
    this.targetNames = new Vector(10);
    this.system = system;
    }
    public void addTarget(StateVar var) {
    if (targets == null) 
        targets = new StateVarVector(10);
    targets.addElement(var);
    if (targets.size() == 1)
        targetType = liftCollectionType(var.getType());
    else
        targetType = superType(targetType,
                   liftCollectionType(var.getType()));
    }
public void addTarget(StateVar var, SootClass sootClass, TypeExtractor extractor) {
    if (targets == null)
        targets = new StateVarVector(10);
    targets.addElement(var);
    if (targets.size() == 1) {
        targetType = liftCollectionType(var.getType());
        sootType = sootClass;
    } else {
        // targetType = superType(targetType,
        //                   liftCollectionType(var.getType()));
        //
        // This is a massive hack. It couples BIR to Soot and BIRC!
        // We really want a cleaner way of doing this. Perhaps an
        // explicit representation of the BIR type hierarchy is in order.
        //
        // Right now, inheritence is detected by field name/type/ordering
        // (i.e., if type a is a prefix of type b then its a parent). Fortunately,
        // the BIRC Builder only forces this "paternity test" on BIR types
        // that are known to be derived from related Soot types.
        //
        sootType = HierarchyQuery.leastAncestor(sootType, sootClass);
        targetType = extractor.getRecordType(sootType);
    }
}
    public void addTarget(String name) {
    targetNames.addElement(name);
    }
    public void apply(TypeSwitch sw, Object o)
    {
        sw.caseRef(this, o);
    }
    /**
     * The target type of a reference type is the least common supertype
     * of all the types of its targets.  The empty record is a supertype
     * of all types since no operations can be performed to it.
     */

    Type computeTargetType() {
    Type result = liftCollectionType(targets.elementAt(0).getType());
    for (int i = 1; i < targets.size(); i++) {
        Type targetType = targets.elementAt(i).getType();
        result = superType(result, liftCollectionType(targetType));
    }
    return result;
    }
    public boolean containsValue(Object value) { // Robbyjo's patch
        return (value instanceof NullExpr) || (value instanceof RefLit);
    }
    public Expr defaultVal() { 
    return new NullExpr(system); 
    }
    public boolean equals(Object o) {
    return this == o;
    }
    public StateVarVector getTargets() { return targets; }
    public Type getTargetType() { return targetType; }
    public boolean isKind(int kind) { 
    return (kind & REF) != 0;
    }
    /**
     * Test if type is a subtype of another (i.e., contains a subset of
     * its targets).
     */

    public boolean isSubtypeOf(Type type) {
    if (! type.isKind(REF))
        return false; 
    Ref other = (Ref) type;
    for (int i = 0; i < this.targets.size(); i++)
        if (! other.targets.contains(this.targets.elementAt(i)))
        return false;
    return true;
    }
    /**
     * Return the base type of a collection.
     */

    Type liftCollectionType(Type type) {
    return type.isKind(COLLECTION) ? 
        ((Collection)type).getBaseType() : type;
    }
    /**
     * Resolve a reference type by finding the state variables
     * named in the type and computing the target type.
     */
    public void resolveTargets() {
    targets = new StateVarVector(targetNames.size());
    for (int i = 0; i < targetNames.size(); i++) {
        String name = (String) targetNames.elementAt(i);
        Object key = system.getKeyOf(name);
        if (key == null) 
        throw new RuntimeException("Unknown object in Ref type: "
                       + name);
        StateVar var = system.getVarOfKey(key);
        if (! var.getType().isKind(RECORD | ARRAY | COLLECTION)) 
        throw new RuntimeException("Ref type must refer to record, array or collection: " + name + " is a " + var.getType());
        targets.addElement(var);
    }
    targetType = computeTargetType();
    }
    /**
     * Compute the least common supertype of two types.
     */
     
    Type superType(Type type1, Type type2) {
    if (type1 == type2)
        return type1;
    // If both arrays of same type, return the one with smaller size
    if (type1.isKind(ARRAY) && type2.isKind(ARRAY) 
        && (((Array)type1).getBaseType() == ((Array)type2).getBaseType())) 
        if (((Array)type1).getSize().getValue() > 
        ((Array)type2).getSize().getValue())
        return type2;
        else
        return type1;
    // If both records, one must have a subset of the other's fields
    // Return the smaller type
    if (type1.isKind(RECORD) && type2.isKind(RECORD)) {
        int i;
        Vector fields1 = ((Record)type1).getFields();
        Vector fields2 = ((Record)type2).getFields();
        for (i = 0; i < fields1.size() && i < fields2.size(); i++) 
        if (! fields2.elementAt(i).equals(fields1.elementAt(i))) 
            break;
        if (i == fields1.size())
        return type1;
        if (i == fields2.size())
        return type2;
    }
    // Else ref is to any object, return empty record

// Here's where we need to query the type hierarchy
//   to find the least ancestor type and return it
//
// In fact, type hierarchy information can be used to replace this entire
// method.
    return new Record();
    }
    // Printing
    public String toString() {
    if (this == system.refAnyType())
        return "ref { * }";
    String result = targets.elementAt(0).getName();
    for (int i = 1; i < targets.size(); i++) 
        result += ", " + targets.elementAt(i).getName();
    return "ref { " + result + " }";
    }
}

---