de.uka.ilkd.key.macros

Class AbstractProofMacro

java.lang.Object

de.uka.ilkd.key.macros.AbstractProofMacro

All Implemented Interfaces:

ProofMacro

Direct Known Subclasses:

AbstractFinishAuxiliaryComputationMacro, AlternativeMacro, DoWhileFinallyMacro, ExhaustiveProofMacro, FinishSymbolicExecutionWithSpecJoinsMacro, SequentialProofMacro, SkipMacro, StartAuxiliaryBlockComputationMacro, StartAuxiliaryLoopComputationMacro, StartAuxiliaryMethodComputationMacro, StrategyProofMacro, TryCloseMacro

public abstract class AbstractProofMacro
extends Object
implements ProofMacro

Takes care of providing the whole ProofMacro interface by only making it necessary to implement to most general application methods for a given list of goals and translating the less general versions (firstly for a given node and secondly having neither any goals nor a node). Although all these methods can be redefined by inheritance, this is usually not necessary, unless you know exactly what you are doing. The exception is #finishAfterMacro() for compound macros (see description in ProofMacro#finishAfterMacro()).

Author:

Michael Kirsten

Nested Class Summary

Nested classes/interfaces inherited from interface de.uka.ilkd.key.macros.ProofMacro

ProofMacro.ProgressBarListener

Constructor Summary

Constructors

Constructor and Description
AbstractProofMacro()

Method Summary

Modifier and Type	Method and Description
ProofMacroFinishedInfo	applyTo(UserInterfaceControl uic, Node node, PosInOccurrence posInOcc, ProverTaskListener listener) Apply this macro on the given node.
boolean	canApplyTo(Node node, PosInOccurrence posInOcc) Can this macro be applied on the given node? This method should not make any changes but check if the macro can be applied or not on the given node.
private static ImmutableList<Goal>	getGoals(Node node)
protected int	getMaxSteps(Proof proof) Gets the maximum number of rule applications allowed for a macro.
String	getScriptCommandName() Gets a unique short name for this macro that can be used in proof scripts.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface de.uka.ilkd.key.macros.ProofMacro

applyTo, canApplyTo, getCategory, getDescription, getName

Constructor Detail

AbstractProofMacro

public AbstractProofMacro()

Method Detail

getGoals

private static ImmutableList<Goal> getGoals(Node node)

getScriptCommandName

public String getScriptCommandName()

Gets a unique short name for this macro that can be used in proof scripts. If null is returned, the macro cannot be addressed from within scripts. By default, proof macros do not support scripts, thus null is returned.

Specified by:

getScriptCommandName in interface ProofMacro

Returns:

null if not supported, or a non-null constant string as the short name

canApplyTo

public boolean canApplyTo(Node node,
                          PosInOccurrence posInOcc)

Description copied from interface: ProofMacro

Can this macro be applied on the given node? This method should not make any changes but check if the macro can be applied or not on the given node. This method may be called from within the GUI thread and be compatible with that fact. This method must be implemented to have the same effect as calling ProofMacro.canApplyTo(Proof, ImmutableList, PosInOccurrence) with node.proof() as proof and all open goals below node.

Specified by:

canApplyTo in interface ProofMacro

Parameters:

node - the node (not null)

posInOcc - the position in occurrence (may be null)

Returns:

true, if the macro is allowed to be applied

applyTo

public ProofMacroFinishedInfo applyTo(UserInterfaceControl uic,
                                      Node node,
                                      PosInOccurrence posInOcc,
                                      ProverTaskListener listener)
                               throws InterruptedException,
                                      Exception

Description copied from interface: ProofMacro

Apply this macro on the given node. This method can change the proof by applying rules to it. This method is usually called from a dedicated thread and not the GUI thread. The thread it runs on may be interrupted. In this case, the macro may report the interruption by an InterruptedException. A ProverTaskListener can be provided to which the progress will be reported. If no reports are desired, null can be used for this parameter. If more than one listener is needed, consider combining them using a single listener object using the composite pattern.

Specified by:

applyTo in interface ProofMacro

Parameters:

uic - the UserInterfaceControl to use

node - the node (not null)

posInOcc - the position in occurrence (may be null)

listener - the listener to use for progress reports (may be null)

Throws:

InterruptedException - if the application of the macro has been interrupted.

Exception

getMaxSteps

protected final int getMaxSteps(Proof proof)

Gets the maximum number of rule applications allowed for a macro. The implementation is the maximum amount of proof steps for automatic mode.

Returns:

the maximum number of rule applications allowed for this macro