org.multijava.util.Utils
org.jmlspecs.checker.JmlAbstractVisitor
org.jmlspecs.jmlrac.RacAbstractVisitor
org.jmlspecs.jmlrac.TransMethodBody
|
JML | ||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||||
java.lang.Object
A visitor class for translating JML specification statements in
a method body into assertion check code. The translated assertion
check code is stored as a RacNode in the AST of the
specification statement and is expected to be pretty-printed by
the class RacPrettyPrinter. Translated are such specification
statements as assume, assert, and
unreachable statements.
TransConstuctorBody JConstructorBlock
| |
+ +
v V
TransType <>----- TransMethodBody -----> JBlock
| |
setAssertionCode()|<<call>> +
V V
JmlAssertStatement ----|> JStatement
^
assertionCode()|<<call>>
|
RacPrettyPrinter
translate(),
visitJmlAssumeStatement(JmlAssumeStatement),
visitJmlAssertStatement(JmlAssertStatement),
visitCompoundStatement(JStatement[]),
visitJmlUnreachableStatement(JmlUnreachableStatement)| Field Summary | |
protected JBlock |
body
method body to be translated |
protected JmlMethodDeclaration |
methodDecl
method declaration whose body is being translated |
protected JTypeDeclarationType |
typeDecl
type declaration to which the method belongs |
protected VarGenerator |
varGen
variable generator to generate fresh local variables |
| Fields inherited from class org.multijava.util.Utils |
DBG_LEVEL_HIGH, DBG_LEVEL_LOW, DBG_LEVEL_NO |
| Fields inherited from interface org.jmlspecs.jmlrac.RacConstants |
MN_CHECK_HC, MN_CHECK_INV, MN_CHECK_POST, MN_CHECK_PRE, MN_CHECK_XPOST, MN_EVAL_OLD, MN_GHOST, MN_INIT, MN_INTERNAL, MN_MODEL, MN_MODEL_PUBLIC, MN_RESTORE_FROM, MN_SAVE_TO, MN_SPEC, MN_SPEC_PUBLIC, TN_JMLCHECKABLE, TN_JMLSURROGATE, TN_JMLUNIT_TEST_POSTFIX, TN_JMLUNIT_TESTDATA_POSTFIX, TN_JMLVALUE, TN_SURROGATE, VN_ASSERTION, VN_CATCH_VAR, VN_CLASS_INIT, VN_CONSTRUCTED, VN_DELEGEE, VN_ERROR_SET, VN_EXCEPTION, VN_FREE_VAR, VN_INIT, VN_OLD_VAR, VN_POST_VAR, VN_PRE_VAR, VN_PRECOND, VN_RAC_COMPILED, VN_RAC_LEVEL, VN_RESULT, VN_STACK_VAR, VN_XRESULT |
| Constructor Summary | |
TransMethodBody(VarGenerator varGen,
JmlMethodDeclaration mdecl,
JTypeDeclarationType typeDecl)
Construct an object of TransMethodBody. |
|
| Method Summary | |
private JExpression |
conjoinInvariants(JmlLoopInvariant[] invs)
Conjoins the given loop invariants and returns the result. |
static String |
defaultValue(CType type)
Return the default value of the type type. |
static RacNode |
getGhostFieldSetter(JClassFieldExpression fieldExpr,
String argVar,
VarGenerator varGen)
Returns Java source code that makes a dynamic call to the setter method of the given ghost field, fieldExpr,
to set the ghost value to the value of the given variable,
argVar. |
private RacNode |
ghostFieldSetter(JClassFieldExpression fieldExpr,
String argVar)
Returns Java source code that makes a dynamic call to the setter method of the given ghost field, fieldExpr,
to set the ghost value to the value of the given variable,
argVar. |
private RacNode |
invariantCheckCode(JmlLoopInvariant[] invs)
Returns code that checks the given loop invariants. |
protected String |
isActive()
Returns a string representation of the condition that tests if the given type of assertion is active. |
private static boolean |
isCheckable(JmlAssertOrAssumeStatement clause)
Returns true if the given assume (or assert) statement is checkable. |
private static boolean |
isCheckable(JmlHenceByStatement clause)
Returns true if the given hence_by statement is checkable. |
private static boolean |
isCheckable(JmlLoopSpecification clause)
Returns true if the given loop invariant is checkable. |
private static boolean |
isStatic(JClassFieldExpression expr)
Returns true if the given field expression is a reference to a static field. |
private static void |
needDynamicInvocationMethod()
Records that a ghost field inheritance mechanism is needed. |
static String |
operator(JAssignmentExpression expr)
Returns the string representation of the assignment operator of the given assignment expression. |
private void |
transDoLoop(JmlLoopStatement self,
RacNode checkInv,
RacNode checkVar)
Translates the given JML loop statement with the given invariant check code and variant check code. |
private void |
transForLoop(JmlLoopStatement self,
RacNode checkInv,
RacNode checkVar)
Translates the given JML loop statement with the given invariant check code and variant check code. |
JBlock |
translate()
Performs the translation of method body and returns the resulting method body, which may be modified during the translation. |
private static RacNode |
transPrefix(VarGenerator varGen,
JClassFieldExpression fieldExpr)
Translates the prefix expression of the given field reference expression, fieldExpr. |
private void |
transWhileLoop(JmlLoopStatement self,
RacNode checkInv,
RacNode checkVar)
Translates the given JML loop statement with the given invariant check code and variant check code. |
private RacNode |
variantCheckCode(JmlVariantFunction[] vars)
Returns code that checks the given loop variants. |
void |
visitAssertStatement(JAssertStatement self)
Translates the given Java assert statement. |
void |
visitBlockStatement(JBlock self)
Translates the given Java block statement. |
void |
visitBreakStatement(JBreakStatement self)
Translates the given Java break statement. |
void |
visitCompoundStatement(JCompoundStatement self)
Translates the given Java compound statement. |
void |
visitCompoundStatement(JStatement[] body)
Translates the given Java compound statement. |
void |
visitConstructorBlock(JConstructorBlock self)
Translates the given Java constructor statement. |
void |
visitContinueStatement(JContinueStatement self)
Translates the given Java continue statement. |
void |
visitDoStatement(JDoStatement self)
Translates the given Java do statement. |
void |
visitEmptyStatement(JEmptyStatement self)
Translates the given Java empty statement. |
void |
visitExpressionListStatement(JExpressionListStatement self)
Translates the given Java expression list statement. |
void |
visitExpressionStatement(JExpressionStatement self)
Translates the given Java expression statement. |
void |
visitForStatement(JForStatement self)
Translates the given Java for statement. |
void |
visitIfStatement(JIfStatement self)
Translates the given Java if statement. |
void |
visitJmlAssertStatement(JmlAssertStatement self)
Translates the given JML assert statement and
stores the translated assertion check code into the AST node. |
void |
visitJmlAssumeStatement(JmlAssumeStatement self)
Translates the JML assume statement and stores the
translated assertion check code into the AST node. |
void |
visitJmlDebugStatement(JmlDebugStatement self)
Translates the given JML debug statement and
stores the translated code into the AST node. |
void |
visitJmlGuardedStatement(JmlGuardedStatement self)
Translates the given JML guarded statement. |
void |
visitJmlHenceByStatement(JmlHenceByStatement self)
Translates the given JML hence_by and stores the
translated assertion check code into the AST node. |
void |
visitJmlInvariantStatement(JmlInvariantStatement self)
Translates the given JML invariant statement. |
void |
visitJmlLoopStatement(JmlLoopStatement self)
Translates the given JML loop statement and stores the instrumented code into the AST node of self. |
void |
visitJmlNondetChoiceStatement(JmlNondetChoiceStatement self)
Translates the given JML nondeterministic choice statement. |
void |
visitJmlNondetIfStatement(JmlNondetIfStatement self)
Translates the given JML nondeterministic if statement. |
void |
visitJmlSetStatement(JmlSetStatement self)
Translates the JML set statement and stores the
translated assertion check code into the AST node. |
void |
visitJmlSpecStatement(JmlSpecStatement self)
Translates the given JML specification statement. |
void |
visitJmlUnreachableStatement(JmlUnreachableStatement self)
Translates the JML unreachable statement. |
void |
visitLabeledStatement(JLabeledStatement self)
Translates the given Java labeled statement. |
void |
visitReturnStatement(JReturnStatement self)
Translates the given Java return statement. |
void |
visitSwitchGroup(JSwitchGroup self)
Translates the given Java switch group statement. |
void |
visitSwitchStatement(JSwitchStatement self)
Translates the given Java switch statement. |
void |
visitSynchronizedStatement(JSynchronizedStatement self)
Translates the given Java synchronized statement. |
void |
visitThrowStatement(JThrowStatement self)
Translates the given Java throw statement. |
void |
visitTryCatchStatement(JTryCatchStatement self)
Translates the given Java try/catch statement. |
void |
visitTryFinallyStatement(JTryFinallyStatement self)
Translates the given Java try/finally statement. |
void |
visitTypeDeclarationStatement(JTypeDeclarationStatement self)
Translates the given Java type declaration statement. |
void |
visitVariableDeclarationStatement(JVariableDeclarationStatement self)
Translates the given Java variable declaration statement. |
void |
visitWhileStatement(JWhileStatement self)
Translates the given Java while statement. |
| Methods inherited from class org.jmlspecs.jmlrac.RacAbstractVisitor |
visitRacNode, visitRacPredicate |
| Methods inherited from class org.multijava.util.Utils |
assertTrue, assertTrue, combineArrays, escapeString, escapeString, fail, fail, getFilePath, hasFlag, hasOtherFlags, parsePathParts, relativePathTo, splitQualifiedName, splitQualifiedName, stripJavaModifiers, stripNonJavaModifiers, stripPrivateModifier, unescapeString, vectorToArray, vectorToIntArray |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
protected VarGenerator varGen
protected JTypeDeclarationType typeDecl
protected JmlMethodDeclaration methodDecl
protected JBlock body
| Constructor Detail |
public TransMethodBody(VarGenerator varGen,
JmlMethodDeclaration mdecl,
JTypeDeclarationType typeDecl)
TransMethodBody.
varGen - variable name generatormdecl - method body to be translated| Method Detail |
public JBlock translate()
RacNode) and stores them into their ASTs.
ensures \result != null;
visitJmlAssumeStatement(JmlAssumeStatement),
visitJmlAssertStatement(JmlAssertStatement),
visitCompoundStatement(JStatement[]),
visitJmlUnreachableStatement(JmlUnreachableStatement)public void visitJmlAssertStatement(JmlAssertStatement self)
assert statement and
stores the translated assertion check code into the AST node.
An assert_redundantly statement is translated only
if the command-line option noredundancy is turned
off (which is the default). The translated assertion check code
has the following form:
[[assert E;]] ==
boolean v = false;
[[E, v]]
if (!v) {
throw new JMLAssertError();
}
also requires self != null; modifies self.*; ensures isCheckable(self) ==> self.assertionCode() != null;
visitJmlAssertStatement in interface JmlVisitorvisitJmlAssertStatement in class JmlAbstractVisitorvisitJmlAssumeStatement(JmlAssumeStatement),
translate()public void visitJmlDebugStatement(JmlDebugStatement self)
debug statement and
stores the translated code into the AST node.
The translated code has the following form:
[[debug E;]] ==
do {
[[E]]
} while (false);
also requires self != null; modifies self.*; ensures self.assertionCode() != null;
visitJmlDebugStatement in interface JmlVisitorvisitJmlDebugStatement in class JmlAbstractVisitorvisitJmlAssumeStatement(JmlAssumeStatement),
translate()private static boolean isCheckable(JmlAssertOrAssumeStatement clause)
noredundancy is not turned on.
private static boolean isCheckable(JmlHenceByStatement clause)
noredundancy is not turned on.
private static boolean isCheckable(JmlLoopSpecification clause)
noredundancy is not turned on. In addition, an
informal variant function is not checkable.
public void visitJmlAssumeStatement(JmlAssumeStatement self)
assume statement and stores the
translated assertion check code into the AST node. An
assume_redundantly statement is translated only if
the command-line option noredundancy is turned off
(which is the default). Note that the assumptions are checked
only if the runtime option
reportAssumptionViolation is set (which is the
default). The translated assertion code has the following
form:
[[assume E;]] ==
if (JMLChecker.reportAssumptionViolation()) {
boolean v = false;
[[E, v]]
if (!v) {
throw new JMLAssumeError();
}
}
also requires self != null; modifies self.*; ensures isCheckable(self) ==> self.assertionCode() != null;
visitJmlAssumeStatement in interface JmlVisitorvisitJmlAssumeStatement in class JmlAbstractVisitorvisitJmlAssertStatement(JmlAssertStatement),
translate()public void visitJmlGuardedStatement(JmlGuardedStatement self)
visitJmlGuardedStatement in interface JmlVisitorvisitJmlGuardedStatement in class JmlAbstractVisitorpublic void visitJmlHenceByStatement(JmlHenceByStatement self)
hence_by and stores the
translated assertion check code into the AST node. An
hence_by_redundantly statement is translated only
if the command-line option noredundancy is turned
off (which is the default). The translated assertion code has
the following form:
[[hence_by P;]] ==
boolean v = false;
[[P, v]]
if (!v) {
throw new JMLHenceByError();
}
also requires self != null; modifies self.*; ensures isCheckable(self) ==> self.assertionCode() != null;
visitJmlHenceByStatement in interface JmlVisitorvisitJmlHenceByStatement in class JmlAbstractVisitorvisitJmlAssertStatement(JmlAssertStatement),
supported yet.public void visitJmlLoopStatement(JmlLoopStatement self)
self. The
pretty-printer is supposed to print the instrumented code
instead of the original AST node. For the structure of
instrumented code, refer to methods transWhileLoop,
transDoLoop, and transForLoop.
also requires self != null; modifies self.*;
visitJmlLoopStatement in interface JmlVisitorvisitJmlLoopStatement in class JmlAbstractVisitor#transWhileLoop(),
#transDoLoop(),
#transForLoop(),
RacPrettyPrinter#visitJmlLoopStatement()private RacNode invariantCheckCode(JmlLoopInvariant[] invs)
--noredundancy is turned
on), null is returned. Otherwise, the following
form of code is returned.
if (IS_ACTIVE()) {
JMLChecker.enter();
boolean v = false;
[[I,v]]
JMLChecker.exit();
if (!v) {
throw new JMLLoopInvariantError(...);
}
}
requires invs != null; ensures (* \result may be null *);
private RacNode variantCheckCode(JmlVariantFunction[] vars)
--noredundancy is turned
on), null is returned. Otherwise, the following
form of code is returned.
if (IS_ACTIVE()) {
JMLChecker.enter();
int v1 = 0;
[[E1,v1]]
JMLChecker.exit();
if (v1 < 0 || (!isFirst && v1 >= vo1)) {
throw new JMLLoopVariantError(...);
}
vo1 = v1;
isFirst = false;
}
...
if (IS_ACTIVE()) {
JMLChecker.enter();
int vn = 0;
[[E1,vn]]
JMLChecker.exit();
if (vn < 0 || (!isFirst && vn >= von)) {
throw new JMLLoopVariantError(...);
}
von = vn;
isFirst = false;
}
The declaration of temporary variables such as vo1, ..., von,
and isFirst is piggybacked through the name field of the
RacNode, and is of the following string.
boolean isFirst = true; int vo1 = 0; ... int von = 0;
requires vars != null; ensures (* \result may be null *);
private void transWhileLoop(JmlLoopStatement self,
RacNode checkInv,
RacNode checkVar)
self, and it has
the following form:
[[while (B) S]] ==
{
boolean v = false;
<>
while (true) {
<>
<>
if (!(B)) {
v = true;
break;
}
S
}
if (!v) {
<>
}
}
requires self != null; requires checkInv != null || checkVar != null; requires self.loopStmt() instanceof JForStatement; modifies self.*;
variantCheckCode(JmlVariantFunction[]),
invariantCheckCode(JmlLoopInvariant[])
private void transDoLoop(JmlLoopStatement self,
RacNode checkInv,
RacNode checkVar)
self, and it has
the following form:
[[while (B) S]] ==
{
<>
while (true) {
<>
<>
if (!(B)) {
break;
}
S
}
<>
}
requires self != null; requires checkInv != null || checkVar != null; requires self.loopStmt() instanceof JDoStatement; modifies self.*;
variantCheckCode(JmlVariantFunction[]),
invariantCheckCode(JmlLoopInvariant[])
private void transForLoop(JmlLoopStatement self,
RacNode checkInv,
RacNode checkVar)
self, and it has the
following form:
[[for (I1, ..., In; B; U1, ..., Un) S]] ==
{
I1, ..., In;
boolean vExit = false;
boolean vIncr = false;
<>
while (true) {
if (vIncr) {
U1, ..., Un;
} else {
vIncr = true;
}
<>
<>
if (!(B)) {
vExit = true;
break;
}
S
}
if (!vExit) {
<>
}
}
requires checkInv != null || checkVar != null; requires self.loopStmt() instanceof JForStatement; modifies self.*;
variantCheckCode(JmlVariantFunction[]),
invariantCheckCode(JmlLoopInvariant[])private JExpression conjoinInvariants(JmlLoopInvariant[] invs)
--noredundancy is turned on), null is
returned.
requires invs != null; ensures (* \result may be null *);
public void visitJmlInvariantStatement(JmlInvariantStatement self)
visitJmlInvariantStatement in interface JmlVisitorvisitJmlInvariantStatement in class JmlAbstractVisitorpublic void visitJmlNondetChoiceStatement(JmlNondetChoiceStatement self)
visitJmlNondetChoiceStatement in interface JmlVisitorvisitJmlNondetChoiceStatement in class JmlAbstractVisitorpublic void visitJmlNondetIfStatement(JmlNondetIfStatement self)
visitJmlNondetIfStatement in interface JmlVisitorvisitJmlNondetIfStatement in class JmlAbstractVisitorpublic void visitJmlSpecStatement(JmlSpecStatement self)
visitJmlSpecStatement in interface JmlVisitorvisitJmlSpecStatement in class JmlAbstractVisitorpublic void visitJmlSetStatement(JmlSetStatement self)
set statement and stores the
translated assertion check code into the AST node. The
translated assertion code has the following structure:
[[set g = E;]] ==
{
T g;
[[E,g]]
ghost$g(g); // dynamic call to setter
}
[[set g *= E;]] ==
{
T g = ghost$v(); // dynamic call to getter
T v;
[[E,v]]
g *= v; // commound assignments (e.g., +=, -=, etc).
ghost$v(g); // dynamic call to setter
}
also requires self != null; modifies self.*; ensures self.assertionCode() != null;
visitJmlSetStatement in interface JmlVisitorvisitJmlSetStatement in class JmlAbstractVisitorTransClass,
TransInterface,
TransType
private RacNode ghostFieldSetter(JClassFieldExpression fieldExpr,
String argVar)
fieldExpr,
to set the ghost value to the value of the given variable,
argVar. Assume that fieldExpr is of
the form "E.g", where E's type is T. Then, the returned code
has the following general structure:
T v;
[[E, v]]
rac$invoke("T", v, "g", typeOf(argVar), wrapped(argVar));
requires fieldExpr != null && argVar != null && (* fieldExpr is a reference to a ghost field *); ensures \result != null;
public static RacNode getGhostFieldSetter(JClassFieldExpression fieldExpr,
String argVar,
VarGenerator varGen)
fieldExpr,
to set the ghost value to the value of the given variable,
argVar.
private static RacNode transPrefix(VarGenerator varGen,
JClassFieldExpression fieldExpr)
fieldExpr. The expression is assumed
to be a reference to a non-static ghost field. If there is no
need to translate the prefix (e.g., super, T.super, this,
T.this, T), then null is returned; otherwise, the
translated code of the following form is returned.
T v; [[E, v]]where
E is the prefix expression, and
v is a temporary variable. The name of the
temporary variable, v, is stored in the name field
of the result object.
requires varGen != null && fieldExpr != null; ensures (* \result may be null *);
private static boolean isStatic(JClassFieldExpression expr)
requires expr != null;
public static String operator(JAssignmentExpression expr)
" = " for
simple assignment expression.
requires expr != null; ensures \result != null && \fresh(\result);
public void visitJmlUnreachableStatement(JmlUnreachableStatement self)
unreachable statement.
The translated assertion code has the following form:
[[unreachable;]] == check(v [&& !assumed]);The optional conjunction in the check statement is generated only if the statement is in the scope of any
assume statement.
This is because the assert condition must hold only if the assume
conditions hold.
The flag assumed is set by assume
statements.
visitJmlUnreachableStatement in interface JmlVisitorvisitJmlUnreachableStatement in class JmlAbstractVisitorvisitJmlAssumeStatement(JmlAssumeStatement)public void visitAssertStatement(JAssertStatement self)
visitAssertStatement in interface MjcVisitorvisitAssertStatement in class JmlAbstractVisitorpublic void visitBlockStatement(JBlock self)
visitBlockStatement in interface MjcVisitorvisitBlockStatement in class JmlAbstractVisitorpublic void visitConstructorBlock(JConstructorBlock self)
visitConstructorBlock in interface MjcVisitorvisitConstructorBlock in class JmlAbstractVisitorpublic void visitBreakStatement(JBreakStatement self)
visitBreakStatement in interface MjcVisitorvisitBreakStatement in class JmlAbstractVisitorpublic void visitCompoundStatement(JCompoundStatement self)
visitCompoundStatement in interface MjcVisitorvisitCompoundStatement in class JmlAbstractVisitorpublic void visitCompoundStatement(JStatement[] body)
visitCompoundStatement in class JmlAbstractVisitorpublic void visitContinueStatement(JContinueStatement self)
visitContinueStatement in interface MjcVisitorvisitContinueStatement in class JmlAbstractVisitorpublic void visitEmptyStatement(JEmptyStatement self)
visitEmptyStatement in interface MjcVisitorvisitEmptyStatement in class JmlAbstractVisitorpublic void visitExpressionListStatement(JExpressionListStatement self)
visitExpressionListStatement in interface MjcVisitorvisitExpressionListStatement in class JmlAbstractVisitorpublic void visitExpressionStatement(JExpressionStatement self)
visitExpressionStatement in interface MjcVisitorvisitExpressionStatement in class JmlAbstractVisitorpublic void visitIfStatement(JIfStatement self)
visitIfStatement in interface MjcVisitorvisitIfStatement in class JmlAbstractVisitorpublic void visitLabeledStatement(JLabeledStatement self)
visitLabeledStatement in interface MjcVisitorvisitLabeledStatement in class JmlAbstractVisitorpublic void visitForStatement(JForStatement self)
visitForStatement in interface MjcVisitorvisitForStatement in class JmlAbstractVisitorpublic void visitDoStatement(JDoStatement self)
visitDoStatement in interface MjcVisitorvisitDoStatement in class JmlAbstractVisitorpublic void visitWhileStatement(JWhileStatement self)
visitWhileStatement in interface MjcVisitorvisitWhileStatement in class JmlAbstractVisitorpublic void visitReturnStatement(JReturnStatement self)
visitReturnStatement in interface MjcVisitorvisitReturnStatement in class JmlAbstractVisitorpublic void visitSwitchStatement(JSwitchStatement self)
visitSwitchStatement in interface MjcVisitorvisitSwitchStatement in class JmlAbstractVisitorpublic void visitSwitchGroup(JSwitchGroup self)
visitSwitchGroup in interface MjcVisitorvisitSwitchGroup in class JmlAbstractVisitorpublic void visitSynchronizedStatement(JSynchronizedStatement self)
visitSynchronizedStatement in interface MjcVisitorvisitSynchronizedStatement in class JmlAbstractVisitorpublic void visitThrowStatement(JThrowStatement self)
visitThrowStatement in interface MjcVisitorvisitThrowStatement in class JmlAbstractVisitorpublic void visitTryCatchStatement(JTryCatchStatement self)
visitTryCatchStatement in interface MjcVisitorvisitTryCatchStatement in class JmlAbstractVisitorpublic void visitTryFinallyStatement(JTryFinallyStatement self)
visitTryFinallyStatement in interface MjcVisitorvisitTryFinallyStatement in class JmlAbstractVisitorpublic void visitTypeDeclarationStatement(JTypeDeclarationStatement self)
visitTypeDeclarationStatement in interface MjcVisitorvisitTypeDeclarationStatement in class JmlAbstractVisitorpublic void visitVariableDeclarationStatement(JVariableDeclarationStatement self)
visitVariableDeclarationStatement in interface MjcVisitorvisitVariableDeclarationStatement in class JmlAbstractVisitorprivate static void needDynamicInvocationMethod()
public static String defaultValue(CType type)
type.
protected String isActive()
|
JML | ||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||||