< prev index next >

src/java.base/share/classes/java/lang/StackWalker.java

Print this page




 208          * Specification</cite>.
 209          *
 210          * @return the line number of the source line containing the execution
 211          *         point represented by this stack frame, or a negative number if
 212          *         this information is unavailable.
 213          *
 214          * @jvms 4.7.12 The {@code LineNumberTable} Attribute
 215          */
 216         public int getLineNumber();
 217 
 218         /**
 219          * Returns {@code true} if the method containing the execution point
 220          * represented by this stack frame is a native method.
 221          *
 222          * @return {@code true} if the method containing the execution point
 223          *         represented by this stack frame is a native method.
 224          */
 225         public boolean isNativeMethod();
 226 
 227         /**












 228          * Gets a {@code StackTraceElement} for this stack frame.
 229          *
 230          * @return {@code StackTraceElement} for this stack frame.
 231          */
 232         public StackTraceElement toStackTraceElement();
 233     }
 234 
 235     /**
 236      * Stack walker option to configure the {@linkplain StackFrame stack frame}
 237      * information obtained by a {@code StackWalker}.
 238      *
 239      * @since 9
 240      */
 241     public enum Option {
 242         /**
 243          * Retains {@code Class} object in {@code StackFrame}s
 244          * walked by this {@code StackWalker}.
 245          *
 246          * <p> A {@code StackWalker} configured with this option will support
 247          * {@link StackWalker#getCallerClass()} and


 276          * <p>A Java Virtual Machine implementation may hide implementation
 277          * specific frames in addition to {@linkplain #SHOW_REFLECT_FRAMES
 278          * reflection frames}. A {@code StackWalker} with this {@code SHOW_HIDDEN_FRAMES}
 279          * option will show all hidden frames (including reflection frames).
 280          */
 281         SHOW_HIDDEN_FRAMES;
 282     }
 283 
 284     enum ExtendedOption {
 285         /**
 286          * Obtain monitors, locals and operands.
 287          */
 288         LOCALS_AND_OPERANDS
 289     };
 290 
 291     static final EnumSet<Option> DEFAULT_EMPTY_OPTION = EnumSet.noneOf(Option.class);
 292 
 293     private final static StackWalker DEFAULT_WALKER =
 294         new StackWalker(DEFAULT_EMPTY_OPTION);
 295 


 296     private final Set<Option> options;
 297     private final ExtendedOption extendedOption;
 298     private final int estimateDepth;
 299     final boolean retainClassRef; // cached for performance
 300 
 301     /**
 302      * Returns a {@code StackWalker} instance.
 303      *
 304      * <p> This {@code StackWalker} is configured to skip all
 305      * {@linkplain Option#SHOW_HIDDEN_FRAMES hidden frames} and
 306      * no {@linkplain Option#RETAIN_CLASS_REFERENCE class reference} is retained.
 307      *
 308      * @return a {@code StackWalker} configured to skip all
 309      * {@linkplain Option#SHOW_HIDDEN_FRAMES hidden frames} and
 310      * no {@linkplain Option#RETAIN_CLASS_REFERENCE class reference} is retained.
 311      *
 312      */
 313     public static StackWalker getInstance() {
 314         // no permission check needed
 315         return DEFAULT_WALKER;
 316     }
 317 
 318     /**


















 319      * Returns a {@code StackWalker} instance with the given option specifying
 320      * the stack frame information it can access.
 321      *
 322      * <p>
 323      * If a security manager is present and the given {@code option} is
 324      * {@link Option#RETAIN_CLASS_REFERENCE Option.RETAIN_CLASS_REFERENCE},
 325      * it calls its {@link SecurityManager#checkPermission checkPermission}
 326      * method for {@code RuntimePermission("getStackWalkerWithClassReference")}.
 327      *
 328      * @param option {@link Option stack walking option}
 329      *
 330      * @return a {@code StackWalker} configured with the given option
 331      *
 332      * @throws SecurityException if a security manager exists and its
 333      *         {@code checkPermission} method denies access.
 334      */
 335     public static StackWalker getInstance(Option option) {
 336         return getInstance(EnumSet.of(Objects.requireNonNull(option)));
 337     }
 338 






















 339     /**
 340      * Returns a {@code StackWalker} instance with the given {@code options} specifying
 341      * the stack frame information it can access.  If the given {@code options}
 342      * is empty, this {@code StackWalker} is configured to skip all
 343      * {@linkplain Option#SHOW_HIDDEN_FRAMES hidden frames} and no
 344      * {@linkplain Option#RETAIN_CLASS_REFERENCE class reference} is retained.
 345      *
 346      * <p>
 347      * If a security manager is present and the given {@code options} contains
 348      * {@link Option#RETAIN_CLASS_REFERENCE Option.RETAIN_CLASS_REFERENCE},
 349      * it calls its {@link SecurityManager#checkPermission checkPermission}
 350      * method for {@code RuntimePermission("getStackWalkerWithClassReference")}.
 351      *
 352      * @param options {@link Option stack walking option}
 353      *
 354      * @return a {@code StackWalker} configured with the given options
 355      *
 356      * @throws SecurityException if a security manager exists and its
 357      *         {@code checkPermission} method denies access.
 358      */
 359     public static StackWalker getInstance(Set<Option> options) {
 360         if (options.isEmpty()) {

























 361             return DEFAULT_WALKER;
 362         }
 363 
 364         EnumSet<Option> optionSet = toEnumSet(options);
 365         checkPermission(optionSet);
 366         return new StackWalker(optionSet);
 367     }
 368 
 369     /**
 370      * Returns a {@code StackWalker} instance with the given {@code options} specifying
 371      * the stack frame information it can access. If the given {@code options}
 372      * is empty, this {@code StackWalker} is configured to skip all
 373      * {@linkplain Option#SHOW_HIDDEN_FRAMES hidden frames} and no
 374      * {@linkplain Option#RETAIN_CLASS_REFERENCE class reference} is retained.
 375      *
 376      * <p>
 377      * If a security manager is present and the given {@code options} contains
 378      * {@link Option#RETAIN_CLASS_REFERENCE Option.RETAIN_CLASS_REFERENCE},
 379      * it calls its {@link SecurityManager#checkPermission checkPermission}
 380      * method for {@code RuntimePermission("getStackWalkerWithClassReference")}.
 381      *
 382      * <p>
 383      * The {@code estimateDepth} specifies the estimate number of stack frames
 384      * this {@code StackWalker} will traverse that the {@code StackWalker} could
 385      * use as a hint for the buffer size.
 386      *
 387      * @param options {@link Option stack walking options}
 388      * @param estimateDepth Estimate number of stack frames to be traversed.
 389      *
 390      * @return a {@code StackWalker} configured with the given options
 391      *
 392      * @throws IllegalArgumentException if {@code estimateDepth <= 0}
 393      * @throws SecurityException if a security manager exists and its
 394      *         {@code checkPermission} method denies access.
 395      */
 396     public static StackWalker getInstance(Set<Option> options, int estimateDepth) {
 397         if (estimateDepth <= 0) {
 398             throw new IllegalArgumentException("estimateDepth must be > 0");
 399         }
 400         EnumSet<Option> optionSet = toEnumSet(options);
 401         checkPermission(optionSet);
 402         return new StackWalker(optionSet, estimateDepth);
 403     }
 404 
 405     // ----- private constructors ------
 406     private StackWalker(EnumSet<Option> options) {
 407         this(options, 0, null);






 408     }
 409     private StackWalker(EnumSet<Option> options, int estimateDepth) {
 410         this(options, estimateDepth, null);






 411     }
 412     private StackWalker(EnumSet<Option> options, int estimateDepth, ExtendedOption extendedOption) {
 413         this.options = options;
 414         this.estimateDepth = estimateDepth;
 415         this.extendedOption = extendedOption;
 416         this.retainClassRef = hasOption(Option.RETAIN_CLASS_REFERENCE);


 417     }
 418 
 419     private static void checkPermission(Set<Option> options) {
 420         Objects.requireNonNull(options);
 421         SecurityManager sm = System.getSecurityManager();
 422         if (sm != null) {
 423             if (options.contains(Option.RETAIN_CLASS_REFERENCE)) {
 424                 sm.checkPermission(new RuntimePermission("getStackWalkerWithClassReference"));
 425             }
 426         }
 427     }
 428 
 429     /*
 430      * Returns a defensive copy
 431      */
 432     private static EnumSet<Option> toEnumSet(Set<Option> options) {
 433         Objects.requireNonNull(options);
 434         if (options.isEmpty()) {
 435             return DEFAULT_EMPTY_OPTION;
 436         } else {


 579      * is the bottom most frame on the stack,
 580      * for example, {@code static public void main} method launched by the
 581      * {@code java} launcher, or a method invoked from a JNI attached thread,
 582      * {@code IllegalCallerException} is thrown.
 583      *
 584      * @return {@code Class} object of the caller's caller invoking this method.
 585      *
 586      * @throws UnsupportedOperationException if this {@code StackWalker}
 587      *         is not configured with {@link Option#RETAIN_CLASS_REFERENCE
 588      *         Option.RETAIN_CLASS_REFERENCE}.
 589      * @throws IllegalCallerException if there is no caller frame, i.e.
 590      *         when this {@code getCallerClass} method is called from a method
 591      *         which is the last frame on the stack.
 592      */
 593     @CallerSensitive
 594     public Class<?> getCallerClass() {
 595         if (!retainClassRef) {
 596             throw new UnsupportedOperationException("This stack walker " +
 597                     "does not have RETAIN_CLASS_REFERENCE access");
 598         }



 599 
 600         return StackStreamFactory.makeCallerFinder(this).findCaller();
 601     }
 602 
 603     // ---- package access ----
 604 
 605     static StackWalker newInstance(Set<Option> options, ExtendedOption extendedOption) {






 606         EnumSet<Option> optionSet = toEnumSet(options);
 607         checkPermission(optionSet);
 608         return new StackWalker(optionSet, 0, extendedOption);
 609     }
 610 
 611     int estimateDepth() {
 612         return estimateDepth;
 613     }
 614 
 615     boolean hasOption(Option option) {
 616         return options.contains(option);
 617     }
 618 
 619     boolean hasLocalsOperandsOption() {
 620         return extendedOption == ExtendedOption.LOCALS_AND_OPERANDS;








 621     }
 622 }


 208          * Specification</cite>.
 209          *
 210          * @return the line number of the source line containing the execution
 211          *         point represented by this stack frame, or a negative number if
 212          *         this information is unavailable.
 213          *
 214          * @jvms 4.7.12 The {@code LineNumberTable} Attribute
 215          */
 216         public int getLineNumber();
 217 
 218         /**
 219          * Returns {@code true} if the method containing the execution point
 220          * represented by this stack frame is a native method.
 221          *
 222          * @return {@code true} if the method containing the execution point
 223          *         represented by this stack frame is a native method.
 224          */
 225         public boolean isNativeMethod();
 226 
 227         /**
 228          * Returns the name of the {@link ContinuationScope} of the continuation 
 229          * (if any) in which this frame exists.
 230          * 
 231          * @return the name of the {@link ContinuationScope} of the continuation 
 232          *         in which this frame exists or {@code null} if this frame is 
 233          *         not in a continuation.
 234          */
 235         public default String getContinuationScopeName() {
 236             return null;
 237         }
 238 
 239         /**
 240          * Gets a {@code StackTraceElement} for this stack frame.
 241          *
 242          * @return {@code StackTraceElement} for this stack frame.
 243          */
 244         public StackTraceElement toStackTraceElement();
 245     }
 246 
 247     /**
 248      * Stack walker option to configure the {@linkplain StackFrame stack frame}
 249      * information obtained by a {@code StackWalker}.
 250      *
 251      * @since 9
 252      */
 253     public enum Option {
 254         /**
 255          * Retains {@code Class} object in {@code StackFrame}s
 256          * walked by this {@code StackWalker}.
 257          *
 258          * <p> A {@code StackWalker} configured with this option will support
 259          * {@link StackWalker#getCallerClass()} and


 288          * <p>A Java Virtual Machine implementation may hide implementation
 289          * specific frames in addition to {@linkplain #SHOW_REFLECT_FRAMES
 290          * reflection frames}. A {@code StackWalker} with this {@code SHOW_HIDDEN_FRAMES}
 291          * option will show all hidden frames (including reflection frames).
 292          */
 293         SHOW_HIDDEN_FRAMES;
 294     }
 295 
 296     enum ExtendedOption {
 297         /**
 298          * Obtain monitors, locals and operands.
 299          */
 300         LOCALS_AND_OPERANDS
 301     };
 302 
 303     static final EnumSet<Option> DEFAULT_EMPTY_OPTION = EnumSet.noneOf(Option.class);
 304 
 305     private final static StackWalker DEFAULT_WALKER =
 306         new StackWalker(DEFAULT_EMPTY_OPTION);
 307 
 308     private final Continuation continuation;
 309     private final ContinuationScope contScope;
 310     private final Set<Option> options;
 311     private final ExtendedOption extendedOption;
 312     private final int estimateDepth;
 313     final boolean retainClassRef; // cached for performance
 314 
 315     /**
 316      * Returns a {@code StackWalker} instance.
 317      *
 318      * <p> This {@code StackWalker} is configured to skip all
 319      * {@linkplain Option#SHOW_HIDDEN_FRAMES hidden frames} and
 320      * no {@linkplain Option#RETAIN_CLASS_REFERENCE class reference} is retained.
 321      *
 322      * @return a {@code StackWalker} configured to skip all
 323      * {@linkplain Option#SHOW_HIDDEN_FRAMES hidden frames} and
 324      * no {@linkplain Option#RETAIN_CLASS_REFERENCE class reference} is retained.
 325      *
 326      */
 327     public static StackWalker getInstance() {
 328         // no permission check needed
 329         return DEFAULT_WALKER;
 330     }
 331 
 332     /**
 333      * Returns a {@code StackWalker} instance.
 334      *
 335      * <p> This {@code StackWalker} is configured to skip all
 336      * {@linkplain Option#SHOW_HIDDEN_FRAMES hidden frames} and
 337      * no {@linkplain Option#RETAIN_CLASS_REFERENCE class reference} is retained.
 338      * 
 339      * @param contScope the continuation scope up to which (inclusive) to walk the stack
 340      * 
 341      * @return a {@code StackWalker} configured to skip all
 342      * {@linkplain Option#SHOW_HIDDEN_FRAMES hidden frames} and
 343      * no {@linkplain Option#RETAIN_CLASS_REFERENCE class reference} is retained.
 344      *
 345      */
 346     public static StackWalker getInstance(ContinuationScope contScope) {
 347         return getInstance(EnumSet.noneOf(Option.class), contScope);
 348     }
 349 
 350     /**
 351      * Returns a {@code StackWalker} instance with the given option specifying
 352      * the stack frame information it can access.
 353      *
 354      * <p>
 355      * If a security manager is present and the given {@code option} is
 356      * {@link Option#RETAIN_CLASS_REFERENCE Option.RETAIN_CLASS_REFERENCE},
 357      * it calls its {@link SecurityManager#checkPermission checkPermission}
 358      * method for {@code RuntimePermission("getStackWalkerWithClassReference")}.
 359      *
 360      * @param option {@link Option stack walking option}
 361      *
 362      * @return a {@code StackWalker} configured with the given option
 363      *
 364      * @throws SecurityException if a security manager exists and its
 365      *         {@code checkPermission} method denies access.
 366      */
 367     public static StackWalker getInstance(Option option) {
 368         return getInstance(EnumSet.of(Objects.requireNonNull(option)));
 369     }
 370 
 371    /**
 372      * Returns a {@code StackWalker} instance with the given option specifying
 373      * the stack frame information it can access.
 374      *
 375      * <p>
 376      * If a security manager is present and the given {@code option} is
 377      * {@link Option#RETAIN_CLASS_REFERENCE Option.RETAIN_CLASS_REFERENCE},
 378      * it calls its {@link SecurityManager#checkPermission checkPermission}
 379      * method for {@code RuntimePermission("getStackWalkerWithClassReference")}.
 380      *
 381      * @param option {@link Option stack walking option}
 382      * @param contScope the continuation scope up to which (inclusive) to walk the stack
 383      *
 384      * @return a {@code StackWalker} configured with the given option
 385      *
 386      * @throws SecurityException if a security manager exists and its
 387      *         {@code checkPermission} method denies access.
 388      */
 389     public static StackWalker getInstance(Option option, ContinuationScope contScope) {
 390         return getInstance(EnumSet.of(Objects.requireNonNull(option)), contScope);
 391     }
 392 
 393     /**
 394      * Returns a {@code StackWalker} instance with the given {@code options} specifying
 395      * the stack frame information it can access.  If the given {@code options}
 396      * is empty, this {@code StackWalker} is configured to skip all
 397      * {@linkplain Option#SHOW_HIDDEN_FRAMES hidden frames} and no
 398      * {@linkplain Option#RETAIN_CLASS_REFERENCE class reference} is retained.
 399      *
 400      * <p>
 401      * If a security manager is present and the given {@code options} contains
 402      * {@link Option#RETAIN_CLASS_REFERENCE Option.RETAIN_CLASS_REFERENCE},
 403      * it calls its {@link SecurityManager#checkPermission checkPermission}
 404      * method for {@code RuntimePermission("getStackWalkerWithClassReference")}.
 405      *
 406      * @param options {@link Option stack walking option}
 407      *
 408      * @return a {@code StackWalker} configured with the given options
 409      *
 410      * @throws SecurityException if a security manager exists and its
 411      *         {@code checkPermission} method denies access.
 412      */
 413     public static StackWalker getInstance(Set<Option> options) {
 414         return getInstance(options, null);
 415     }
 416 
 417     /**
 418      * Returns a {@code StackWalker} instance with the given {@code options} specifying
 419      * the stack frame information it can access.  If the given {@code options}
 420      * is empty, this {@code StackWalker} is configured to skip all
 421      * {@linkplain Option#SHOW_HIDDEN_FRAMES hidden frames} and no
 422      * {@linkplain Option#RETAIN_CLASS_REFERENCE class reference} is retained.
 423      *
 424      * <p>
 425      * If a security manager is present and the given {@code options} contains
 426      * {@link Option#RETAIN_CLASS_REFERENCE Option.RETAIN_CLASS_REFERENCE},
 427      * it calls its {@link SecurityManager#checkPermission checkPermission}
 428      * method for {@code RuntimePermission("getStackWalkerWithClassReference")}.
 429      *
 430      * @param options {@link Option stack walking option}
 431      * @param contScope the continuation scope up to which (inclusive) to walk the stack
 432      *
 433      * @return a {@code StackWalker} configured with the given options
 434      *
 435      * @throws SecurityException if a security manager exists and its
 436      *         {@code checkPermission} method denies access.
 437      */
 438     public static StackWalker getInstance(Set<Option> options, ContinuationScope contScope) {
 439         if (options.isEmpty() && contScope == null) {
 440             return DEFAULT_WALKER;
 441         }
 442 
 443         EnumSet<Option> optionSet = toEnumSet(options);
 444         checkPermission(optionSet);
 445         return new StackWalker(optionSet, contScope);
 446     }
 447 
 448     /**
 449      * Returns a {@code StackWalker} instance with the given {@code options} specifying
 450      * the stack frame information it can access. If the given {@code options}
 451      * is empty, this {@code StackWalker} is configured to skip all
 452      * {@linkplain Option#SHOW_HIDDEN_FRAMES hidden frames} and no
 453      * {@linkplain Option#RETAIN_CLASS_REFERENCE class reference} is retained.
 454      *
 455      * <p>
 456      * If a security manager is present and the given {@code options} contains
 457      * {@link Option#RETAIN_CLASS_REFERENCE Option.RETAIN_CLASS_REFERENCE},
 458      * it calls its {@link SecurityManager#checkPermission checkPermission}
 459      * method for {@code RuntimePermission("getStackWalkerWithClassReference")}.
 460      *
 461      * <p>
 462      * The {@code estimateDepth} specifies the estimate number of stack frames
 463      * this {@code StackWalker} will traverse that the {@code StackWalker} could
 464      * use as a hint for the buffer size.
 465      *
 466      * @param options {@link Option stack walking options}
 467      * @param estimateDepth Estimate number of stack frames to be traversed.
 468      *
 469      * @return a {@code StackWalker} configured with the given options
 470      *
 471      * @throws IllegalArgumentException if {@code estimateDepth <= 0}
 472      * @throws SecurityException if a security manager exists and its
 473      *         {@code checkPermission} method denies access.
 474      */
 475     public static StackWalker getInstance(Set<Option> options, int estimateDepth) {
 476         if (estimateDepth <= 0) {
 477             throw new IllegalArgumentException("estimateDepth must be > 0");
 478         }
 479         EnumSet<Option> optionSet = toEnumSet(options);
 480         checkPermission(optionSet);
 481         return new StackWalker(optionSet, estimateDepth);
 482     }
 483 
 484     // ----- private constructors ------
 485     private StackWalker(EnumSet<Option> options) {
 486         this(options, 0, null, null, null);
 487     }
 488     private StackWalker(EnumSet<Option> options, ContinuationScope contScope) {
 489         this(options, 0, null, contScope, null);
 490     }
 491     private StackWalker(EnumSet<Option> options, ContinuationScope contScope, Continuation continuation) {
 492         this(options, 0, null, contScope, continuation);
 493     }
 494     private StackWalker(EnumSet<Option> options, int estimateDepth) {
 495         this(options, estimateDepth, null, null, null);
 496     }
 497     private StackWalker(EnumSet<Option> options, int estimateDepth, ContinuationScope contScope) {
 498         this(options, estimateDepth, null, contScope, null);
 499     }
 500     private StackWalker(EnumSet<Option> options, int estimateDepth, ContinuationScope contScope, Continuation continuation) {
 501         this(options, estimateDepth, null, contScope, continuation);
 502     }
 503     private StackWalker(EnumSet<Option> options, int estimateDepth, ExtendedOption extendedOption, ContinuationScope contScope, Continuation continuation) {
 504         this.options = options;
 505         this.estimateDepth = estimateDepth;
 506         this.extendedOption = extendedOption;
 507         this.retainClassRef = hasOption(Option.RETAIN_CLASS_REFERENCE);
 508         this.contScope = contScope;
 509         this.continuation = continuation;
 510     }
 511 
 512     private static void checkPermission(Set<Option> options) {
 513         Objects.requireNonNull(options);
 514         SecurityManager sm = System.getSecurityManager();
 515         if (sm != null) {
 516             if (options.contains(Option.RETAIN_CLASS_REFERENCE)) {
 517                 sm.checkPermission(new RuntimePermission("getStackWalkerWithClassReference"));
 518             }
 519         }
 520     }
 521 
 522     /*
 523      * Returns a defensive copy
 524      */
 525     private static EnumSet<Option> toEnumSet(Set<Option> options) {
 526         Objects.requireNonNull(options);
 527         if (options.isEmpty()) {
 528             return DEFAULT_EMPTY_OPTION;
 529         } else {


 672      * is the bottom most frame on the stack,
 673      * for example, {@code static public void main} method launched by the
 674      * {@code java} launcher, or a method invoked from a JNI attached thread,
 675      * {@code IllegalCallerException} is thrown.
 676      *
 677      * @return {@code Class} object of the caller's caller invoking this method.
 678      *
 679      * @throws UnsupportedOperationException if this {@code StackWalker}
 680      *         is not configured with {@link Option#RETAIN_CLASS_REFERENCE
 681      *         Option.RETAIN_CLASS_REFERENCE}.
 682      * @throws IllegalCallerException if there is no caller frame, i.e.
 683      *         when this {@code getCallerClass} method is called from a method
 684      *         which is the last frame on the stack.
 685      */
 686     @CallerSensitive
 687     public Class<?> getCallerClass() {
 688         if (!retainClassRef) {
 689             throw new UnsupportedOperationException("This stack walker " +
 690                     "does not have RETAIN_CLASS_REFERENCE access");
 691         }
 692         if (continuation != null) {
 693             throw new UnsupportedOperationException("This stack walker walks a continuation");
 694         }
 695 
 696         return StackStreamFactory.makeCallerFinder(this).findCaller();
 697     }
 698 
 699     // ---- package access ----
 700 
 701     static StackWalker newInstance(Set<Option> options, ExtendedOption extendedOption, ContinuationScope contScope) {
 702         EnumSet<Option> optionSet = toEnumSet(options);
 703         checkPermission(optionSet);
 704         return new StackWalker(optionSet, 0, extendedOption, contScope, null);
 705     }
 706 
 707     static StackWalker newInstance(Set<Option> options, ExtendedOption extendedOption, ContinuationScope contScope, Continuation continuation) {
 708         EnumSet<Option> optionSet = toEnumSet(options);
 709         checkPermission(optionSet);
 710         return new StackWalker(optionSet, 0, extendedOption, contScope, continuation);
 711     }
 712 
 713     int estimateDepth() {
 714         return estimateDepth;
 715     }
 716 
 717     boolean hasOption(Option option) {
 718         return options.contains(option);
 719     }
 720 
 721     boolean hasLocalsOperandsOption() {
 722         return extendedOption == ExtendedOption.LOCALS_AND_OPERANDS;
 723     }
 724 
 725     ContinuationScope getContScope() {
 726         return contScope;
 727     }
 728 
 729     Continuation getContinuation() {
 730         return continuation;
 731     }
 732 }
< prev index next >