libjava/classpath/gnu/java/lang/reflect/GenericSignatureParser.java

   1 /* GenericSignatureParser.java
   2    Copyright (C) 2005
   3    Free Software Foundation
   4
   5 This file is part of GNU Classpath.
   6
   7 GNU Classpath is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU Classpath is distributed in the hope that it will be useful, but
  13 WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU Classpath; see the file COPYING.  If not, write to the
  19 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20 02110-1301 USA.
  21
  22 Linking this library statically or dynamically with other modules is
  23 making a combined work based on this library.  Thus, the terms and
  24 conditions of the GNU General Public License cover the whole
  25 combination.
  26
  27 As a special exception, the copyright holders of this library give you
  28 permission to link this library with independent modules to produce an
  29 executable, regardless of the license terms of these independent
  30 modules, and to copy and distribute the resulting executable under
  31 terms of your choice, provided that you also meet, for each linked
  32 independent module, the terms and conditions of the license of that
  33 module.  An independent module is a module which is not derived from
  34 or based on this library.  If you modify this library, you may extend
  35 this exception to your version of the library, but you are not
  36 obligated to do so.  If you do not wish to do so, delete this
  37 exception statement from your version. */
  38
  39 package gnu.java.lang.reflect;
  40
  41 import java.lang.reflect.*;
  42 import java.util.ArrayList;
  43 import java.util.Arrays;
  44
  45 final class TypeVariableImpl extends TypeImpl implements TypeVariable
  46 {
  47     private GenericDeclaration decl;
  48     private Type[] bounds;
  49     private String name;
  50
  51     TypeVariableImpl(GenericDeclaration decl, Type[] bounds, String name)
  52     {
  53         this.decl = decl;
  54         this.bounds = bounds;
  55         this.name = name;
  56     }
  57
  58     Type resolve()
  59     {
  60         return this;
  61     }
  62
  63     /* FIXME[GENERICS]: Remove cast */
  64     public Type[] getBounds()
  65     {
  66         resolve(bounds);
  67         return (Type[]) bounds.clone();
  68     }
  69
  70     public GenericDeclaration getGenericDeclaration()
  71     {
  72         return decl;
  73     }
  74
  75     public String getName()
  76     {
  77         return name;
  78     }
  79
  80     public boolean equals(Object obj)
  81     {
  82         if (obj instanceof TypeVariableImpl)
  83         {
  84             TypeVariableImpl other = (TypeVariableImpl)obj;
  85             return decl.equals(other.decl) && name.equals(other.name);
  86         }
  87         return false;
  88     }
  89
  90     public int hashCode()
  91     {
  92         return 0x5f4d5156 ^ decl.hashCode() ^ name.hashCode();
  93     }
  94
  95     public String toString()
  96     {
  97         return name;
  98     }
  99 }
 100
 101 final class ParameterizedTypeImpl extends TypeImpl implements ParameterizedType
 102 {
 103     private String rawTypeName;
 104     private ClassLoader loader;
 105     private Class rawType;
 106     private Type owner;
 107     private Type[] typeArgs;
 108
 109     ParameterizedTypeImpl(String rawTypeName, ClassLoader loader, Type owner,
 110         Type[] typeArgs)
 111     {
 112         this.rawTypeName = rawTypeName;
 113         this.loader = loader;
 114         this.owner = owner;
 115         this.typeArgs = typeArgs;
 116     }
 117
 118     Type resolve()
 119     {
 120         if (rawType == null)
 121         {
 122             try
 123             {
 124                 rawType = Class.forName(rawTypeName, false, loader);
 125             }
 126             catch (ClassNotFoundException x)
 127             {
 128                 throw new TypeNotPresentException(rawTypeName, x);
 129             }
 130         }
 131         if (typeArgs == null)
 132         {
 133             if (owner == null)
 134             {
 135                 return rawType;
 136             }
 137             typeArgs = new Type[0];
 138         }
 139         resolve(typeArgs);
 140         owner = resolve(owner);
 141         return this;
 142     }
 143
 144     /* FIXME[GENERICS]: Remove cast */
 145     public Type[] getActualTypeArguments()
 146     {
 147         return (Type[]) typeArgs.clone();
 148     }
 149
 150     public Type getRawType()
 151     {
 152         return rawType;
 153     }
 154
 155     public Type getOwnerType()
 156     {
 157         return owner;
 158     }
 159
 160     public boolean equals(Object obj)
 161     {
 162         if (obj instanceof ParameterizedTypeImpl)
 163         {
 164             ParameterizedTypeImpl other = (ParameterizedTypeImpl)obj;
 165             return rawType.equals(other.rawType)
 166                 && ((owner == null && other.owner == null)
 167                     || owner.equals(other.owner))
 168                 && Arrays.deepEquals(typeArgs, other.typeArgs);
 169         }
 170         return false;
 171     }
 172
 173     public int hashCode()
 174     {
 175         int h = 0x58158970 ^ rawType.hashCode();
 176         if (owner != null)
 177         {
 178             h ^= Integer.reverse(owner.hashCode());
 179         }
 180         for (int i = 0; i < typeArgs.length; i++)
 181         {
 182             h ^= Integer.rotateLeft(typeArgs[i].hashCode(), i);
 183         }
 184         return h;
 185     }
 186
 187     public String toString()
 188     {
 189         StringBuilder sb = new StringBuilder();
 190         if (owner != null)
 191         {
 192             sb.append(owner);
 193             sb.append('.');
 194             sb.append(rawType.getSimpleName());
 195         }
 196         else
 197         {
 198             sb.append(rawTypeName);
 199         }
 200         if (typeArgs.length > 0)
 201         {
 202             sb.append('<');
 203             for (int i = 0; i < typeArgs.length; i++)
 204             {
 205                 if (i > 0)
 206                     sb.append(", ");
 207                 if (typeArgs[i] instanceof Class)
 208                 {
 209                     sb.append(((Class)typeArgs[i]).getName());
 210                 }
 211                 else
 212                 {
 213                     sb.append(typeArgs[i]);
 214                 }
 215             }
 216             sb.append('>');
 217         }
 218         return sb.toString();
 219     }
 220 }
 221
 222 final class GenericArrayTypeImpl extends TypeImpl implements GenericArrayType
 223 {
 224     private Type componentType;
 225
 226     GenericArrayTypeImpl(Type componentType)
 227     {
 228         this.componentType = componentType;
 229     }
 230
 231     Type resolve()
 232     {
 233         componentType = resolve(componentType);
 234         return this;
 235     }
 236
 237     public Type getGenericComponentType()
 238     {
 239         return componentType;
 240     }
 241
 242     public boolean equals(Object obj)
 243     {
 244         if (obj instanceof GenericArrayTypeImpl)
 245         {
 246             GenericArrayTypeImpl other = (GenericArrayTypeImpl)obj;
 247             return componentType.equals(other.componentType);
 248         }
 249         return false;
 250     }
 251
 252     public int hashCode()
 253     {
 254         return 0x4be37a7f ^ componentType.hashCode();
 255     }
 256
 257     public String toString()
 258     {
 259         return componentType + "[]";
 260     }
 261 }
 262
 263 final class UnresolvedTypeVariable extends TypeImpl implements Type
 264 {
 265     private GenericDeclaration decl;
 266     private String name;
 267
 268     UnresolvedTypeVariable(GenericDeclaration decl, String name)
 269     {
 270         this.decl = decl;
 271         this.name = name;
 272     }
 273
 274     Type resolve()
 275     {
 276         GenericDeclaration d = decl;
 277         while (d != null)
 278         {
 279             TypeVariable[] vars = d.getTypeParameters();
 280             for (int a = 0; a < vars.length  ; ++a)
 281             {
 282                 if (vars[a].getName().equals(name))
 283                 {
 284                     return vars[a];
 285                 }
 286             }
 287             d = getParent(d);
 288         }
 289         throw new MalformedParameterizedTypeException();
 290     }
 291
 292     private static GenericDeclaration getParent(GenericDeclaration d)
 293     {
 294         if (d instanceof Class)
 295         {
 296             Method m = ((Class)d).getEnclosingMethod();
 297             if (m != null)
 298             {
 299                 return m;
 300             }
 301             Constructor c = ((Class)d).getEnclosingConstructor();
 302             if (c != null)
 303             {
 304                 return c;
 305             }
 306             return ((Class)d).getEnclosingClass();
 307         }
 308         else if (d instanceof Method)
 309         {
 310             return ((Method)d).getDeclaringClass();
 311         }
 312         else if (d instanceof Constructor)
 313         {
 314             return ((Constructor)d).getDeclaringClass();
 315         }
 316         else
 317         {
 318             // TODO figure out what this represents
 319             throw new Error();
 320         }
 321     }
 322 }
 323
 324 final class WildcardTypeImpl extends TypeImpl implements WildcardType
 325 {
 326     private Type lower;
 327     private Type upper;
 328
 329     WildcardTypeImpl(Type lower, Type upper)
 330     {
 331         this.lower = lower;
 332         this.upper = upper;
 333     }
 334
 335     Type resolve()
 336     {
 337         upper = resolve(upper);
 338         lower = resolve(lower);
 339         return this;
 340     }
 341
 342     public Type[] getUpperBounds()
 343     {
 344         if (upper == null)
 345         {
 346             return new Type[0];
 347         }
 348         return new Type[] { upper };
 349     }
 350
 351     public Type[] getLowerBounds()
 352     {
 353         if (lower == null)
 354         {
 355             return new Type[0];
 356         }
 357         return new Type[] { lower };
 358     }
 359
 360     public boolean equals(Object obj)
 361     {
 362         if (obj instanceof WildcardTypeImpl)
 363         {
 364             WildcardTypeImpl other = (WildcardTypeImpl)obj;
 365             return Arrays.deepEquals(getUpperBounds(), other.getUpperBounds())
 366                 && Arrays.deepEquals(getLowerBounds(), other.getLowerBounds());
 367         }
 368         return false;
 369     }
 370
 371     public int hashCode()
 372     {
 373         int h = 0x75d074fd;
 374         if (upper != null)
 375         {
 376             h ^= upper.hashCode();
 377         }
 378         if (lower != null)
 379         {
 380             h ^= lower.hashCode();
 381         }
 382         return h;
 383     }
 384
 385     public String toString()
 386     {
 387         if (lower != null)
 388         {
 389             return "? super " + lower;
 390         }
 391         if (upper == java.lang.Object.class)
 392         {
 393             return "?";
 394         }
 395         return "? extends " + upper;
 396     }
 397 }
 398
 399 class GenericSignatureParser
 400 {
 401     private ClassLoader loader;
 402     private GenericDeclaration container;
 403     private String signature;
 404     private int pos;
 405
 406     GenericSignatureParser(GenericDeclaration container, ClassLoader loader,
 407         String signature)
 408     {
 409         this.container = container;
 410         this.loader = loader;
 411         this.signature = signature;
 412     }
 413
 414     TypeVariable[] readFormalTypeParameters()
 415     {
 416         consume('<');
 417         ArrayList params = new ArrayList();
 418         do
 419         {
 420             // TODO should we handle name clashes?
 421             params.add(readFormalTypeParameter());
 422         } while (peekChar() != '>');
 423         consume('>');
 424         TypeVariable[] list = new TypeVariable[params.size()];
 425         params.toArray(list);
 426         return list;
 427     }
 428
 429     private TypeVariable readFormalTypeParameter()
 430     {
 431         String identifier = readIdentifier();
 432         consume(':');
 433         ArrayList bounds = new ArrayList();
 434         if (peekChar() != ':')
 435         {
 436             bounds.add(readFieldTypeSignature());
 437         }
 438         while (peekChar() == ':')
 439         {
 440             consume(':');
 441             bounds.add(readFieldTypeSignature());
 442         }
 443         Type[] b = new Type[bounds.size()];
 444         bounds.toArray(b);
 445         return new TypeVariableImpl(container, b, identifier);
 446     }
 447
 448     Type readFieldTypeSignature()
 449     {
 450         switch (peekChar())
 451         {
 452             case 'L':
 453                 return readClassTypeSignature();
 454             case '[':
 455                 return readArrayTypeSignature();
 456             case 'T':
 457                 return readTypeVariableSignature();
 458             default:
 459                 throw new GenericSignatureFormatError();
 460         }
 461     }
 462
 463     Type readClassTypeSignature()
 464     {
 465         consume('L');
 466         String className = "";
 467         for (;;)
 468         {
 469             String part = readIdentifier();
 470             if (peekChar() != '/')
 471             {
 472                 className += part;
 473                 break;
 474             }
 475             consume('/');
 476             className += part + ".";
 477         }
 478         Type[] typeArguments = null;
 479         if (peekChar() == '<')
 480         {
 481             typeArguments = readTypeArguments();
 482         }
 483         Type type = new ParameterizedTypeImpl(className, loader, null,
 484                                               typeArguments);
 485         while (peekChar() == '.')
 486         {
 487             consume('.');
 488             className += "$" + readIdentifier();
 489             typeArguments = null;
 490             if (peekChar() == '<')
 491             {
 492                 typeArguments = readTypeArguments();
 493             }
 494             type = new ParameterizedTypeImpl(className, loader, type,
 495                                              typeArguments);
 496         }
 497         consume(';');
 498         return type;
 499     }
 500
 501     private Type[] readTypeArguments()
 502     {
 503         consume('<');
 504         ArrayList list = new ArrayList();
 505         do
 506         {
 507             list.add(readTypeArgument());
 508         } while ((peekChar() != '>'));
 509         consume('>');
 510         Type[] arr = new Type[list.size()];
 511         list.toArray(arr);
 512         return arr;
 513     }
 514
 515     private Type readTypeArgument()
 516     {
 517         char c = peekChar();
 518         if (c == '+')
 519         {
 520             consume('+');
 521             return new WildcardTypeImpl(null, readFieldTypeSignature());
 522         }
 523         else if (c == '-')
 524         {
 525             consume('-');
 526             return new WildcardTypeImpl(readFieldTypeSignature(),
 527                 java.lang.Object.class);
 528         }
 529         else if (c == '*')
 530         {
 531             consume('*');
 532             return new WildcardTypeImpl(null, java.lang.Object.class);
 533         }
 534         else
 535         {
 536             return readFieldTypeSignature();
 537         }
 538     }
 539
 540     Type readArrayTypeSignature()
 541     {
 542         consume('[');
 543         switch (peekChar())
 544         {
 545             case 'L':
 546             case '[':
 547             case 'T':
 548                 return new GenericArrayTypeImpl(readFieldTypeSignature());
 549             case 'Z':
 550                 consume('Z');
 551                 return boolean[].class;
 552             case 'B':
 553                 consume('B');
 554                 return byte[].class;
 555             case 'S':
 556                 consume('S');
 557                 return short[].class;
 558             case 'C':
 559                 consume('C');
 560                 return char[].class;
 561             case 'I':
 562                 consume('I');
 563                 return int[].class;
 564             case 'F':
 565                 consume('F');
 566                 return float[].class;
 567             case 'J':
 568                 consume('J');
 569                 return long[].class;
 570             case 'D':
 571                 consume('D');
 572                 return double[].class;
 573             default:
 574                 throw new GenericSignatureFormatError();
 575         }
 576     }
 577
 578     Type readTypeVariableSignature()
 579     {
 580         consume('T');
 581         String identifier = readIdentifier();
 582         consume(';');
 583         return new UnresolvedTypeVariable(container, identifier);
 584     }
 585
 586     private String readIdentifier()
 587     {
 588         int start = pos;
 589         char c;
 590         do
 591         {
 592             readChar();
 593             c = peekChar();
 594         } while (";:./<>-+*".indexOf(c) == -1);
 595         return signature.substring(start, pos);
 596     }
 597
 598     final char peekChar()
 599     {
 600         if (pos == signature.length())
 601             return '\u0000';
 602         else
 603             return signature.charAt(pos);
 604     }
 605
 606     final char readChar()
 607     {
 608         return signature.charAt(pos++);
 609     }
 610
 611     final void consume(char c)
 612     {
 613         if (readChar() != c)
 614             throw new GenericSignatureFormatError();
 615     }
 616
 617     final void end()
 618     {
 619         if (pos != signature.length())
 620             throw new GenericSignatureFormatError();
 621     }
 622 }