    001    /* Copyright 2000, 2001, Compaq Computer Corporation */
    002
    003    package escjava.tc;
    004
    005    import javafe.ast.*;
    006    import escjava.ast.TagConstants;
    007
    008    import javafe.tc.*;
    009
    010    import javafe.util.*;
    011
    012    public class Types extends javafe.tc.Types
    013    {
    014        static {
    015            inst = new Types();
    016        }
    017
    018        public static void init() {
    019        }
    020
    021        protected javafe.tc.TypeSig makeTypeSigInstance(String simpleName,
    022                                            /*@ non_null */ Env enclosingEnv,
    023                                            /*@ non_null */ TypeDecl decl) {
    024                    return new escjava.tc.TypeSig(simpleName,
    025                                                    enclosingEnv,
    026                                                    decl);
    027        }
    028
    029        protected javafe.tc.TypeSig makeTypeSigInstance(String[] packageName,
    030                                    /*@ non_null */ String simpleName,
    031                                    javafe.tc.TypeSig enclosingType,
    032                                    TypeDecl decl,
    033                                    CompilationUnit cu) {
    034            return new escjava.tc.TypeSig(packageName, simpleName,
    035                                    enclosingType, decl, cu);
    036        }
    037
    038
    039        public static PrimitiveType
    040                anyType = PrimitiveType.make(TagConstants.ANY, Location.NULL);
    041
    042        public static PrimitiveType
    043                typecodeType = PrimitiveType.make(TagConstants.TYPECODE, Location.NULL);
    044        //public static Type typecodeType = javaLangClass();
    045
    046        public static PrimitiveType
    047                locksetType = PrimitiveType.make(TagConstants.LOCKSET, Location.NULL);
    048
    049        public static PrimitiveType
    050                objectsetType = PrimitiveType.make(TagConstants.OBJECTSET, Location.NULL);
    051
    052        public static PrimitiveType
    053                rangeType = PrimitiveType.make(TagConstants.DOTDOT, Location.NULL);
    054
    055        //@ invariant bigintType != null;
    056        public static PrimitiveType
    057                bigintType = PrimitiveType.make( TagConstants.BIGINTTYPE, Location.NULL );
    058
    059        //@ invariant realType != null;
    060        public static PrimitiveType
    061                realType = PrimitiveType.make( TagConstants.REALTYPE, Location.NULL );
    062
    063
    064        public static boolean isTypeType(Type t) {
    065            //return t.getTag() == TagConstants.TYPECODE;
    066            return t.getTag() == TagConstants.TYPECODE || t.equals(javaLangClass());
    067        }
    068
    069
    070        public boolean isSameTypeInstance(Type t, Type tt) {
    071            if (isTypeType(t) && isTypeType(tt)) return true;
    072            return super.isSameTypeInstance(t,tt);
    073        }
    074
    075        public boolean isCastableInstance(Type t, Type tt) {
    076            boolean b = super.isCastableInstance(t,tt);
    077            if (b) return b;
    078            if (t.getTag() == TagConstants.BYTETYPE &&
    079                    tt.getTag() == TagConstants.BIGINTTYPE) return true;
    080            if (t.getTag() == TagConstants.SHORTTYPE &&
    081                    tt.getTag() == TagConstants.BIGINTTYPE) return true;
    082            if (t.getTag() == TagConstants.INTTYPE &&
    083                    tt.getTag() == TagConstants.BIGINTTYPE) return true;
    084            if (t.getTag() == TagConstants.LONGTYPE &&
    085                    tt.getTag() == TagConstants.BIGINTTYPE) return true;
    086            if (t.getTag() == TagConstants.TYPECODE)
    087                    return super.isCastableInstance(javaLangClass(),tt);
    088            if (tt.getTag() == TagConstants.TYPECODE)
    089                    return super.isCastableInstance(t,javaLangClass());
    090            return b;
    091        }
    092
    093        public boolean isIntegralTypeInstance(Type t){
    094            if ((t instanceof PrimitiveType) &&
    095                    ((PrimitiveType)t).getTag() == TagConstants.BIGINTTYPE) return true;
    096            return super.isIntegralTypeInstance(t);
    097        }
    098
    099        public boolean isNumericTypeInstance(Type t){
    100            if( t instanceof PrimitiveType ) {
    101                PrimitiveType p = (PrimitiveType)t;
    102                if (p.getTag() == TagConstants.BIGINTTYPE) return true;
    103                if (p.getTag() == TagConstants.REALTYPE) return true;
    104            }
    105            return super.isNumericTypeInstance(t);
    106        }
    107
    108        public boolean isFloatingPointTypeInstance(Type t){
    109            if( t instanceof PrimitiveType ) {
    110                if (((PrimitiveType)t).tag == TagConstants.REALTYPE) return true;
    111            }
    112            return super.isFloatingPointTypeInstance(t);
    113        }
    114
    115        protected boolean isWideningPrimitiveConvertableInstance( Type x, Type y ) {
    116
    117            switch( x.getTag() ) {
    118            case TagConstants.BYTETYPE:
    119            case TagConstants.SHORTTYPE:
    120            case TagConstants.INTTYPE:
    121            case TagConstants.LONGTYPE:
    122                switch( y.getTag() ) {
    123                case TagConstants.BIGINTTYPE:
    124                case TagConstants.REALTYPE:
    125                    return true;
    126                default:
    127                    break;
    128                }
    129
    130            case TagConstants.BIGINTTYPE:
    131                switch( y.getTag() ) {
    132                case TagConstants.REALTYPE:
    133                    return true;
    134                default:
    135                    break;
    136                }
    137
    138            case TagConstants.FLOATTYPE:
    139            case TagConstants.DOUBLETYPE:
    140                switch( y.getTag() ) {
    141                case TagConstants.REALTYPE:
    142                    return true;
    143                default:
    144                    break;
    145                }
    146            default:
    147                break;
    148            }
    149
    150        return super.isWideningPrimitiveConvertableInstance(x,y);
    151    }
    152
    153
    154
    155        /**
    156         * This routine overrides {@link javafe.tc.Types#lookupField}.  Unlike that
    157         * routine, it knows about ghost fields and spec_public.
    158         *
    159         * <p> This routine assumes we are in an annotation so ghost fields are visible
    160         * and spec_public is equivalent to public. </a>
    161         */
    162    /*
    163        //@ requires t != null
    164        public FieldDecl lookupFieldInstance(Type t, Identifier id, javafe.tc.TypeSig caller)
    165                throws LookupException {
    166            Assert.notNull(t);
    167            if (t instanceof TypeName)
    168                t = TypeSig.getSig((TypeName) t);
    169            Assert.notNull(t);
    170
    171            / *
    172             * Looking up a field in an arraytype is equivalent to looking
    173             * up that field in java.lang.Object unless the field name is
    174             * "length":
    175             * /
    176            if (t instanceof ArrayType && id != javafe.tc.Types.lenId)
    177                t = javaLangObject();
    178
    179            // Our functionality is different only for TypeSigs:
    180            if (!(t instanceof TypeSig))
    181                return javafe.tc.Types.lookupField(t, id, caller);
    182            TypeSig sig = (TypeSig)t;
    183
    184            //      /*
    185            //       * Extend caller to handle spec_public:
    186            //       * /
    187            //      caller = new ExtendedTypeSig(caller);
    188
    189            // Search for a normal field first; propogate any errors other
    190            // than NOTFOUND:
    191            try {
    192                return sig.lookupField(id, caller);
    193            } catch (LookupException E) {
    194                if (E.reason != LookupException.NOTFOUND)
    195                    throw E;
    196            }
    197
    198            // If not found, search for a ghost field:
    199            GhostEnv G = new GhostEnv(sig.getEnclosingEnv(), sig, false);
    200            FieldDecl decl = G.getGhostField(id.toString(), null);
    201            if (decl==null)
    202                throw new LookupException(LookupException.NOTFOUND);
    203
    204            // Make sure the ghost field is not ambiguous:
    205            if (G.getGhostField(id.toString(), decl) != null)
    206                throw new LookupException(LookupException.AMBIGUOUS);
    207
    208            // Ghost fields are always public, so no access checking required...
    209            // FIXME - no longer true
    210
    211            return decl;
    212        }
    213    */
    214    } // end of class Types
    215
    216    /*
    217     * Local Variables:
    218     * Mode: Java
    219     * fill-column: 85
    220     * End:
    221     */