Mercurial > jdk8-mips64-public > langtools / file revision

 /*

  * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

  *

  * This code is free software; you can redistribute it and/or modify it

  * under the terms of the GNU General Public License version 2 only, as

  * published by the Free Software Foundation.  Oracle designates this

  * particular file as subject to the "Classpath" exception as provided

  * by Oracle in the LICENSE file that accompanied this code.

  *

  * This code 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 General Public License

  * version 2 for more details (a copy is included in the LICENSE file that

  * accompanied this code).

  *

  * You should have received a copy of the GNU General Public License version

  * 2 along with this work; if not, write to the Free Software Foundation,

  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

  *

  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

  * or visit www.oracle.com if you need additional information or have any

  * questions.

  */

 package org.openjdk.tests.shapegen;

 import java.util.ArrayList;

 import java.util.HashSet;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 /**

  *

  * @author Robert Field

  */

 public class ClassCase {

     public enum Kind {

         IVAC        (true,  "v"),

         IPRESENT    (true,  "p"),

         IDEFAULT    (true,  "d"),

         CNONE       (false, "n"),

         CABSTRACT   (false, "a"),

         CCONCRETE   (false, "c");

         private final String prefix;

         public final boolean isInterface;

         Kind(boolean isInterface, String prefix) {

             this.isInterface = isInterface;

             this.prefix = prefix;

         }

         public String getPrefix() { return prefix; }

     }

     public final Kind kind;

     private final ClassCase superclass;

     private final List<ClassCase> supertypes;

     private String name;

     private boolean _OK;

     private boolean _HasClassMethod;

     private Set<ClassCase> _mprov;

     private boolean _IsConcrete;

     private boolean _HasDefault;

     private ClassCase _mres;

     private ClassCase _mdefend;

     private Set<RuleGroup> executed = new HashSet<RuleGroup>();

     public ClassCase(Kind kind, ClassCase superclass, List<ClassCase> interfaces) {

         this.kind = kind;

         this.superclass = superclass;

         // Set supertypes from superclass (if any) and interfaces

         List<ClassCase> lc;

         if (superclass == null) {

             lc = interfaces;

         } else {

             lc = new ArrayList<>();

             lc.add(superclass);

             lc.addAll(interfaces);

         }

         this.supertypes = lc;

     }

     public final boolean isInterface() { return kind.isInterface; }

     public final boolean isClass() { return !kind.isInterface; }

     public Set<ClassCase> get_mprov() {

         exec(RuleGroup.PROVENENCE);

         return _mprov;

     }

     public void set_mprov(ClassCase cc) {

         Set<ClassCase> s = new HashSet<>();

         s.add(cc);

         _mprov = s;

     }

     public void set_mprov(Set<ClassCase> s) {

         _mprov = s;

     }

     public ClassCase get_mres() {

         exec(RuleGroup.RESOLUTION);

         return _mres;

     }

     public void set_mres(ClassCase cc) {

         _mres = cc;

     }

     public ClassCase get_mdefend() {

         exec(RuleGroup.DEFENDER);

         return _mdefend;

     }

     public void set_mdefend(ClassCase cc) {

         _mdefend = cc;

     }

     public boolean get_HasClassMethod() {

         exec(RuleGroup.PROVENENCE);

         return _HasClassMethod;

     }

     public void set_HasClassMethod(boolean bool) {

         _HasClassMethod = bool;

     }

     public boolean get_HasDefault() {

         exec(RuleGroup.MARKER);

         return _HasDefault;

     }

     public void set_HasDefault(boolean bool) {

         _HasDefault = bool;

     }

     public boolean get_IsConcrete() {

         exec(RuleGroup.MARKER);

         return _IsConcrete;

     }

     public void set_IsConcrete(boolean bool) {

         _IsConcrete = bool;

     }

     public boolean get_OK() {

         exec(RuleGroup.CHECKING);

         return _OK;

     }

     public void set_OK(boolean bool) {

         _OK = bool;

     }

     public boolean isMethodDefined() {

         for (ClassCase cc : supertypes) {

             if (cc.isMethodDefined()) {

                 return true;

             }

         }

         switch (kind) {

             case CCONCRETE:

             case CABSTRACT:

             case IPRESENT:

             case IDEFAULT:

                 return true;

             default:

                 return false;

         }

     }

     public boolean isAbstract() {

         return isMethodDefined() && (get_mres()==null);

     }

     public boolean hasSuperclass() {

         return superclass != null;

     }

     public ClassCase getSuperclass() {

         return superclass;

     }

     public List<ClassCase> getSupertypes() {

         return supertypes;

     }

     public List<ClassCase> getInterfaces() {

         if (superclass != null) {

             if (supertypes.get(0) != superclass) {

                 throw new AssertionError("superclass missing from supertypes");

             }

             return supertypes.subList(1, supertypes.size());

         } else {

             return supertypes;

         }

     }

     public boolean isSubtypeOf(ClassCase cc) {

         // S-Refl

         if (cc.equals(this)) {

             return true;

         }

         // S-Def

         for (ClassCase sp : getSupertypes()) {

             if (cc.equals(sp)) {

                 return true;

             }

         }

         // _S-Trans

         for (ClassCase sp : getSupertypes()) {

             if (sp.isSubtypeOf(cc)) {

                 return true;

             }

         }

         return false;

     }

     public void init(Map<String, Integer> namingContext) {

         if (name != null) {

             return; // Already inited

         }

         for (ClassCase sup : supertypes) {

             sup.init(namingContext);

         }

         // Build name

         StringBuilder sb = new StringBuilder();

         if (!supertypes.isEmpty()) {

             sb.append(isInterface() ? "I" : "C");

             for (ClassCase cc : supertypes) {

                 sb.append(cc.getName());

             }

             sb.append(kind.isInterface ? "i" : "c");

         }

         sb.append(kind.prefix);

         String pname = sb.toString();

         Integer icnt = namingContext.get(pname);

         int cnt = icnt == null ? 0 : icnt;

         ++cnt;

         namingContext.put(pname, cnt);

         if (cnt > 1) {

             sb.append(cnt);

         }

         this.name = sb.toString();

     }

     public boolean isa(Kind... kinds) {

         for (Kind k : kinds) {

             if (kind == k) {

                 return true;

             }

         }

         return false;

     }

     private void exec(RuleGroup rg ) {

         if (!executed.contains(rg)) {

             rg.exec(this);

             executed.add(rg);

         }

     }

     public void collectClasses(Set<ClassCase> seen) {

         seen.add(this);

         for (ClassCase cc : supertypes) {

             cc.collectClasses(seen);

         }

     }

     public String getID() {

         if (name == null) {

             throw new Error("Access to uninitialized ClassCase");

         } else {

             return name;

         }

     }

     public final String getName() {

         if (name == null) {

             return "ClassCase uninited@" + hashCode();

         } else {

             return name;

         }

     }

     @Override

     public boolean equals(Object obj) {

         return obj instanceof ClassCase && getID().equals(((ClassCase)obj).getID());

     }

     @Override

     public int hashCode() {

         return getID().hashCode();

     }

     @Override

     public String toString() {

         return getName();

     }

 }