PageRenderTime 26ms CodeModel.GetById 16ms RepoModel.GetById 0ms app.codeStats 0ms

/projects/findbugs-1.3.9/src/patches/obsolete/bcel-30-April-2003.patch

https://gitlab.com/essere.lab.public/qualitas.class-corpus
Patch | 1254 lines | 1162 code | 92 blank | 0 comment | 0 complexity | 8fd271b3074f9f7a5c6ee04da9e0cd8c MD5 | raw file
    

  1. ? HelloWorld.class
    2. 

  2. ? java
    3. 

  3. ? docs/api
    4. 

  4. Index: examples/TransitiveHull.java
    5. 

  5. ===================================================================
    6. 

  6. RCS file: /home/cvspublic/jakarta-bcel/examples/TransitiveHull.java,v
    7. 

  7. retrieving revision 1.2
    8. 

  8. diff -u -r1.2 TransitiveHull.java
    9. 

  9. --- examples/TransitiveHull.java	10 Nov 2002 18:30:05 -0000	1.2
    10. 

  10. +++ examples/TransitiveHull.java	30 Apr 2003 17:53:51 -0000
    11. 

  11. @@ -24,6 +24,12 @@
    12. 

  12.   * @author  <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
    13. 

  13.   */
    14. 

  14.  public class TransitiveHull extends org.apache.bcel.classfile.EmptyVisitor {
    15. 

  15. +  private static class LookupFailure extends RuntimeException {
    16. 

  16. +    public LookupFailure(String msg) {
    17. 

  17. +      super(msg);
    18. 

  18. +    }
    19. 

  19. +  }
    20. 

  20. +
    21. 

  21.    private JavaClass    _class;
    22. 

  22.    private ClassQueue   _queue;
    23. 

  23.    private ClassSet     _set;
    24. 

  24. @@ -86,10 +92,14 @@
    25. 

  25.        return;
    26. 

  26.      }
    27. 

  27.      
    28. 

  28. -    JavaClass clazz = Repository.lookupClass(class_name);
    29. 

  29. +    try {
    30. 

  30. +      JavaClass clazz = Repository.lookupClass(class_name);
    31. 

  31.      
    32. 

  32. -    if(clazz != null && _set.add(clazz)) {
    33. 

  33. -      _queue.enqueue(clazz);
    34. 

  34. +      if(_set.add(clazz)) {
    35. 

  35. +        _queue.enqueue(clazz);
    36. 

  36. +      }
    37. 

  37. +    } catch (ClassNotFoundException e) {
    38. 

  38. +      throw new LookupFailure("Missing class: " + e.toString());
    39. 

  39.      }
    40. 

  40.    }
    41. 

  41.  
    42. 

  42. Index: src/java/org/apache/bcel/Repository.java
    43. 

  43. ===================================================================
    44. 

  44. RCS file: /home/cvspublic/jakarta-bcel/src/java/org/apache/bcel/Repository.java,v
    45. 

  45. retrieving revision 1.11
    46. 

  46. diff -u -r1.11 Repository.java
    47. 

  47. --- src/java/org/apache/bcel/Repository.java	11 Oct 2002 20:34:47 -0000	1.11
    48. 

  48. +++ src/java/org/apache/bcel/Repository.java	30 Apr 2003 17:53:51 -0000
    49. 

  49. @@ -88,33 +88,32 @@
    50. 

  50.    /** Lookup class somewhere found on your CLASSPATH, or whereever the
    51. 

  51.     * repository instance looks for it.
    52. 

  52.     *
    53. 

  53. -   * @return class object for given fully qualified class name, or null
    54. 

  54. -   * if the class could not be found or parsed correctly
    55. 

  55. +   * @return class object for given fully qualified class name
    56. 

  56. +   * @throws ClassNotFoundException if the class could not be found or
    57. 

  57. +   * parsed correctly
    58. 

  58.     */
    59. 

  59. -  public static JavaClass lookupClass(String class_name) {
    60. 

  60. -    try {
    61. 

  61. -      JavaClass clazz = _repository.findClass(class_name);
    62. 

  62. +  public static JavaClass lookupClass(String class_name)
    63. 

  63. +    throws ClassNotFoundException {
    64. 

  64.  
    65. 

  65. -      if(clazz == null) {
    66. 

  66. -	return _repository.loadClass(class_name);
    67. 

  67. -      } else {
    68. 

  68. -	return clazz;
    69. 

  69. -      }
    70. 

  70. -    } catch(ClassNotFoundException ex) { return null; }
    71. 

  71. +    return _repository.loadClass(class_name);
    72. 

  72.    }
    73. 

  73.  
    74. 

  74.    /**
    75. 

  75. -   * Try to find class source via getResourceAsStream().
    76. 

  76. +   * Try to find class source using the internal repository instance.
    77. 

  77.     * @see Class
    78. 

  78.     * @return JavaClass object for given runtime class
    79. 

  79. +   * @throws ClassNotFoundException if the class could not be found or
    80. 

  80. +   * parsed correctly
    81. 

  81.     */
    82. 

  82. -  public static JavaClass lookupClass(Class clazz) {
    83. 

  83. -    try {
    84. 

  84. -      return _repository.loadClass(clazz);
    85. 

  85. -    } catch(ClassNotFoundException ex) { return null; }
    86. 

  86. +  public static JavaClass lookupClass(Class clazz)
    87. 

  87. +    throws ClassNotFoundException {
    88. 

  88. +    return _repository.loadClass(clazz);
    89. 

  89.    }
    90. 

  90.  
    91. 

  91. -  /** @return class file object for given Java class.
    92. 

  92. +  /**
    93. 

  93. +   * @return class file object for given Java class by looking on the
    94. 

  94. +   *  system class path; returns null if the class file can't be
    95. 

  95. +   *  found
    96. 

  96.     */
    97. 

  97.    public static ClassPath.ClassFile lookupClassFile(String class_name) {
    98. 

  98.      try {
    99. 

  99. @@ -156,92 +155,124 @@
    100. 

  100.    /**
    101. 

  101.     * @return list of super classes of clazz in ascending order, i.e.,
    102. 

  102.     * Object is always the last element
    103. 

  103. +   * @throws ClassNotFoundException if any of the superclasses can't be found
    104. 

  104.     */
    105. 

  105. -  public static JavaClass[] getSuperClasses(JavaClass clazz) {
    106. 

  106. +  public static JavaClass[] getSuperClasses(JavaClass clazz)
    107. 

  107. +    throws ClassNotFoundException {
    108. 

  108.      return clazz.getSuperClasses();
    109. 

  109.    }
    110. 

  110.  
    111. 

  111.    /**
    112. 

  112.     * @return list of super classes of clazz in ascending order, i.e.,
    113. 

  113. -   * Object is always the last element. return "null", if class
    114. 

  114. -   * cannot be found.
    115. 

  115. +   * Object is always the last element.
    116. 

  116. +   * @throws ClassNotFoundException if the named class or any of its
    117. 

  117. +   *  superclasses can't be found
    118. 

  118.     */
    119. 

  119. -  public static JavaClass[] getSuperClasses(String class_name) {
    120. 

  120. +  public static JavaClass[] getSuperClasses(String class_name)
    121. 

  121. +    throws ClassNotFoundException {
    122. 

  122.      JavaClass jc = lookupClass(class_name);
    123. 

  123. -    return (jc == null? null : getSuperClasses(jc));
    124. 

  124. +    return getSuperClasses(jc);
    125. 

  125.    }
    126. 

  126.  
    127. 

  127.    /**
    128. 

  128.     * @return all interfaces implemented by class and its super
    129. 

  129.     * classes and the interfaces that those interfaces extend, and so on.
    130. 

  130.     * (Some people call this a transitive hull).
    131. 

  131. +   * @throws ClassNotFoundException if any of the class's
    132. 

  132. +   *  superclasses or superinterfaces can't be found
    133. 

  133.     */
    134. 

  134. -  public static JavaClass[] getInterfaces(JavaClass clazz) {
    135. 

  135. +  public static JavaClass[] getInterfaces(JavaClass clazz)
    136. 

  136. +    throws ClassNotFoundException {
    137. 

  137.      return clazz.getAllInterfaces();
    138. 

  138.    }
    139. 

  139.  
    140. 

  140.    /**
    141. 

  141.     * @return all interfaces implemented by class and its super
    142. 

  142.     * classes and the interfaces that extend those interfaces, and so on
    143. 

  143. +   * @throws ClassNotFoundException if the named class can't be found,
    144. 

  144. +   *   or if any of its superclasses or superinterfaces can't be found
    145. 

  145.     */
    146. 

  146. -  public static JavaClass[] getInterfaces(String class_name) {
    147. 

  147. +  public static JavaClass[] getInterfaces(String class_name)
    148. 

  148. +    throws ClassNotFoundException {
    149. 

  149.      return getInterfaces(lookupClass(class_name));
    150. 

  150.    }
    151. 

  151.  
    152. 

  152.    /**
    153. 

  153.     * Equivalent to runtime "instanceof" operator.
    154. 

  154.     * @return true, if clazz is an instance of super_class
    155. 

  155. +   * @throws ClassNotFoundException if any superclasses or superinterfaces
    156. 

  156. +   *   of clazz can't be found
    157. 

  157.     */
    158. 

  158. -  public static boolean instanceOf(JavaClass clazz, JavaClass super_class) {
    159. 

  159. +  public static boolean instanceOf(JavaClass clazz, JavaClass super_class)
    160. 

  160. +    throws ClassNotFoundException {
    161. 

  161.      return clazz.instanceOf(super_class);
    162. 

  162.    }
    163. 

  163.  
    164. 

  164.    /**
    165. 

  165.     * @return true, if clazz is an instance of super_class
    166. 

  166. +   * @throws ClassNotFoundException if either clazz or super_class
    167. 

  167. +   *   can't be found
    168. 

  168.     */
    169. 

  169. -  public static boolean instanceOf(String clazz, String super_class) {
    170. 

  170. +  public static boolean instanceOf(String clazz, String super_class)
    171. 

  171. +    throws ClassNotFoundException {
    172. 

  172.      return instanceOf(lookupClass(clazz), lookupClass(super_class));
    173. 

  173.    }
    174. 

  174.  
    175. 

  175.    /**
    176. 

  176.     * @return true, if clazz is an instance of super_class
    177. 

  177. +   * @throws ClassNotFoundException if super_class can't be found
    178. 

  178.     */
    179. 

  179. -  public static boolean instanceOf(JavaClass clazz, String super_class) {
    180. 

  180. +  public static boolean instanceOf(JavaClass clazz, String super_class)
    181. 

  181. +    throws ClassNotFoundException {
    182. 

  182.      return instanceOf(clazz, lookupClass(super_class));
    183. 

  183.    }
    184. 

  184.  
    185. 

  185.    /**
    186. 

  186.     * @return true, if clazz is an instance of super_class
    187. 

  187. +   * @throws ClassNotFoundException if clazz can't be found
    188. 

  188.     */
    189. 

  189. -  public static boolean instanceOf(String clazz, JavaClass super_class) {
    190. 

  190. +  public static boolean instanceOf(String clazz, JavaClass super_class)
    191. 

  191. +    throws ClassNotFoundException {
    192. 

  192.      return instanceOf(lookupClass(clazz), super_class);
    193. 

  193.    }
    194. 

  194.  
    195. 

  195.    /**
    196. 

  196.     * @return true, if clazz is an implementation of interface inter
    197. 

  197. +   * @throws ClassNotFoundException if any superclasses or superinterfaces
    198. 

  198. +   *   of clazz can't be found
    199. 

  199.     */
    200. 

  200. -  public static boolean implementationOf(JavaClass clazz, JavaClass inter) {
    201. 

  201. +  public static boolean implementationOf(JavaClass clazz, JavaClass inter)
    202. 

  202. +    throws ClassNotFoundException {
    203. 

  203.      return clazz.implementationOf(inter);
    204. 

  204.    }
    205. 

  205.  
    206. 

  206.    /**
    207. 

  207.     * @return true, if clazz is an implementation of interface inter
    208. 

  208. +   * @throws ClassNotFoundException if clazz, inter, or any superclasses
    209. 

  209. +   *   or superinterfaces of clazz can't be found
    210. 

  210.     */
    211. 

  211. -  public static boolean implementationOf(String clazz, String inter) {
    212. 

  212. +  public static boolean implementationOf(String clazz, String inter)
    213. 

  213. +    throws ClassNotFoundException {
    214. 

  214.      return implementationOf(lookupClass(clazz), lookupClass(inter));
    215. 

  215.    }
    216. 

  216.  
    217. 

  217.    /**
    218. 

  218.     * @return true, if clazz is an implementation of interface inter
    219. 

  219. +   * @throws ClassNotFoundException if inter or any superclasses
    220. 

  220. +   *   or superinterfaces of clazz can't be found
    221. 

  221.     */
    222. 

  222. -  public static boolean implementationOf(JavaClass clazz, String inter) {
    223. 

  223. +  public static boolean implementationOf(JavaClass clazz, String inter)
    224. 

  224. +    throws ClassNotFoundException {
    225. 

  225.      return implementationOf(clazz, lookupClass(inter));
    226. 

  226.    }
    227. 

  227.  
    228. 

  228.    /**
    229. 

  229.     * @return true, if clazz is an implementation of interface inter
    230. 

  230. +   * @throws ClassNotFoundException if clazz or any superclasses or
    231. 

  231. +   *   superinterfaces of clazz can't be found
    232. 

  232.     */
    233. 

  233. -  public static boolean implementationOf(String clazz, JavaClass inter) {
    234. 

  234. +  public static boolean implementationOf(String clazz, JavaClass inter)
    235. 

  235. +    throws ClassNotFoundException {
    236. 

  236.      return implementationOf(lookupClass(clazz), inter);
    237. 

  237.    }
    238. 

  238.  }
    239. 

  239. Index: src/java/org/apache/bcel/classfile/JavaClass.java
    240. 

  240. ===================================================================
    241. 

  241. RCS file: /home/cvspublic/jakarta-bcel/src/java/org/apache/bcel/classfile/JavaClass.java,v
    242. 

  242. retrieving revision 1.13
    243. 

  243. diff -u -r1.13 JavaClass.java
    244. 

  244. --- src/java/org/apache/bcel/classfile/JavaClass.java	11 Jul 2002 19:39:04 -0000	1.13
    245. 

  245. +++ src/java/org/apache/bcel/classfile/JavaClass.java	30 Apr 2003 17:53:51 -0000
    246. 

  246. @@ -685,9 +685,13 @@
    247. 

  247.  
    248. 

  248.    /** Equivalent to runtime "instanceof" operator.
    249. 

  249.     *
    250. 

  250. -   * @return true if this JavaClass is derived from teh super class
    251. 

  251. +   * @return true if this JavaClass is derived from the super class
    252. 

  252. +   * @throws ClassNotFoundException if superclasses or superinterfaces
    253. 

  253. +   *   of this object can't be found
    254. 

  254.     */
    255. 

  255. -  public final boolean instanceOf(JavaClass super_class) {
    256. 

  256. +  public final boolean instanceOf(JavaClass super_class)
    257. 

  257. +    throws ClassNotFoundException {
    258. 

  258. +
    259. 

  259.      if(this.equals(super_class))
    260. 

  260.        return true;
    261. 

  261.  
    262. 

  262. @@ -707,9 +711,13 @@
    263. 

  263.    }
    264. 

  264.  
    265. 

  265.    /**
    266. 

  266. -   * @return true, if clazz is an implementation of interface inter
    267. 

  267. +   * @return true, if this class is an implementation of interface inter
    268. 

  268. +   * @throws ClassNotFoundException if superclasses or superinterfaces
    269. 

  269. +   *   of this class can't be found
    270. 

  270.     */
    271. 

  271. -  public boolean implementationOf(JavaClass inter) {
    272. 

  272. +  public boolean implementationOf(JavaClass inter)
    273. 

  273. +    throws ClassNotFoundException {
    274. 

  274. +
    275. 

  275.      if(!inter.isInterface()) {
    276. 

  276.        throw new IllegalArgumentException(inter.getClassName() + " is no interface");
    277. 

  277.      }
    278. 

  278. @@ -732,25 +740,22 @@
    279. 

  279.    /**
    280. 

  280.     * @return the superclass for this JavaClass object, or null if this
    281. 

  281.     * is java.lang.Object
    282. 

  282. +   * @throws ClassNotFoundException if the superclass can't be found
    283. 

  283.     */
    284. 

  284. -  public JavaClass getSuperClass() {
    285. 

  285. +  public JavaClass getSuperClass() throws ClassNotFoundException {
    286. 

  286.      if("java.lang.Object".equals(getClassName())) {
    287. 

  287.        return null;
    288. 

  288.      }
    289. 

  289.  
    290. 

  290. -    try {
    291. 

  291. -      return repository.loadClass(getSuperclassName());
    292. 

  292. -    } catch(ClassNotFoundException e) {
    293. 

  293. -      System.err.println(e);
    294. 

  294. -      return null;
    295. 

  295. -    }
    296. 

  296. +    return repository.loadClass(getSuperclassName());
    297. 

  297.    }
    298. 

  298.  
    299. 

  299.    /**
    300. 

  300.     * @return list of super classes of this class in ascending order, i.e.,
    301. 

  301.     * java.lang.Object is always the last element
    302. 

  302. +   * @throws ClassNotFoundException if any of the superclasses can't be found
    303. 

  303.     */
    304. 

  304. -  public JavaClass[] getSuperClasses() {
    305. 

  305. +  public JavaClass[] getSuperClasses() throws ClassNotFoundException {
    306. 

  306.      JavaClass   clazz = this;
    307. 

  307.      ClassVector vec   = new ClassVector();
    308. 

  308.  
    309. 

  309. @@ -766,17 +771,12 @@
    310. 

  310.    /**
    311. 

  311.     * Get interfaces directly implemented by this JavaClass.
    312. 

  312.     */
    313. 

  313. -  public JavaClass[] getInterfaces() {
    314. 

  314. +  public JavaClass[] getInterfaces() throws ClassNotFoundException {
    315. 

  315.      String[]    interfaces = getInterfaceNames();
    316. 

  316.      JavaClass[] classes    = new JavaClass[interfaces.length];
    317. 

  317.  
    318. 

  318. -    try {
    319. 

  319. -      for(int i = 0; i < interfaces.length; i++) {
    320. 

  320. -	classes[i] = repository.loadClass(interfaces[i]);
    321. 

  321. -      }
    322. 

  322. -    } catch(ClassNotFoundException e) {
    323. 

  323. -      System.err.println(e);
    324. 

  324. -      return null;
    325. 

  325. +    for(int i = 0; i < interfaces.length; i++) {
    326. 

  326. +      classes[i] = repository.loadClass(interfaces[i]);
    327. 

  327.      }
    328. 

  328.  
    329. 

  329.      return classes;
    330. 

  330. @@ -785,7 +785,7 @@
    331. 

  331.    /**
    332. 

  332.     * Get all interfaces implemented by this JavaClass (transitively).
    333. 

  333.     */
    334. 

  334. -  public JavaClass[] getAllInterfaces() {
    335. 

  335. +  public JavaClass[] getAllInterfaces() throws ClassNotFoundException {
    336. 

  336.      ClassQueue  queue = new ClassQueue();
    337. 

  337.      ClassVector vec   = new ClassVector();
    338. 

  338.      
    339. 

  339. Index: src/java/org/apache/bcel/classfile/Signature.java
    340. 

  340. ===================================================================
    341. 

  341. RCS file: /home/cvspublic/jakarta-bcel/src/java/org/apache/bcel/classfile/Signature.java,v
    342. 

  342. retrieving revision 1.3
    343. 

  343. diff -u -r1.3 Signature.java
    344. 

  344. --- src/java/org/apache/bcel/classfile/Signature.java	11 Mar 2002 16:16:35 -0000	1.3
    345. 

  345. +++ src/java/org/apache/bcel/classfile/Signature.java	30 Apr 2003 17:53:51 -0000
    346. 

  346. @@ -111,7 +111,7 @@
    347. 

  347.     * @param v Visitor object
    348. 

  348.     */
    349. 

  349.     public void accept(Visitor v) {
    350. 

  350. -     System.err.println("Visiting non-standard Signature object");
    351. 

  351. +     //System.err.println("Visiting non-standard Signature object");
    352. 

  352.       v.visitSignature(this);
    353. 

  353.     }
    354. 

  354.     
    355. 

  355. Index: src/java/org/apache/bcel/generic/ObjectType.java
    356. 

  356. ===================================================================
    357. 

  357. RCS file: /home/cvspublic/jakarta-bcel/src/java/org/apache/bcel/generic/ObjectType.java,v
    358. 

  358. retrieving revision 1.1.1.1
    359. 

  359. diff -u -r1.1.1.1 ObjectType.java
    360. 

  360. --- src/java/org/apache/bcel/generic/ObjectType.java	29 Oct 2001 20:00:25 -0000	1.1.1.1
    361. 

  361. +++ src/java/org/apache/bcel/generic/ObjectType.java	30 Apr 2003 17:53:51 -0000
    362. 

  362. @@ -93,12 +93,13 @@
    363. 

  363.     * If "this" doesn't reference a class, it references an interface
    364. 

  364.     * or a non-existant entity.
    365. 

  365.     */
    366. 

  366. -  public boolean referencesClass(){
    367. 

  367. -    JavaClass jc = Repository.lookupClass(class_name);
    368. 

  368. -    if (jc == null)
    369. 

  369. -      return false;
    370. 

  370. -    else
    371. 

  371. +  public boolean referencesClass() {
    372. 

  372. +    try {
    373. 

  373. +      JavaClass jc = Repository.lookupClass(class_name);
    374. 

  374.        return jc.isClass();
    375. 

  375. +    } catch (ClassNotFoundException e) {
    376. 

  376. +      return false;
    377. 

  377. +    }
    378. 

  378.    }
    379. 

  379.    
    380. 

  380.    /**
    381. 

  381. @@ -106,14 +107,22 @@
    382. 

  382.     * or a non-existant entity.
    383. 

  383.     */
    384. 

  384.    public boolean referencesInterface(){
    385. 

  385. -    JavaClass jc = Repository.lookupClass(class_name);
    386. 

  386. -    if (jc == null)
    387. 

  387. -      return false;
    388. 

  388. -    else
    389. 

  389. +    try {
    390. 

  390. +      JavaClass jc = Repository.lookupClass(class_name);
    391. 

  391.        return !jc.isClass();
    392. 

  392. +    } catch (ClassNotFoundException e) {
    393. 

  393. +      return false;
    394. 

  394. +    }
    395. 

  395.    }
    396. 

  396.  
    397. 

  397. -  public boolean subclassOf(ObjectType superclass){
    398. 

  398. +  /**
    399. 

  399. +   * Return true if this type is a subclass of given ObjectType.
    400. 

  400. +   * @throws ClassNotFoundException if any of this class's superclasses
    401. 

  401. +   *  can't be found
    402. 

  402. +   */
    403. 

  403. +  public boolean subclassOf(ObjectType superclass)
    404. 

  404. +    throws ClassNotFoundException {
    405. 

  405. +
    406. 

  406.      if (this.referencesInterface() || superclass.referencesInterface())
    407. 

  407.        return false;
    408. 

  408.  
    409. 

  409. @@ -122,8 +131,10 @@
    410. 

  410.  
    411. 

  411.    /**
    412. 

  412.     * Java Virtual Machine Specification edition 2, � 5.4.4 Access Control
    413. 

  413. +   * @throws ClassNotFoundException if the class referenced by this type
    414. 

  414. +   *   can't be found
    415. 

  415.     */
    416. 

  416. -  public boolean accessibleTo(ObjectType accessor) {
    417. 

  417. +  public boolean accessibleTo(ObjectType accessor) throws ClassNotFoundException {
    418. 

  418.      JavaClass jc = Repository.lookupClass(class_name);
    419. 

  419.  
    420. 

  420.      if(jc.isPublic()) {
    421. 

  421. Index: src/java/org/apache/bcel/generic/ReferenceType.java
    422. 

  422. ===================================================================
    423. 

  423. RCS file: /home/cvspublic/jakarta-bcel/src/java/org/apache/bcel/generic/ReferenceType.java,v
    424. 

  424. retrieving revision 1.5
    425. 

  425. diff -u -r1.5 ReferenceType.java
    426. 

  426. --- src/java/org/apache/bcel/generic/ReferenceType.java	7 Aug 2002 18:01:32 -0000	1.5
    427. 

  427. +++ src/java/org/apache/bcel/generic/ReferenceType.java	30 Apr 2003 17:53:51 -0000
    428. 

  428. @@ -82,8 +82,11 @@
    429. 

  429.     * However, because e.g. CHECKCAST doesn't throw a
    430. 

  430.     * ClassCastException when casting a null reference to any Object,
    431. 

  431.     * true is returned in this case.
    432. 

  432. +   *
    433. 

  433. +   * @throws ClassNotFoundException if any classes or interfaces required
    434. 

  434. +   *  to determine assignment compatibility can't be found
    435. 

  435.     */
    436. 

  436. -  public boolean isCastableTo(Type t) {
    437. 

  437. +  public boolean isCastableTo(Type t) throws ClassNotFoundException {
    438. 

  438.      if (this.equals(Type.NULL))
    439. 

  439.        return true;		// If this is ever changed in isAssignmentCompatible()
    440. 

  440.  
    441. 

  441. @@ -97,8 +100,12 @@
    442. 

  442.     * Return true iff this is assignment compatible with another type t
    443. 

  443.     * as defined in the JVM specification; see the AASTORE definition
    444. 

  444.     * there.
    445. 

  445. +   * @throws ClassNotFoundException if any classes or interfaces required
    446. 

  446. +   *  to determine assignment compatibility can't be found
    447. 

  447.     */
    448. 

  448. -  public boolean isAssignmentCompatibleWith(Type t) {
    449. 

  449. +  public boolean isAssignmentCompatibleWith(Type t)
    450. 

  450. +    throws ClassNotFoundException {
    451. 

  451. +
    452. 

  452.      if (!(t instanceof ReferenceType))
    453. 

  453.        return false;
    454. 

  454.  
    455. 

  455. @@ -210,8 +217,13 @@
    456. 

  456.     * If "this" or t is a ReferenceType referencing an interface, then Type.OBJECT is returned.
    457. 

  457.     * If not all of the two classes' superclasses cannot be found, "null" is returned.
    458. 

  458.     * See the JVM specification edition 2, "�4.9.2 The Bytecode Verifier".
    459. 

  459. +   *
    460. 

  460. +   * @throws ClassNotFoundException on failure to find superclasses of this
    461. 

  461. +   *  type, or the type passed as a parameter
    462. 

  462.     */
    463. 

  463. -  public ReferenceType getFirstCommonSuperclass(ReferenceType t) {
    464. 

  464. +  public ReferenceType getFirstCommonSuperclass(ReferenceType t)
    465. 

  465. +    throws ClassNotFoundException {
    466. 

  466. +
    467. 

  467.      if (this.equals(Type.NULL)) return t;
    468. 

  468.      if (t.equals(Type.NULL)) return this;
    469. 

  469.      if (this.equals(t)) return this;
    470. 

  470. @@ -294,8 +306,12 @@
    471. 

  471.     *
    472. 

  472.     * @deprecated use getFirstCommonSuperclass(ReferenceType t) which has
    473. 

  473.     *             slightly changed semantics.
    474. 

  474. +   * @throws ClassNotFoundException on failure to find superclasses of this
    475. 

  475. +   *  type, or the type passed as a parameter
    476. 

  476.     */
    477. 

  477. -  public ReferenceType firstCommonSuperclass(ReferenceType t) {
    478. 

  478. +  public ReferenceType firstCommonSuperclass(ReferenceType t)
    479. 

  479. +    throws ClassNotFoundException {
    480. 

  480. +
    481. 

  481.      if (this.equals(Type.NULL)) return t;
    482. 

  482.      if (t.equals(Type.NULL)) return this;
    483. 

  483.      if (this.equals(t)) return this;
    484. 

  484. Index: src/java/org/apache/bcel/util/SyntheticRepository.java
    485. 

  485. ===================================================================
    486. 

  486. RCS file: /home/cvspublic/jakarta-bcel/src/java/org/apache/bcel/util/SyntheticRepository.java,v
    487. 

  487. retrieving revision 1.6
    488. 

  488. diff -u -r1.6 SyntheticRepository.java
    489. 

  489. --- src/java/org/apache/bcel/util/SyntheticRepository.java	10 Nov 2002 18:30:05 -0000	1.6
    490. 

  490. +++ src/java/org/apache/bcel/util/SyntheticRepository.java	30 Apr 2003 17:53:51 -0000
    491. 

  491. @@ -138,6 +138,10 @@
    492. 

  492.    public JavaClass loadClass(String className) 
    493. 

  493.      throws ClassNotFoundException
    494. 

  494.    {
    495. 

  495. +    JavaClass alreadyLoaded = findClass(className);
    496. 

  496. +    if (alreadyLoaded != null)
    497. 

  497. +      return alreadyLoaded;
    498. 

  498. +
    499. 

  499.      if(className == null || className.equals("")) {
    500. 

  500.        throw new IllegalArgumentException("Invalid class name " + className);
    501. 

  501.      }
    502. 

  502. @@ -159,6 +163,11 @@
    503. 

  503.     */
    504. 

  504.    public JavaClass loadClass(Class clazz) throws ClassNotFoundException {
    505. 

  505.      String className = clazz.getName();
    506. 

  506. +
    507. 

  507. +    JavaClass alreadyLoaded = findClass(className);
    508. 

  508. +    if (alreadyLoaded != null)
    509. 

  509. +      return alreadyLoaded;
    510. 

  510. +
    511. 

  511.      String name      = className;
    512. 

  512.      int    i         = name.lastIndexOf('.');
    513. 

  513.  
    514. 

  514. Index: src/java/org/apache/bcel/verifier/TransitiveHull.java
    515. 

  515. ===================================================================
    516. 

  516. RCS file: /home/cvspublic/jakarta-bcel/src/java/org/apache/bcel/verifier/TransitiveHull.java,v
    517. 

  517. retrieving revision 1.1.1.1
    518. 

  518. diff -u -r1.1.1.1 TransitiveHull.java
    519. 

  519. --- src/java/org/apache/bcel/verifier/TransitiveHull.java	29 Oct 2001 20:00:31 -0000	1.1.1.1
    520. 

  520. +++ src/java/org/apache/bcel/verifier/TransitiveHull.java	30 Apr 2003 17:53:51 -0000
    521. 

  521. @@ -77,7 +77,7 @@
    522. 

  522.  	}
    523. 

  523.  	
    524. 

  524.  	/* Implementing VerifierFactoryObserver. */
    525. 

  525. -	public void update(String classname){
    526. 

  526. +	public void update(String classname) {
    527. 

  527.  
    528. 

  528.  		System.gc(); // avoid swapping if possible.
    529. 

  529.  
    530. 

  530. @@ -99,15 +99,19 @@
    531. 

  531.  			System.out.println("Pass 2:\n"+vr);
    532. 

  532.  
    533. 

  533.  		if (vr == VerificationResult.VR_OK){
    534. 

  534. -			JavaClass jc = Repository.lookupClass(v.getClassName());
    535. 

  535. -			for (int i=0; i<jc.getMethods().length; i++){
    536. 

  536. -				vr = v.doPass3a(i);
    537. 

  537. -				if (vr != VerificationResult.VR_OK) //System.exit(1);
    538. 

  538. -					System.out.println(v.getClassName()+", Pass 3a, method "+i+" ['"+jc.getMethods()[i]+"']:\n"+vr);
    539. 

  539. -
    540. 

  540. -				vr = v.doPass3b(i);
    541. 

  541. -				if (vr != VerificationResult.VR_OK) //System.exit(1);
    542. 

  542. -					System.out.println(v.getClassName()+", Pass 3b, method "+i+" ['"+jc.getMethods()[i]+"']:\n"+vr);
    543. 

  543. +			try {
    544. 

  544. +				JavaClass jc = Repository.lookupClass(v.getClassName());
    545. 

  545. +				for (int i=0; i<jc.getMethods().length; i++){
    546. 

  546. +					vr = v.doPass3a(i);
    547. 

  547. +					if (vr != VerificationResult.VR_OK) //System.exit(1);
    548. 

  548. +						System.out.println(v.getClassName()+", Pass 3a, method "+i+" ['"+jc.getMethods()[i]+"']:\n"+vr);
    549. 

  549. +	
    550. 

  550. +					vr = v.doPass3b(i);
    551. 

  551. +					if (vr != VerificationResult.VR_OK) //System.exit(1);
    552. 

  552. +						System.out.println(v.getClassName()+", Pass 3b, method "+i+" ['"+jc.getMethods()[i]+"']:\n"+vr);
    553. 

  553. +				}
    554. 

  554. +			} catch (ClassNotFoundException e) {
    555. 

  555. +				System.err.println("Could not find class " + v.getClassName() + " in Repository");
    556. 

  556.  			}
    557. 

  557.  		}
    558. 

  558.  
    559. 

  559. Index: src/java/org/apache/bcel/verifier/Verifier.java
    560. 

  560. ===================================================================
    561. 

  561. RCS file: /home/cvspublic/jakarta-bcel/src/java/org/apache/bcel/verifier/Verifier.java,v
    562. 

  562. retrieving revision 1.7
    563. 

  563. diff -u -r1.7 Verifier.java
    564. 

  564. --- src/java/org/apache/bcel/verifier/Verifier.java	13 Oct 2002 21:56:16 -0000	1.7
    565. 

  565. +++ src/java/org/apache/bcel/verifier/Verifier.java	30 Apr 2003 17:53:51 -0000
    566. 

  566. @@ -172,7 +172,7 @@
    567. 

  567.  	 * This returns all the (warning) messages collected during verification.
    568. 

  568.  	 * A prefix shows from which verifying pass a message originates.
    569. 

  569.  	 */
    570. 

  570. -	public String[] getMessages(){
    571. 

  571. +	public String[] getMessages() throws ClassNotFoundException {
    572. 

  572.  		ArrayList messages = new ArrayList();
    573. 

  573.  
    574. 

  574.  		if (p1v != null){
    575. 

  575. @@ -237,7 +237,7 @@
    576. 

  576.  	public static void main(String [] args){
    577. 

  577.  		System.out.println("JustIce by Enver Haase, (C) 2001-2002.\n<http://bcel.sourceforge.net>\n<http://jakarta.apache.org/bcel>\n");
    578. 

  578.  	  for(int k=0; k < args.length; k++) {
    579. 

  579. -
    580. 

  580. +		try {
    581. 

  581.  			if (args[k].endsWith(".class")){
    582. 

  582.  				int dotclasspos = args[k].lastIndexOf(".class");
    583. 

  583.  				if (dotclasspos != -1) args[k] = args[k].substring(0,dotclasspos);
    584. 

  584. @@ -278,9 +278,12 @@
    585. 

  585.  			System.out.println("\n");
    586. 

  586.  
    587. 

  587.  			// avoid swapping.
    588. 

  588. -	  	v.flush();
    589. 

  589. -	  	org.apache.bcel.Repository.clearCache();
    590. 

  590. -		System.gc();
    591. 

  591. +	  		v.flush();
    592. 

  592. +	  		org.apache.bcel.Repository.clearCache();
    593. 

  593. +			System.gc();
    594. 

  594. +		} catch (ClassNotFoundException e) {
    595. 

  595. +			e.printStackTrace();
    596. 

  596. +		}
    597. 

  597.  	  }
    598. 

  598.  	}
    599. 

  599.  }
    600. 

  600. Index: src/java/org/apache/bcel/verifier/VerifierAppFrame.java
    601. 

  601. ===================================================================
    602. 

  602. RCS file: /home/cvspublic/jakarta-bcel/src/java/org/apache/bcel/verifier/VerifierAppFrame.java,v
    603. 

  603. retrieving revision 1.3
    604. 

  604. diff -u -r1.3 VerifierAppFrame.java
    605. 

  605. --- src/java/org/apache/bcel/verifier/VerifierAppFrame.java	13 Jun 2002 09:32:50 -0000	1.3
    606. 

  606. +++ src/java/org/apache/bcel/verifier/VerifierAppFrame.java	30 Apr 2003 17:53:51 -0000
    607. 

  607. @@ -242,11 +242,16 @@
    608. 

  608.    synchronized void classNamesJList_valueChanged(ListSelectionEvent e) {
    609. 

  609.      if (e.getValueIsAdjusting()) return;
    610. 

  610.      current_class = classNamesJList.getSelectedValue().toString();
    611. 

  611. -    verify();
    612. 

  612. +    try {
    613. 

  613. +      verify();
    614. 

  614. +    } catch (ClassNotFoundException ex) {
    615. 

  615. +      // FIXME: report the error using the GUI
    616. 

  616. +      ex.printStackTrace();
    617. 

  617. +    }
    618. 

  618.      classNamesJList.setSelectedValue(current_class, true);
    619. 

  619.    }
    620. 

  620.  
    621. 

  621. -  private void verify(){
    622. 

  622. +  private void verify() throws ClassNotFoundException {
    623. 

  623.      setTitle("PLEASE WAIT");
    624. 

  624.  
    625. 

  625.      Verifier v = VerifierFactory.getVerifier(current_class);
    626. 

  626. @@ -345,7 +350,14 @@
    627. 

  627.            all3aok = false;
    628. 

  628.            rejected = true;
    629. 

  629.          }
    630. 

  630. -        all3amsg += "Method '"+Repository.lookupClass(v.getClassName()).getMethods()[i]+"': "+vr.getMessage().replace('\n',' ')+"\n\n";
    631. 

  631. +        JavaClass jc = null;
    632. 

  632. +	try {
    633. 

  633. +          jc = Repository.lookupClass(v.getClassName());
    634. 

  634. +        } catch (ClassNotFoundException ex) {
    635. 

  635. +          // FIXME: handle the error
    636. 

  636. +          ex.printStackTrace();
    637. 

  637. +        }
    638. 

  638. +        all3amsg += "Method '"+jc.getMethods()[i]+"': "+vr.getMessage().replace('\n',' ')+"\n\n";
    639. 

  639.        }
    640. 

  640.      }
    641. 

  641.      pass3aTextPane.setText(all3amsg);
    642. 

  642. @@ -370,7 +382,14 @@
    643. 

  643.            all3bok = false;
    644. 

  644.            rejected = true;
    645. 

  645.          }
    646. 

  646. -        all3bmsg += "Method '"+Repository.lookupClass(v.getClassName()).getMethods()[i]+"': "+vr.getMessage().replace('\n',' ')+"\n\n";
    647. 

  647. +        JavaClass jc = null;
    648. 

  648. +	try {
    649. 

  649. +          jc = Repository.lookupClass(v.getClassName());
    650. 

  650. +        } catch (ClassNotFoundException ex) {
    651. 

  651. +          // FIXME: handle the error
    652. 

  652. +          ex.printStackTrace();
    653. 

  653. +        }
    654. 

  654. +        all3bmsg += "Method '"+jc.getMethods()[i]+"': "+vr.getMessage().replace('\n',' ')+"\n\n";
    655. 

  655.        }
    656. 

  656.      }
    657. 

  657.      pass3bTextPane.setText(all3bmsg);
    658. 

  658. Index: src/java/org/apache/bcel/verifier/VerifyDialog.java
    659. 

  659. ===================================================================
    660. 

  660. RCS file: /home/cvspublic/jakarta-bcel/src/java/org/apache/bcel/verifier/VerifyDialog.java,v
    661. 

  661. retrieving revision 1.1.1.1
    662. 

  662. diff -u -r1.1.1.1 VerifyDialog.java
    663. 

  663. --- src/java/org/apache/bcel/verifier/VerifyDialog.java	29 Oct 2001 20:00:33 -0000	1.1.1.1
    664. 

  664. +++ src/java/org/apache/bcel/verifier/VerifyDialog.java	30 Apr 2003 17:53:51 -0000
    665. 

  665. @@ -539,7 +539,13 @@
    666. 

  666.  	Verifier v = VerifierFactory.getVerifier(class_name);
    667. 

  667.  	VerificationResult vr = v.doPass2();
    668. 

  668.  	if (vr.getStatus() == VerificationResult.VERIFIED_OK){
    669. 

  669. -		JavaClass jc = Repository.lookupClass(class_name);
    670. 

  670. +		JavaClass jc = null;
    671. 

  671. +		try {
    672. 

  672. +			jc = Repository.lookupClass(class_name);
    673. 

  673. +		} catch (ClassNotFoundException ex) {
    674. 

  674. +			// FIXME: report the error
    675. 

  675. +			ex.printStackTrace();
    676. 

  676. +		}
    677. 

  677.  		int nr = jc.getMethods().length;
    678. 

  678.  		for (int i=0; i<nr; i++) {
    679. 

  679.  			vr = v.doPass3b(i);
    680. 

  680. Index: src/java/org/apache/bcel/verifier/statics/Pass1Verifier.java
    681. 

  681. ===================================================================
    682. 

  682. RCS file: /home/cvspublic/jakarta-bcel/src/java/org/apache/bcel/verifier/statics/Pass1Verifier.java,v
    683. 

  683. retrieving revision 1.2
    684. 

  684. diff -u -r1.2 Pass1Verifier.java
    685. 

  685. --- src/java/org/apache/bcel/verifier/statics/Pass1Verifier.java	13 Jun 2002 09:32:50 -0000	1.2
    686. 

  686. +++ src/java/org/apache/bcel/verifier/statics/Pass1Verifier.java	30 Apr 2003 17:53:51 -0000
    687. 

  687. @@ -85,7 +85,14 @@
    688. 

  688.  	/** Used to load in and return the myOwner-matching JavaClass object when needed. Avoids loading in a class file when it's not really needed! */
    689. 

  689.  	private JavaClass getJavaClass(){
    690. 

  690.  		if (jc == null){
    691. 

  691. -			jc = Repository.lookupClass(myOwner.getClassName());
    692. 

  692. +			try {
    693. 

  693. +				jc = Repository.lookupClass(myOwner.getClassName());
    694. 

  694. +			} catch (ClassNotFoundException e) {
    695. 

  695. +				// FIXME: currently, Pass1Verifier treats jc == null as a special
    696. 

  696. +				// case, so we don't need to do anything here.  A better solution
    697. 

  697. +				// would be to simply throw the ClassNotFoundException
    698. 

  698. +				// out of this method.
    699. 

  699. +			}
    700. 

  700.  		}
    701. 

  701.  		return jc;
    702. 

  702.  	}
    703. 

  703. Index: src/java/org/apache/bcel/verifier/statics/Pass2Verifier.java
    704. 

  704. ===================================================================
    705. 

  705. RCS file: /home/cvspublic/jakarta-bcel/src/java/org/apache/bcel/verifier/statics/Pass2Verifier.java,v
    706. 

  706. retrieving revision 1.2
    707. 

  707. diff -u -r1.2 Pass2Verifier.java
    708. 

  708. --- src/java/org/apache/bcel/verifier/statics/Pass2Verifier.java	13 Jun 2002 09:32:50 -0000	1.2
    709. 

  709. +++ src/java/org/apache/bcel/verifier/statics/Pass2Verifier.java	30 Apr 2003 17:53:51 -0000
    710. 

  710. @@ -139,6 +139,7 @@
    711. 

  711.  	 * @see org.apache.bcel.verifier.statics.Pass3aVerifier
    712. 

  712.  	 */
    713. 

  713.  	public VerificationResult do_verify(){
    714. 

  714. +	    try {
    715. 

  715.  		VerificationResult vr1 = myOwner.doPass1();
    716. 

  716.  		if (vr1.equals(VerificationResult.VR_OK)){
    717. 

  717.  			
    718. 

  718. @@ -160,6 +161,11 @@
    719. 

  719.  		}
    720. 

  720.  		else
    721. 

  721.  			return VerificationResult.VR_NOTYET;
    722. 

  722. +
    723. 

  723. +	    } catch (ClassNotFoundException e) {
    724. 

  724. +		// FIXME: this might not be the best way to handle missing classes.
    725. 

  725. +		throw new AssertionViolatedException("Missing class: " + e.toString());
    726. 

  726. +	    }
    727. 

  727.  	}
    728. 

  728.  
    729. 

  729.  	/**
    730. 

  730. @@ -176,6 +182,7 @@
    731. 

  731.  	 * @throws ClassConstraintException otherwise.
    732. 

  732.  	 */
    733. 

  733.  	private void every_class_has_an_accessible_superclass(){
    734. 

  734. +	    try {
    735. 

  735.  		HashSet hs = new HashSet(); // save class names to detect circular inheritance
    736. 

  736.  		JavaClass jc = Repository.lookupClass(myOwner.getClassName());
    737. 

  737.  		int supidx = -1;
    738. 

  738. @@ -206,6 +213,11 @@
    739. 

  739.  				}
    740. 

  740.  			}
    741. 

  741.  		}
    742. 

  742. +
    743. 

  743. +	    } catch (ClassNotFoundException e) {
    744. 

  744. +		// FIXME: this might not be the best way to handle missing classes.
    745. 

  745. +		throw new AssertionViolatedException("Missing class: " + e.toString());
    746. 

  746. +	    }
    747. 

  747.  	}
    748. 

  748.  
    749. 

  749.  	/**
    750. 

  750. @@ -220,6 +232,7 @@
    751. 

  751.  	 * @see #every_class_has_an_accessible_superclass()
    752. 

  752.  	 */
    753. 

  753.  	private void final_methods_are_not_overridden(){
    754. 

  754. +	    try {
    755. 

  755.  		HashMap hashmap = new HashMap();
    756. 

  756.  		JavaClass jc = Repository.lookupClass(myOwner.getClassName());
    757. 

  757.  		
    758. 

  758. @@ -251,6 +264,11 @@
    759. 

  759.  			jc = Repository.lookupClass(jc.getSuperclassName());	// Well, for OBJECT this returns OBJECT so it works (could return anything but must not throw an Exception).
    760. 

  760.  		}
    761. 

  761.  
    762. 

  762. +	    } catch (ClassNotFoundException e) {
    763. 

  763. +		// FIXME: this might not be the best way to handle missing classes.
    764. 

  764. +		throw new AssertionViolatedException("Missing class: " + e.toString());
    765. 

  765. +	    }
    766. 

  766. +
    767. 

  767.  	}
    768. 

  768.  
    769. 

  769.  	/**
    770. 

  770. @@ -260,11 +278,17 @@
    771. 

  771.  	 * @throws ClassConstraintException otherwise.
    772. 

  772.  	 */
    773. 

  773.  	private void constant_pool_entries_satisfy_static_constraints(){
    774. 

  774. +	    try {
    775. 

  775.  		// Most of the consistency is handled internally by BCEL; here
    776. 

  776.  		// we only have to verify if the indices of the constants point
    777. 

  777.  		// to constants of the appropriate type and such.
    778. 

  778.  		JavaClass jc = Repository.lookupClass(myOwner.getClassName());
    779. 

  779.  		new CPESSC_Visitor(jc); // constructor implicitely traverses jc
    780. 

  780. +
    781. 

  781. +	    } catch (ClassNotFoundException e) {
    782. 

  782. +		// FIXME: this might not be the best way to handle missing classes.
    783. 

  783. +		throw new AssertionViolatedException("Missing class: " + e.toString());
    784. 

  784. +	    }
    785. 

  785.  	}
    786. 

  786.  
    787. 

  787.  	/**
    788. 

  788. @@ -799,6 +823,7 @@
    789. 

  789.  		// method_info-structure-ATTRIBUTES (vmspec2 4.6, 4.7) //
    790. 

  790.  		/////////////////////////////////////////////////////////
    791. 

  791.  		public void visitCode(Code obj){//vmspec2 4.7.3
    792. 

  792. +		    try {
    793. 

  793.  			// No code attribute allowed for native or abstract methods: see visitMethod(Method).
    794. 

  794.  			// Code array constraints are checked in Pass3 (3a and 3b).
    795. 

  795.  
    796. 

  796. @@ -945,9 +970,16 @@
    797. 

  797.  					}
    798. 

  798.  				}// if atts[a] instanceof LocalVariableTable END
    799. 

  799.  			}// for all attributes atts[a] END
    800. 

  800. +
    801. 

  801. +		    } catch (ClassNotFoundException e) {
    802. 

  802. +			// FIXME: this might not be the best way to handle missing classes.
    803. 

  803. +			throw new AssertionViolatedException("Missing class: " + e.toString());
    804. 

  804. +		    }
    805. 

  805. +
    806. 

  806.  		}// visitCode(Code) END
    807. 

  807.  
    808. 

  808.  		public void visitExceptionTable(ExceptionTable obj){//vmspec2 4.7.4
    809. 

  809. +		    try {
    810. 

  810.  			// incorrectly named, it's the Exceptions attribute (vmspec2 4.7.4)
    811. 

  811.  			checkIndex(obj, obj.getNameIndex(), CONST_Utf8);
    812. 

  812.  
    813. 

  813. @@ -992,6 +1024,11 @@
    814. 

  814.  					if (e != t) throw new ClassConstraintException("Exceptions attribute '"+tostring(obj)+"' references '"+cname+"' as an Exception but it is not a subclass of '"+t.getClassName()+"'.");
    815. 

  815.  				}
    816. 

  816.  			}
    817. 

  817. +
    818. 

  818. +		    } catch (ClassNotFoundException e) {
    819. 

  819. +			// FIXME: this might not be the best way to handle missing classes.
    820. 

  820. +			throw new AssertionViolatedException("Missing class: " + e.toString());
    821. 

  821. +		    }
    822. 

  822.  		}
    823. 

  823.  		// SYNTHETIC: see above
    824. 

  824.  		// DEPRECATED: see above
    825. 

  825. @@ -1073,9 +1110,15 @@
    826. 

  826.  	 * @see #constant_pool_entries_satisfy_static_constraints()
    827. 

  827.  	 */
    828. 

  828.  	private void field_and_method_refs_are_valid(){
    829. 

  829. +	    try {
    830. 

  830.  		JavaClass jc = Repository.lookupClass(myOwner.getClassName());
    831. 

  831.  		DescendingVisitor v = new DescendingVisitor(jc, new FAMRAV_Visitor(jc));
    832. 

  832.  		v.visit();
    833. 

  833. +
    834. 

  834. +	    } catch (ClassNotFoundException e) {
    835. 

  835. +		// FIXME: this might not be the best way to handle missing classes.
    836. 

  836. +		throw new AssertionViolatedException("Missing class: " + e.toString());
    837. 

  837. +	    }
    838. 

  838.  	}
    839. 

  839.  
    840. 

  840.  	/**
    841. 

  841. Index: src/java/org/apache/bcel/verifier/statics/Pass3aVerifier.java
    842. 

  842. ===================================================================
    843. 

  843. RCS file: /home/cvspublic/jakarta-bcel/src/java/org/apache/bcel/verifier/statics/Pass3aVerifier.java,v
    844. 

  844. retrieving revision 1.3
    845. 

  845. diff -u -r1.3 Pass3aVerifier.java
    846. 

  846. --- src/java/org/apache/bcel/verifier/statics/Pass3aVerifier.java	13 Jun 2002 09:32:50 -0000	1.3
    847. 

  847. +++ src/java/org/apache/bcel/verifier/statics/Pass3aVerifier.java	30 Apr 2003 17:53:51 -0000
    848. 

  848. @@ -112,6 +112,7 @@
    849. 

  849.  	 * @throws InvalidMethodException if the method to verify does not exist.
    850. 

  850.  	 */
    851. 

  851.  	public VerificationResult do_verify(){
    852. 

  852. +	    try {
    853. 

  853.  		if (myOwner.doPass2().equals(VerificationResult.VR_OK)){
    854. 

  854.  			// Okay, class file was loaded correctly by Pass 1
    855. 

  855.  			// and satisfies static constraints of Pass 2.
    856. 

  856. @@ -167,6 +168,10 @@
    857. 

  857.  		else{ //did not pass Pass 2.
    858. 

  858.  			return VerificationResult.VR_NOTYET;
    859. 

  859.  		}
    860. 

  860. +	    } catch (ClassNotFoundException e) {
    861. 

  861. +		// FIXME: maybe not the best way to handle this
    862. 

  862. +		throw new AssertionViolatedException("Missing class: " + e.toString());
    863. 

  863. +	    }
    864. 

  864.  	}
    865. 

  865.  
    866. 

  866.  	/**
    867. 

  867. @@ -330,6 +335,7 @@
    868. 

  868.  	 * @throws StaticCodeConstraintException if the verification fails.
    869. 

  869.  	 */
    870. 

  870.  	private void pass3StaticInstructionOperandsChecks(){
    871. 

  871. +	    try {
    872. 

  872.  		// When building up the InstructionList, BCEL has already done all those checks
    873. 

  873.  		// mentioned in The Java Virtual Machine Specification, Second Edition, as
    874. 

  874.  		// "static constraints on the operands of instructions in the code array".
    875. 

  875. @@ -366,6 +372,10 @@
    876. 

  876.  			ih = ih.getNext();
    877. 

  877.  		}
    878. 

  878.  
    879. 

  879. +	    } catch (ClassNotFoundException e) {
    880. 

  880. +		// FIXME: maybe not the best way to handle this
    881. 

  881. +		throw new AssertionViolatedException("Missing class: " + e.toString());
    882. 

  882. +	    }
    883. 

  883.  	}
    884. 

  884.  	
    885. 

  885.  	/** A small utility method returning if a given int i is in the given int[] ints. */
    886. 

  886. @@ -399,7 +409,12 @@
    887. 

  887.  		 * by the surrounding Pass3aVerifier instance.
    888. 

  888.  		 */
    889. 

  889.  		private int max_locals(){
    890. 

  890. +		   try {
    891. 

  891.  			return Repository.lookupClass(myOwner.getClassName()).getMethods()[method_no].getCode().getMaxLocals();
    892. 

  892. +		    } catch (ClassNotFoundException e) {
    893. 

  893. +			// FIXME: maybe not the best way to handle this
    894. 

  894. +			throw new AssertionViolatedException("Missing class: " + e.toString());
    895. 

  895. +		    }
    896. 

  896.  		}
    897. 

  897.  
    898. 

  898.  		/**
    899. 

  899. @@ -476,6 +491,7 @@
    900. 

  900.  		/** Checks if the constraints of operands of the said instruction(s) are satisfied. */
    901. 

  901.   		//getfield, putfield, getstatic, putstatic
    902. 

  902.   		public void visitFieldInstruction(FieldInstruction o){
    903. 

  903. +		   try {
    904. 

  904.  			indexValid(o, o.getIndex());
    905. 

  905.  			Constant c = cpg.getConstant(o.getIndex());
    906. 

  906.  			if (! (c instanceof ConstantFieldref)){
    907. 

  907. @@ -511,6 +527,10 @@
    908. 

  908.  				}
    909. 

  909.  				/* TODO: Check for access modifiers here. */
    910. 

  910.  			}
    911. 

  911. +		    } catch (ClassNotFoundException e) {
    912. 

  912. +			// FIXME: maybe not the best way to handle this
    913. 

  913. +			throw new AssertionViolatedException("Missing class: " + e.toString());
    914. 

  914. +		    }
    915. 

  915.  		}	
    916. 

  916.  
    917. 

  917.  		/** Checks if the constraints of operands of the said instruction(s) are satisfied. */
    918. 

  918. @@ -869,6 +889,7 @@
    919. 

  919.  
    920. 

  920.  		/** Checks if the constraints of operands of the said instruction(s) are satisfied. */
    921. 

  921.  		public void visitPUTSTATIC(PUTSTATIC o){
    922. 

  922. +		    try {
    923. 

  923.  			String field_name = o.getFieldName(cpg);
    924. 

  924.  			JavaClass jc = Repository.lookupClass(o.getClassType(cpg).getClassName());
    925. 

  925.  			Field[] fields = jc.getFields();
    926. 

  926. @@ -899,10 +920,15 @@
    927. 

  927.  			if ((!(jc.isClass())) && (!(meth_name.equals(Constants.STATIC_INITIALIZER_NAME)))){
    928. 

  928.  				constraintViolated(o, "Interface field '"+f+"' must be set in a '"+Constants.STATIC_INITIALIZER_NAME+"' method.");
    929. 

  929.  			}
    930. 

  930. +		    } catch (ClassNotFoundException e) {
    931. 

  931. +			// FIXME: maybe not the best way to handle this
    932. 

  932. +			throw new AssertionViolatedException("Missing class: " + e.toString());
    933. 

  933. +		    }
    934. 

  934.  		}
    935. 

  935.  
    936. 

  936.  		/** Checks if the constraints of operands of the said instruction(s) are satisfied. */
    937. 

  937.  		public void visitGETSTATIC(GETSTATIC o){
    938. 

  938. +		    try {
    939. 

  939.  			String field_name = o.getFieldName(cpg);
    940. 

  940.  			JavaClass jc = Repository.lookupClass(o.getClassType(cpg).getClassName());
    941. 

  941.  			Field[] fields = jc.getFields();
    942. 

  942. @@ -920,6 +946,10 @@
    943. 

  943.  			if (! (f.isStatic())){
    944. 

  944.  				constraintViolated(o, "Referenced field '"+f+"' is not static which it should be.");
    945. 

  945.  			}
    946. 

  946. +		    } catch (ClassNotFoundException e) {
    947. 

  947. +			// FIXME: maybe not the best way to handle this
    948. 

  948. +			throw new AssertionViolatedException("Missing class: " + e.toString());
    949. 

  949. +		    }
    950. 

  950.  		}
    951. 

  951.  
    952. 

  952.  		/* Checks if the constraints of operands of the said instruction(s) are satisfied. */
    953. 

  953. @@ -934,6 +964,7 @@
    954. 

  954.  
    955. 

  955.  		/** Checks if the constraints of operands of the said instruction(s) are satisfied. */
    956. 

  956.  		public void visitINVOKEINTERFACE(INVOKEINTERFACE o){
    957. 

  957. +		    try {
    958. 

  958.  			// INVOKEINTERFACE is a LoadClass; the Class where the referenced method is declared in,
    959. 

  959.  			// is therefore resolved/verified.
    960. 

  960.  			// INVOKEINTERFACE is an InvokeInstruction, the argument and return types are resolved/verified,
    961. 

  961. @@ -956,10 +987,15 @@
    962. 

  962.  			if (jc.isClass()){
    963. 

  963.  				constraintViolated(o, "Referenced class '"+jc.getClassName()+"' is a class, but not an interface as expected.");
    964. 

  964.  			}
    965. 

  965. +		    } catch (ClassNotFoundException e) {
    966. 

  966. +			// FIXME: maybe not the best way to handle this
    967. 

  967. +			throw new AssertionViolatedException("Missing class: " + e.toString());
    968. 

  968. +		    }
    969. 

  969.  		}
    970. 

  970.  
    971. 

  971.  		/** Checks if the constraints of operands of the said instruction(s) are satisfied. */
    972. 

  972.  		public void visitINVOKESPECIAL(INVOKESPECIAL o){
    973. 

  973. +		    try {
    974. 

  974.  			// INVOKESPECIAL is a LoadClass; the Class where the referenced method is declared in,
    975. 

  975.  			// is therefore resolved/verified.
    976. 

  976.  			// INVOKESPECIAL is an InvokeInstruction, the argument and return types are resolved/verified,
    977. 

  977. @@ -1013,11 +1049,16 @@
    978. 

  978.  				}
    979. 

  979.  			}
    980. 

  980.  			
    981. 

  981. +		    } catch (ClassNotFoundException e) {
    982. 

  982. +			// FIXME: maybe not the best way to handle this
    983. 

  983. +			throw new AssertionViolatedException("Missing class: " + e.toString());
    984. 

  984. +		    }
    985. 

  985.  			
    986. 

  986.  		}
    987. 

  987.  		
    988. 

  988.  		/** Checks if the constraints of operands of the said instruction(s) are satisfied. */
    989. 

  989.  		public void visitINVOKESTATIC(INVOKESTATIC o){
    990. 

  990. +		    try {
    991. 

  991.  			// INVOKESTATIC is a LoadClass; the Class where the referenced method is declared in,
    992. 

  992.  			// is therefore resolved/verified.
    993. 

  993.  			// INVOKESTATIC is an InvokeInstruction, the argument and return types are resolved/verified,
    994. 

  994. @@ -1042,11 +1083,16 @@
    995. 

  995.  				constraintViolated(o, "Referenced method '"+o.getMethodName(cpg)+"' has ACC_STATIC unset.");
    996. 

  996.  			}
    997. 

  997.  		
    998. 

  998. +		    } catch (ClassNotFoundException e) {
    999. 

  999. +			// FIXME: maybe not the best way to handle this
    1000. 

  1000. +			throw new AssertionViolatedException("Missing class: " + e.toString());
    1001. 

  1001. +		    }
    1002. 

  1002.  		}
    1003. 

  1003.  
    1004. 

  1004.  
    1005. 

  1005.  		/** Checks if the constraints of operands of the said instruction(s) are satisfied. */
    1006. 

  1006.  		public void visitINVOKEVIRTUAL(INVOKEVIRTUAL o){
    1007. 

  1007. +		    try {
    1008. 

  1008.  			// INVOKEVIRTUAL is a LoadClass; the Class where the referenced method is declared in,
    1009. 

  1009.  			// is therefore resolved/verified.
    1010. 

  1010.  			// INVOKEVIRTUAL is an InvokeInstruction, the argument and return types are resolved/verified,
    1011. 

  1011. @@ -1070,6 +1116,10 @@
    1012. 

  1012.  				constraintViolated(o, "Referenced class '"+jc.getClassName()+"' is an interface, but not a class as expected.");
    1013. 

  1013.  			}
    1014. 

  1014.  					
    1015. 

  1015. +		    } catch (ClassNotFoundException e) {
    1016. 

  1016. +			// FIXME: maybe not the best way to handle this
    1017. 

  1017. +			throw new AssertionViolatedException("Missing class: " + e.toString());
    1018. 

  1018. +		    }
    1019. 

  1019.  		}
    1020. 

  1020.  
    1021. 

  1021.  		
    1022. 

  1022. Index: src/java/org/apache/bcel/verifier/structurals/InstConstraintVisitor.java
    1023. 

  1023. ===================================================================
    1024. 

  1024. RCS file: /home/cvspublic/jakarta-bcel/src/java/org/apache/bcel/verifier/structurals/InstConstraintVisitor.java,v
    1025. 

  1025. retrieving revision 1.5
    1026. 

  1026. diff -u -r1.5 InstConstraintVisitor.java
    1027. 

  1027. --- src/java/org/apache/bcel/verifier/structurals/InstConstraintVisitor.java	12 Feb 2003 10:15:29 -0000	1.5
    1028. 

  1028. +++ src/java/org/apache/bcel/verifier/structurals/InstConstraintVisitor.java	30 Apr 2003 17:53:51 -0000
    1029. 

  1029. @@ -473,6 +473,7 @@
    1030. 

  1030.  	 * Ensures the specific preconditions of the said instruction.
    1031. 

  1031.  	 */
    1032. 

  1032.  	public void visitAASTORE(AASTORE o){
    1033. 

  1033. +	    try {
    1034. 

  1034.  		Type arrayref = stack().peek(2);
    1035. 

  1035.  		Type index    = stack().peek(1);
    1036. 

  1036.  		Type value    = stack().peek(0);
    1037. 

  1037. @@ -493,6 +494,10 @@
    1038. 

  1038.  				constraintViolated(o, "The type of 'value' ('"+value+"') is not assignment compatible to the components of the array 'arrayref' refers to. ('"+((ArrayType) arrayref).getElementType()+"')");
    1039. 

  1039.  			}
    1040. 

  1040.  		}
    1041. 

  1041. +	    } catch (ClassNotFoundException e) {
    1042. 

  1042. +		// FIXME: maybe not the best way to handle this
    1043. 

  1043. +		throw new AssertionViolatedException("Missing class: " + e.toString());
    1044. 

  1044. +	    }
    1045. 

  1045.  	}
    1046. 

  1046.  
    1047. 

  1047.  	/**
    1048. 

  1048. @@ -563,6 +568,7 @@
    1049. 

  1049.  	 * Ensures the specific preconditions of the said instruction.
    1050. 

  1050.  	 */
    1051. 

  1051.  	public void visitATHROW(ATHROW o){
    1052. 

  1052. +	    try {
    1053. 

  1053.  		// It's stated that 'objectref' must be of a ReferenceType --- but since Throwable is
    1054. 

  1054.  		// not derived from an ArrayType, it follows that 'objectref' must be of an ObjectType or Type.NULL.
    1055. 

  1055.  		if (! ((stack().peek() instanceof ObjectType) || (stack().peek().equals(Type.NULL))) ){
    1056. 

  1056. @@ -577,6 +583,10 @@
    1057. 

  1057.  		if ( (! (exc.subclassOf(throwable)) ) && (! (exc.equals(throwable))) ){
    1058. 

  1058.  			constraintViolated(o, "The 'objectref' is not of class Throwable or of a subclass of Throwable, but of '"+stack().peek()+"'.");
    1059. 

  1059.  		}
    1060. 

  1060. +	    } catch (ClassNotFoundException e) {
    1061. 

  1061. +		// FIXME: maybe not the best way to handle this
    1062. 

  1062. +		throw new AssertionViolatedException("Missing class: " + e.toString());
    1063. 

  1063. +	    }
    1064. 

  1064.  	}
    1065. 

  1065.  
    1066. 

  1066.  	/**
    1067. 

  1067. @@ -1167,6 +1177,7 @@
    1068. 

  1068.  	 * Ensures the specific preconditions of the said instruction.
    1069. 

  1069.  	 */
    1070. 

  1070.  	public void visitGETFIELD(GETFIELD o){
    1071. 

  1071. +	    try {
    1072. 

  1072.  		Type objectref = stack().peek();
    1073. 

  1073.  		if (! ( (objectref instanceof ObjectType) || (objectref == Type.NULL) ) ){
    1074. 

  1074.  			constraintViolated(o, "Stack top should be an object reference that's not an array reference, but is '"+objectref+"'.");
    1075. 

  1075. @@ -1215,6 +1226,11 @@
    1076. 

  1076.  		if (f.isStatic()){
    1077. 

  1077.  			constraintViolated(o, "Referenced field '"+f+"' is static which it shouldn't be.");
    1078. 

  1078.  		}
    1079. 

  1079. +
    1080. 

  1080. +	    } catch (ClassNotFoundException e) {
    1081. 

  1081. +		// FIXME: maybe not the best way to handle this
    1082. 

  1082. +		throw new AssertionViolatedException("Missing class: " + e.toString());
    1083. 

  1083. +	    }
    1084. 

  1084.  	}
    1085. 

  1085.  
    1086. 

  1086.  	/**
    1087. 

  1087. @@ -1716,6 +1732,7 @@
    1088. 

  1088.  	 * Ensures the specific preconditions of the said instruction.
    1089. 

  1089.  	 */
    1090. 

  1090.  	public void visitINVOKESPECIAL(INVOKESPECIAL o){
    1091. 

  1091. +	    try {
    1092. 

  1092.  		// Don't init an object twice.
    1093. 

  1093.  		if ( (o.getMethodName(cpg).equals(Constants.CONSTRUCTOR_NAME)) && (!(stack().peek(o.getArgumentTypes(cpg).length) instanceof UninitializedObjectType)) ){
    1094. 

  1094.  			constraintViolated(o, "Possibly initializing object twice. A valid instruction sequence must not have an uninitialized object on the operand stack or in a local variable during a backwards branch, or in a local variable in code protected by an exception handler. Please see The Java Virtual Machine Specification, Second Edition, 4.9.4 (pages 147 and 148) for details.");
    1095. 

  1095. @@ -1796,12 +1813,17 @@
    1096. 

  1096.  			constraintViolated(o, "The 'objref' item '"+objref+"' does not implement '"+theClass+"' as expected.");
    1097. 

  1097.  		}	
    1098. 

  1098.  		
    1099. 

  1099. +	    } catch (ClassNotFoundException e) {
    1100. 

  1100. +		// FIXME: maybe not the best way to handle this
    1101. 

  1101. +		throw new AssertionViolatedException("Missing class: " + e.toString());
    1102. 

  1102. +	    }
    1103. 

  1103.  	}
    1104. 

  1104.  
    1105. 

  1105.  	/**
    1106. 

  1106.  	 * Ensures the specific preconditions of the said instruction.
    1107. 

  1107.  	 */
    1108. 

  1108.  	public void visitINVOKESTATIC(INVOKESTATIC o){
    1109. 

  1109. +	    try {
    1110. 

  1110.  		// Method is not native, otherwise pass 3 would not happen.
    1111. 

  1111.  		
    1112. 

  1112.  		Type t = o.getType(cpg);
    1113. 

  1113. @@ -1841,12 +1863,17 @@
    1114. 

  1114.  				}
    1115. 

  1115.  			}
    1116. 

  1116.  		}
    1117. 

  1117. +	    } catch (ClassNotFoundException e) {
    1118. 

  1118. +		// FIXME: maybe not the best way to handle this
    1119. 

  1119. +		throw new AssertionViolatedException("Missing class: " + e.toString());
    1120. 

  1120. +	    }
    1121. 

  1121.  	}
    1122. 

  1122.  
    1123. 

  1123.  	/**
    1124. 

  1124.  	 * Ensures the specific preconditions of the said instruction.
    1125. 

  1125.  	 */
    1126. 

  1126.  	public void visitINVOKEVIRTUAL(INVOKEVIRTUAL o){
    1127. 

  1127. +	    try {
    1128. 

  1128.  		// the o.getClassType(cpg) type has passed pass 2; see visitLoadClass(o).
    1129. 

  1129.  
    1130. 

  1130.  		Type t = o.getType(cpg);
    1131. 

  1131. @@ -1912,6 +1939,10 @@
    1132. 

  1132.  		if ( ! Repository.instanceOf(objref_classname, theClass) ){
    1133. 

  1133.  			constraintViolated(o, "The 'objref' item '"+objref+"' does not implement '"+theClass+"' as expected.");
    1134. 

  1134.  		}	
    1135. 

  1135. +	    } catch (ClassNotFoundException e) {
    1136. 

  1136. +		// FIXME: maybe not the best way to handle this
    1137. 

  1137. +		throw new AssertionViolatedException("Missing class: " + e.toString());
    1138. 

  1138. +	    }
    1139. 

  1139.  	}
    1140. 

  1140.  
    1141. 

  1141.  	/**
    1142. 

  1142. @@ -2427,6 +2458,7 @@
    1143. 

  1143.  	 * Ensures the specific preconditions of the said instruction.
    1144. 

  1144.  	 */
    1145. 

  1145.  	public void visitPUTFIELD(PUTFIELD o){
    1146. 

  1146. +	    try {
    1147. 

  1147.  
    1148. 

  1148.  		Type objectref = stack().peek(1);
    1149. 

  1149.  		if (! ( (objectref instanceof ObjectType) || (objectref == Type.NULL) ) ){
    1150. 

  1150. @@ -2504,12 +2536,18 @@
    1151. 

  1151.  		if (f.isStatic()){
    1152. 

  1152.  			constraintViolated(o, "Referenced field '"+f+"' is static which it shouldn't be.");
    1153. 

  1153.  		}
    1154. 

  1154. +
    1155. 

  1155. +	    } catch (ClassNotFoundException e) {
    1156. 

  1156. +		// FIXME: maybe not the best way to handle this
    1157. 

  1157. +		throw new AssertionViolatedException("Missing class: " + e.toString());
    1158. 

  1158. +	    }
    1159. 

  1159.  	}
    1160. 

  1160.  
    1161. 

  1161.  	/**
    1162. 

  1162.  	 * Ensures the specific preconditions of the said instruction.
    1163. 

  1163.  	 */
    1164. 

  1164.  	public void visitPUTSTATIC(PUTSTATIC o){
    1165. 

  1165. +	    try {
    1166. 

  1166.  		String field_name = o.getFieldName(cpg);
    1167. 

  1167.  		JavaClass jc = Repository.lookupClass(o.getClassType(cpg).getClassName());
    1168. 

  1168.  		Field[] fields = jc.getFields();
    1169. 

  1169. @@ -2555,6 +2593,11 @@
    1170. 

  1170.  		}
    1171. 

  1171.  		// TODO: Interface fields may be assigned to only once. (Hard to implement in
    1172. 

  1172.  		//       JustIce's execution model). This may only happen in <clinit>, see Pass 3a.
    1173. 

  1173. +
    1174. 

  1174. +	    } catch (ClassNotFoundException e) {
    1175. 

  1175. +		// FIXME: maybe not the best way to handle this
    1176. 

  1176. +		throw new AssertionViolatedException("Missing class: " + e.toString());
    1177. 

  1177. +	    }
    1178. 

  1178.  	}
    1179. 

  1179.  
    1180. 

  1180.  	/**
    1181. 

  1181. Index: src/java/org/apache/bcel/verifier/structurals/LocalVariables.java
    1182. 

  1182. ===================================================================
    1183. 

  1183. RCS file: /home/cvspublic/jakarta-bcel/src/java/org/apache/bcel/verifier/structurals/LocalVariables.java,v
    1184. 

  1184. retrieving revision 1.2
    1185. 

  1185. diff -u -r1.2 LocalVariables.java
    1186. 

  1186. --- src/java/org/apache/bcel/verifier/structurals/LocalVariables.java	2 Aug 2002 11:57:51 -0000	1.2
    1187. 

  1187. +++ src/java/org/apache/bcel/verifier/structurals/LocalVariables.java	30 Apr 2003 17:53:51 -0000
    1188. 

  1188. @@ -162,6 +162,7 @@
    1189. 

  1189.  	 * @see #merge(LocalVariables)
    1190. 

  1190.  	 */
    1191. 

  1191.  	private void merge(LocalVariables lv, int i){
    1192. 

  1192. +	    try {
    1193. 

  1193.  		
    1194. 

  1194.  		// We won't accept an unitialized object if we know it was initialized;
    1195. 

  1195.  		// compare vmspec2, 4.9.4, last paragraph.
    1196. 

  1196. @@ -202,6 +203,10 @@
    1197. 

  1197.  				locals[i] = Type.UNKNOWN;
    1198. 

  1198.  			}
    1199. 

  1199.  		}
    1200. 

  1200. +	    } catch (ClassNotFoundException e) {
    1201. 

  1201. +		// FIXME: maybe not the best way to handle this
    1202. 

  1202. +		throw new AssertionViolatedException("Missing class: " + e.toString());
    1203. 

  1203. +	    }
    1204. 

  1204.  	}
    1205. 

  1205.  
    1206. 

  1206.  	/**
    1207. 

  1207. Index: src/java/org/apache/bcel/verifier/structurals/OperandStack.java
    1208. 

  1208. ===================================================================
    1209. 

  1209. RCS file: /home/cvspublic/jakarta-bcel/src/java/org/apache/bcel/verifier/structurals/OperandStack.java,v
    1210. 

  1210. retrieving revision 1.2
    1211. 

  1211. diff -u -r1.2 OperandStack.java
    1212. 

  1212. --- src/java/org/apache/bcel/verifier/structurals/OperandStack.java	2 Aug 2002 11:57:51 -0000	1.2
    1213. 

  1213. +++ src/java/org/apache/bcel/verifier/structurals/OperandStack.java	30 Apr 2003 17:53:51 -0000
    1214. 

  1214. @@ -228,6 +228,7 @@
    1215. 

  1215.  	 * for details.
    1216. 

  1216.  	 */
    1217. 

  1217.  	public void merge(OperandStack s){
    1218. 

  1218. +	    try {
    1219. 

  1219.  		if ( (slotsUsed() != s.slotsUsed()) || (size() != s.size()) )
    1220. 

  1220.  			throw new StructuralCodeConstraintException("Cannot merge stacks of different size:\nOperandStack A:\n"+this+"\nOperandStack B:\n"+s);
    1221. 

  1221.  		
    1222. 

  1222. @@ -258,6 +259,10 @@
    1223. 

  1223.  				}
    1224. 

  1224.  			}
    1225. 

  1225.  		}
    1226. 

  1226. +	    } catch (ClassNotFoundException e) {
    1227. 

  1227. +		// FIXME: maybe not the best way to handle this
    1228. 

  1228. +		throw new AssertionViolatedException("Missing class: " + e.toString());
    1229. 

  1229. +	    }
    1230. 

  1230.  	}
    1231. 

  1231.  
    1232. 

  1232.  	/**
    1233. 

  1233. Index: src/java/org/apache/bcel/verifier/structurals/Pass3bVerifier.java
    1234. 

  1234. ===================================================================
    1235. 

  1235. RCS file: /home/cvspublic/jakarta-bcel/src/java/org/apache/bcel/verifier/structurals/Pass3bVerifier.java,v
    1236. 

  1236. retrieving revision 1.3
    1237. 

  1237. diff -u -r1.3 Pass3bVerifier.java
    1238. 

  1238. --- src/java/org/apache/bcel/verifier/structurals/Pass3bVerifier.java	4 Jul 2002 21:44:42 -0000	1.3
    1239. 

  1239. +++ src/java/org/apache/bcel/verifier/structurals/Pass3bVerifier.java	30 Apr 2003 17:53:51 -0000
    1240. 

  1240. @@ -292,7 +292,13 @@
    1241. 

  1241.  
    1242. 

  1242.  		// Pass 3a ran before, so it's safe to assume the JavaClass object is
    1243. 

  1243.  		// in the BCEL repository.
    1244. 

  1244. -		JavaClass jc = Repository.lookupClass(myOwner.getClassName());
    1245. 

  1245. +		JavaClass jc;
    1246. 

  1246. +		try {
    1247. 

  1247. +			jc = Repository.lookupClass(myOwner.getClassName());
    1248. 

  1248. +		} catch (ClassNotFoundException e) {
    1249. 

  1249. +			// FIXME: maybe not the best way to handle this
    1250. 

  1250. +			throw new AssertionViolatedException("Missing class: " + e.toString());
    1251. 

  1251. +		}
    1252. 

  1252.  
    1253. 

  1253.  		ConstantPoolGen constantPoolGen = new ConstantPoolGen(jc.getConstantPool());
    1254. 

  1254.  		// Init Visitors
    1255. 

    1256.