The great tab cleanup of 2012
diff --git a/baksmali/src/main/java/org/jf/baksmali/Adaptors/ClassDefinition.java b/baksmali/src/main/java/org/jf/baksmali/Adaptors/ClassDefinition.java
index 781e70b..816b1ae 100644
--- a/baksmali/src/main/java/org/jf/baksmali/Adaptors/ClassDefinition.java
+++ b/baksmali/src/main/java/org/jf/baksmali/Adaptors/ClassDefinition.java
@@ -262,7 +262,7 @@
classDefItem.getClassType().getTypeDescriptor(), field.field.getShortFieldString()));
}
- FieldDefinition.writeTo(fieldWriter, field, null, fieldAnnotations, false);
+ FieldDefinition.writeTo(fieldWriter, field, null, fieldAnnotations, false);
}
}
diff --git a/smali/src/main/antlr3/smaliParser.g b/smali/src/main/antlr3/smaliParser.g
index 26ecd96..d9c987f 100644
--- a/smali/src/main/antlr3/smaliParser.g
+++ b/smali/src/main/antlr3/smaliParser.g
@@ -29,8 +29,8 @@
parser grammar smaliParser;
options {
- output=AST;
- ASTLabelType=CommonTree;
+ output=AST;
+ ASTLabelType=CommonTree;
}
tokens {
@@ -171,94 +171,94 @@
LABEL;
INTEGER_LITERAL;
- //I_* tokens are imaginary tokens used as parent AST nodes
- I_CLASS_DEF;
- I_SUPER;
- I_IMPLEMENTS;
- I_SOURCE;
- I_ACCESS_LIST;
- I_METHODS;
- I_FIELDS;
- I_FIELD;
- I_FIELD_TYPE;
- I_FIELD_INITIAL_VALUE;
- I_METHOD;
- I_METHOD_PROTOTYPE;
- I_METHOD_RETURN_TYPE;
- I_REGISTERS;
- I_LOCALS;
- I_LABELS;
- I_LABEL;
- I_ANNOTATIONS;
- I_ANNOTATION;
- I_ANNOTATION_ELEMENT;
- I_SUBANNOTATION;
- I_ENCODED_FIELD;
- I_ENCODED_METHOD;
- I_ENCODED_ENUM;
- I_ENCODED_ARRAY;
- I_ARRAY_ELEMENT_SIZE;
- I_ARRAY_ELEMENTS;
- I_PACKED_SWITCH_START_KEY;
- I_PACKED_SWITCH_TARGET_COUNT;
- I_PACKED_SWITCH_TARGETS;
- I_PACKED_SWITCH_DECLARATION;
- I_PACKED_SWITCH_DECLARATIONS;
- I_SPARSE_SWITCH_KEYS;
- I_SPARSE_SWITCH_TARGET_COUNT;
- I_SPARSE_SWITCH_TARGETS;
- I_SPARSE_SWITCH_DECLARATION;
- I_SPARSE_SWITCH_DECLARATIONS;
- I_ADDRESS;
- I_CATCH;
- I_CATCHALL;
- I_CATCHES;
- I_PARAMETER;
- I_PARAMETERS;
- I_PARAMETER_NOT_SPECIFIED;
- I_ORDERED_DEBUG_DIRECTIVES;
- I_LINE;
- I_LOCAL;
- I_END_LOCAL;
- I_RESTART_LOCAL;
- I_PROLOGUE;
- I_EPILOGUE;
- I_STATEMENTS;
- I_STATEMENT_FORMAT10t;
- I_STATEMENT_FORMAT10x;
- I_STATEMENT_FORMAT11n;
- I_STATEMENT_FORMAT11x;
- I_STATEMENT_FORMAT12x;
- I_STATEMENT_FORMAT20bc;
- I_STATEMENT_FORMAT20t;
- I_STATEMENT_FORMAT21c_TYPE;
- I_STATEMENT_FORMAT21c_FIELD;
- I_STATEMENT_FORMAT21c_STRING;
- I_STATEMENT_FORMAT21h;
- I_STATEMENT_FORMAT21s;
- I_STATEMENT_FORMAT21t;
- I_STATEMENT_FORMAT22b;
- I_STATEMENT_FORMAT22c_FIELD;
- I_STATEMENT_FORMAT22c_TYPE;
- I_STATEMENT_FORMAT22s;
- I_STATEMENT_FORMAT22t;
- I_STATEMENT_FORMAT22x;
- I_STATEMENT_FORMAT23x;
- I_STATEMENT_FORMAT30t;
- I_STATEMENT_FORMAT31c;
- I_STATEMENT_FORMAT31i;
- I_STATEMENT_FORMAT31t;
- I_STATEMENT_FORMAT32x;
- I_STATEMENT_FORMAT35c_METHOD;
- I_STATEMENT_FORMAT35c_TYPE;
- I_STATEMENT_FORMAT3rc_METHOD;
- I_STATEMENT_FORMAT3rc_TYPE;
- I_STATEMENT_FORMAT51l;
- I_STATEMENT_ARRAY_DATA;
- I_STATEMENT_PACKED_SWITCH;
- I_STATEMENT_SPARSE_SWITCH;
- I_REGISTER_RANGE;
- I_REGISTER_LIST;
+ //I_* tokens are imaginary tokens used as parent AST nodes
+ I_CLASS_DEF;
+ I_SUPER;
+ I_IMPLEMENTS;
+ I_SOURCE;
+ I_ACCESS_LIST;
+ I_METHODS;
+ I_FIELDS;
+ I_FIELD;
+ I_FIELD_TYPE;
+ I_FIELD_INITIAL_VALUE;
+ I_METHOD;
+ I_METHOD_PROTOTYPE;
+ I_METHOD_RETURN_TYPE;
+ I_REGISTERS;
+ I_LOCALS;
+ I_LABELS;
+ I_LABEL;
+ I_ANNOTATIONS;
+ I_ANNOTATION;
+ I_ANNOTATION_ELEMENT;
+ I_SUBANNOTATION;
+ I_ENCODED_FIELD;
+ I_ENCODED_METHOD;
+ I_ENCODED_ENUM;
+ I_ENCODED_ARRAY;
+ I_ARRAY_ELEMENT_SIZE;
+ I_ARRAY_ELEMENTS;
+ I_PACKED_SWITCH_START_KEY;
+ I_PACKED_SWITCH_TARGET_COUNT;
+ I_PACKED_SWITCH_TARGETS;
+ I_PACKED_SWITCH_DECLARATION;
+ I_PACKED_SWITCH_DECLARATIONS;
+ I_SPARSE_SWITCH_KEYS;
+ I_SPARSE_SWITCH_TARGET_COUNT;
+ I_SPARSE_SWITCH_TARGETS;
+ I_SPARSE_SWITCH_DECLARATION;
+ I_SPARSE_SWITCH_DECLARATIONS;
+ I_ADDRESS;
+ I_CATCH;
+ I_CATCHALL;
+ I_CATCHES;
+ I_PARAMETER;
+ I_PARAMETERS;
+ I_PARAMETER_NOT_SPECIFIED;
+ I_ORDERED_DEBUG_DIRECTIVES;
+ I_LINE;
+ I_LOCAL;
+ I_END_LOCAL;
+ I_RESTART_LOCAL;
+ I_PROLOGUE;
+ I_EPILOGUE;
+ I_STATEMENTS;
+ I_STATEMENT_FORMAT10t;
+ I_STATEMENT_FORMAT10x;
+ I_STATEMENT_FORMAT11n;
+ I_STATEMENT_FORMAT11x;
+ I_STATEMENT_FORMAT12x;
+ I_STATEMENT_FORMAT20bc;
+ I_STATEMENT_FORMAT20t;
+ I_STATEMENT_FORMAT21c_TYPE;
+ I_STATEMENT_FORMAT21c_FIELD;
+ I_STATEMENT_FORMAT21c_STRING;
+ I_STATEMENT_FORMAT21h;
+ I_STATEMENT_FORMAT21s;
+ I_STATEMENT_FORMAT21t;
+ I_STATEMENT_FORMAT22b;
+ I_STATEMENT_FORMAT22c_FIELD;
+ I_STATEMENT_FORMAT22c_TYPE;
+ I_STATEMENT_FORMAT22s;
+ I_STATEMENT_FORMAT22t;
+ I_STATEMENT_FORMAT22x;
+ I_STATEMENT_FORMAT23x;
+ I_STATEMENT_FORMAT30t;
+ I_STATEMENT_FORMAT31c;
+ I_STATEMENT_FORMAT31i;
+ I_STATEMENT_FORMAT31t;
+ I_STATEMENT_FORMAT32x;
+ I_STATEMENT_FORMAT35c_METHOD;
+ I_STATEMENT_FORMAT35c_TYPE;
+ I_STATEMENT_FORMAT3rc_METHOD;
+ I_STATEMENT_FORMAT3rc_TYPE;
+ I_STATEMENT_FORMAT51l;
+ I_STATEMENT_ARRAY_DATA;
+ I_STATEMENT_PACKED_SWITCH;
+ I_STATEMENT_SPARSE_SWITCH;
+ I_REGISTER_RANGE;
+ I_REGISTER_LIST;
}
@header {
@@ -270,226 +270,226 @@
@members {
- public static final int ERROR_CHANNEL = 100;
+ public static final int ERROR_CHANNEL = 100;
- private boolean verboseErrors = false;
- private boolean allowOdex = false;
- private int apiLevel;
+ private boolean verboseErrors = false;
+ private boolean allowOdex = false;
+ private int apiLevel;
- public void setVerboseErrors(boolean verboseErrors) {
- this.verboseErrors = verboseErrors;
- }
+ public void setVerboseErrors(boolean verboseErrors) {
+ this.verboseErrors = verboseErrors;
+ }
- public void setAllowOdex(boolean allowOdex) {
- this.allowOdex = allowOdex;
- }
+ public void setAllowOdex(boolean allowOdex) {
+ this.allowOdex = allowOdex;
+ }
- public void setApiLevel(int apiLevel) {
- this.apiLevel = apiLevel;
- }
+ public void setApiLevel(int apiLevel) {
+ this.apiLevel = apiLevel;
+ }
- public String getErrorMessage(RecognitionException e,
- String[] tokenNames) {
+ public String getErrorMessage(RecognitionException e,
+ String[] tokenNames) {
- if (verboseErrors) {
- List stack = getRuleInvocationStack(e, this.getClass().getName());
- String msg = null;
+ if (verboseErrors) {
+ List stack = getRuleInvocationStack(e, this.getClass().getName());
+ String msg = null;
- if (e instanceof NoViableAltException) {
- NoViableAltException nvae = (NoViableAltException)e;
- msg = " no viable alt; token="+getTokenErrorDisplay(e.token)+
- " (decision="+nvae.decisionNumber+
- " state "+nvae.stateNumber+")"+
- " decision=<<"+nvae.grammarDecisionDescription+">>";
- } else {
- msg = super.getErrorMessage(e, tokenNames);
- }
+ if (e instanceof NoViableAltException) {
+ NoViableAltException nvae = (NoViableAltException)e;
+ msg = " no viable alt; token="+getTokenErrorDisplay(e.token)+
+ " (decision="+nvae.decisionNumber+
+ " state "+nvae.stateNumber+")"+
+ " decision=<<"+nvae.grammarDecisionDescription+">>";
+ } else {
+ msg = super.getErrorMessage(e, tokenNames);
+ }
- return stack + " " + msg;
- } else {
- return super.getErrorMessage(e, tokenNames);
- }
- }
+ return stack + " " + msg;
+ } else {
+ return super.getErrorMessage(e, tokenNames);
+ }
+ }
- public String getTokenErrorDisplay(Token t) {
- if (!verboseErrors) {
- String s = t.getText();
- if ( s==null ) {
- if ( t.getType()==Token.EOF ) {
- s = "<EOF>";
- }
- else {
- s = "<"+tokenNames[t.getType()]+">";
- }
- }
- s = s.replaceAll("\n","\\\\n");
- s = s.replaceAll("\r","\\\\r");
- s = s.replaceAll("\t","\\\\t");
- return "'"+s+"'";
- }
+ public String getTokenErrorDisplay(Token t) {
+ if (!verboseErrors) {
+ String s = t.getText();
+ if ( s==null ) {
+ if ( t.getType()==Token.EOF ) {
+ s = "<EOF>";
+ }
+ else {
+ s = "<"+tokenNames[t.getType()]+">";
+ }
+ }
+ s = s.replaceAll("\n","\\\\n");
+ s = s.replaceAll("\r","\\\\r");
+ s = s.replaceAll("\t","\\\\t");
+ return "'"+s+"'";
+ }
- CommonToken ct = (CommonToken)t;
+ CommonToken ct = (CommonToken)t;
- String channelStr = "";
- if (t.getChannel()>0) {
- channelStr=",channel="+t.getChannel();
- }
- String txt = t.getText();
- if ( txt!=null ) {
- txt = txt.replaceAll("\n","\\\\n");
- txt = txt.replaceAll("\r","\\\\r");
- txt = txt.replaceAll("\t","\\\\t");
- }
- else {
- txt = "<no text>";
- }
- return "[@"+t.getTokenIndex()+","+ct.getStartIndex()+":"+ct.getStopIndex()+"='"+txt+"',<"+tokenNames[t.getType()]+">"+channelStr+","+t.getLine()+":"+t.getCharPositionInLine()+"]";
- }
+ String channelStr = "";
+ if (t.getChannel()>0) {
+ channelStr=",channel="+t.getChannel();
+ }
+ String txt = t.getText();
+ if ( txt!=null ) {
+ txt = txt.replaceAll("\n","\\\\n");
+ txt = txt.replaceAll("\r","\\\\r");
+ txt = txt.replaceAll("\t","\\\\t");
+ }
+ else {
+ txt = "<no text>";
+ }
+ return "[@"+t.getTokenIndex()+","+ct.getStartIndex()+":"+ct.getStopIndex()+"='"+txt+"',<"+tokenNames[t.getType()]+">"+channelStr+","+t.getLine()+":"+t.getCharPositionInLine()+"]";
+ }
- public String getErrorHeader(RecognitionException e) {
- return getSourceName()+"["+ e.line+","+e.charPositionInLine+"]";
- }
+ public String getErrorHeader(RecognitionException e) {
+ return getSourceName()+"["+ e.line+","+e.charPositionInLine+"]";
+ }
- private CommonTree buildTree(int type, String text, List<CommonTree> children) {
- CommonTree root = new CommonTree(new CommonToken(type, text));
- for (CommonTree child: children) {
- root.addChild(child);
- }
- return root;
- }
+ private CommonTree buildTree(int type, String text, List<CommonTree> children) {
+ CommonTree root = new CommonTree(new CommonToken(type, text));
+ for (CommonTree child: children) {
+ root.addChild(child);
+ }
+ return root;
+ }
- private CommonToken getParamListSubToken(CommonToken baseToken, String str, int typeStartIndex) {
- CommonToken token = new CommonToken(baseToken);
- token.setStartIndex(baseToken.getStartIndex() + typeStartIndex);
+ private CommonToken getParamListSubToken(CommonToken baseToken, String str, int typeStartIndex) {
+ CommonToken token = new CommonToken(baseToken);
+ token.setStartIndex(baseToken.getStartIndex() + typeStartIndex);
- switch (str.charAt(typeStartIndex)) {
- case 'Z':
- case 'B':
- case 'S':
- case 'C':
- case 'I':
- case 'J':
- case 'F':
- case 'D':
- {
- token.setType(PRIMITIVE_TYPE);
- token.setText(str.substring(typeStartIndex, typeStartIndex+1));
- token.setStopIndex(baseToken.getStartIndex() + typeStartIndex);
- break;
- }
- case 'L':
- {
- int i = typeStartIndex;
- while (str.charAt(++i) != ';');
+ switch (str.charAt(typeStartIndex)) {
+ case 'Z':
+ case 'B':
+ case 'S':
+ case 'C':
+ case 'I':
+ case 'J':
+ case 'F':
+ case 'D':
+ {
+ token.setType(PRIMITIVE_TYPE);
+ token.setText(str.substring(typeStartIndex, typeStartIndex+1));
+ token.setStopIndex(baseToken.getStartIndex() + typeStartIndex);
+ break;
+ }
+ case 'L':
+ {
+ int i = typeStartIndex;
+ while (str.charAt(++i) != ';');
- token.setType(CLASS_DESCRIPTOR);
- token.setText(str.substring(typeStartIndex, i + 1));
- token.setStopIndex(baseToken.getStartIndex() + i);
- break;
- }
- case '[':
- {
- int i = typeStartIndex;
- while (str.charAt(++i) == '[');
+ token.setType(CLASS_DESCRIPTOR);
+ token.setText(str.substring(typeStartIndex, i + 1));
+ token.setStopIndex(baseToken.getStartIndex() + i);
+ break;
+ }
+ case '[':
+ {
+ int i = typeStartIndex;
+ while (str.charAt(++i) == '[');
- if (str.charAt(i++) == 'L') {
- while (str.charAt(i++) != ';');
- }
+ if (str.charAt(i++) == 'L') {
+ while (str.charAt(i++) != ';');
+ }
- token.setType(ARRAY_DESCRIPTOR);
- token.setText(str.substring(typeStartIndex, i));
- token.setStopIndex(baseToken.getStartIndex() + i - 1);
- break;
- }
- default:
- throw new RuntimeException(String.format("Invalid character '\%c' in param list \"\%s\" at position \%d", str.charAt(typeStartIndex), str, typeStartIndex));
- }
+ token.setType(ARRAY_DESCRIPTOR);
+ token.setText(str.substring(typeStartIndex, i));
+ token.setStopIndex(baseToken.getStartIndex() + i - 1);
+ break;
+ }
+ default:
+ throw new RuntimeException(String.format("Invalid character '\%c' in param list \"\%s\" at position \%d", str.charAt(typeStartIndex), str, typeStartIndex));
+ }
- return token;
- }
+ return token;
+ }
- private CommonTree parseParamList(CommonToken paramListToken) {
- String paramList = paramListToken.getText();
- CommonTree root = new CommonTree();
+ private CommonTree parseParamList(CommonToken paramListToken) {
+ String paramList = paramListToken.getText();
+ CommonTree root = new CommonTree();
- int startIndex = paramListToken.getStartIndex();
+ int startIndex = paramListToken.getStartIndex();
- int i=0;
- while (i<paramList.length()) {
- CommonToken token = getParamListSubToken(paramListToken, paramList, i);
- root.addChild(new CommonTree(token));
- i += token.getText().length();
- }
+ int i=0;
+ while (i<paramList.length()) {
+ CommonToken token = getParamListSubToken(paramListToken, paramList, i);
+ root.addChild(new CommonTree(token));
+ i += token.getText().length();
+ }
- if (root.getChildCount() == 0) {
- return null;
- }
- return root;
- }
+ if (root.getChildCount() == 0) {
+ return null;
+ }
+ return root;
+ }
- private void throwOdexedInstructionException(IntStream input, String odexedInstruction)
- throws OdexedInstructionException {
- /*this has to be done in a separate method, otherwise java will complain about the
- auto-generated code in the rule after the throw not being reachable*/
- throw new OdexedInstructionException(input, odexedInstruction);
- }
+ private void throwOdexedInstructionException(IntStream input, String odexedInstruction)
+ throws OdexedInstructionException {
+ /*this has to be done in a separate method, otherwise java will complain about the
+ auto-generated code in the rule after the throw not being reachable*/
+ throw new OdexedInstructionException(input, odexedInstruction);
+ }
}
smali_file
- scope
- {
- boolean hasClassSpec;
- boolean hasSuperSpec;
- boolean hasSourceSpec;
- List<CommonTree> classAnnotations;
- }
- @init
- { $smali_file::hasClassSpec = $smali_file::hasSuperSpec = $smali_file::hasSourceSpec = false;
- $smali_file::classAnnotations = new ArrayList<CommonTree>();
- }
- :
- ( {!$smali_file::hasClassSpec}?=> class_spec {$smali_file::hasClassSpec = true;}
- | {!$smali_file::hasSuperSpec}?=> super_spec {$smali_file::hasSuperSpec = true;}
- | implements_spec
- | {!$smali_file::hasSourceSpec}?=> source_spec {$smali_file::hasSourceSpec = true;}
- | method
- | field
- | annotation {$smali_file::classAnnotations.add($annotation.tree);}
- )+
- EOF
- {
- if (!$smali_file::hasClassSpec) {
- throw new SemanticException(input, "The file must contain a .class directive");
- }
+ scope
+ {
+ boolean hasClassSpec;
+ boolean hasSuperSpec;
+ boolean hasSourceSpec;
+ List<CommonTree> classAnnotations;
+ }
+ @init
+ { $smali_file::hasClassSpec = $smali_file::hasSuperSpec = $smali_file::hasSourceSpec = false;
+ $smali_file::classAnnotations = new ArrayList<CommonTree>();
+ }
+ :
+ ( {!$smali_file::hasClassSpec}?=> class_spec {$smali_file::hasClassSpec = true;}
+ | {!$smali_file::hasSuperSpec}?=> super_spec {$smali_file::hasSuperSpec = true;}
+ | implements_spec
+ | {!$smali_file::hasSourceSpec}?=> source_spec {$smali_file::hasSourceSpec = true;}
+ | method
+ | field
+ | annotation {$smali_file::classAnnotations.add($annotation.tree);}
+ )+
+ EOF
+ {
+ if (!$smali_file::hasClassSpec) {
+ throw new SemanticException(input, "The file must contain a .class directive");
+ }
- if (!$smali_file::hasSuperSpec) {
- if (!$class_spec.className.equals("Ljava/lang/Object;")) {
- throw new SemanticException(input, "The file must contain a .super directive");
- }
- }
- }
- -> ^(I_CLASS_DEF
- class_spec
- super_spec?
- implements_spec*
- source_spec?
- ^(I_METHODS method*) ^(I_FIELDS field*) {buildTree(I_ANNOTATIONS, "I_ANNOTATIONS", $smali_file::classAnnotations)});
+ if (!$smali_file::hasSuperSpec) {
+ if (!$class_spec.className.equals("Ljava/lang/Object;")) {
+ throw new SemanticException(input, "The file must contain a .super directive");
+ }
+ }
+ }
+ -> ^(I_CLASS_DEF
+ class_spec
+ super_spec?
+ implements_spec*
+ source_spec?
+ ^(I_METHODS method*) ^(I_FIELDS field*) {buildTree(I_ANNOTATIONS, "I_ANNOTATIONS", $smali_file::classAnnotations)});
class_spec returns[String className]
- : CLASS_DIRECTIVE access_list CLASS_DESCRIPTOR {$className = $CLASS_DESCRIPTOR.text;} -> CLASS_DESCRIPTOR access_list;
+ : CLASS_DIRECTIVE access_list CLASS_DESCRIPTOR {$className = $CLASS_DESCRIPTOR.text;} -> CLASS_DESCRIPTOR access_list;
super_spec
- : SUPER_DIRECTIVE CLASS_DESCRIPTOR -> ^(I_SUPER[$start, "I_SUPER"] CLASS_DESCRIPTOR);
+ : SUPER_DIRECTIVE CLASS_DESCRIPTOR -> ^(I_SUPER[$start, "I_SUPER"] CLASS_DESCRIPTOR);
implements_spec
- : IMPLEMENTS_DIRECTIVE CLASS_DESCRIPTOR -> ^(I_IMPLEMENTS[$start, "I_IMPLEMENTS"] CLASS_DESCRIPTOR);
+ : IMPLEMENTS_DIRECTIVE CLASS_DESCRIPTOR -> ^(I_IMPLEMENTS[$start, "I_IMPLEMENTS"] CLASS_DESCRIPTOR);
source_spec
- : SOURCE_DIRECTIVE STRING_LITERAL -> ^(I_SOURCE[$start, "I_SOURCE"] STRING_LITERAL);
+ : SOURCE_DIRECTIVE STRING_LITERAL -> ^(I_SOURCE[$start, "I_SOURCE"] STRING_LITERAL);
access_list
- : ACCESS_SPEC* -> ^(I_ACCESS_LIST[$start,"I_ACCESS_LIST"] ACCESS_SPEC*);
+ : ACCESS_SPEC* -> ^(I_ACCESS_LIST[$start,"I_ACCESS_LIST"] ACCESS_SPEC*);
/*When there are annotations immediately after a field definition, we don't know whether they are field annotations
@@ -497,697 +497,702 @@
the annotations. If it turns out that they are field annotations, we include them in the I_FIELD AST. Otherwise, we
add them to the $smali_file::classAnnotations list*/
field
- @init {List<CommonTree> annotations = new ArrayList<CommonTree>();}
- : FIELD_DIRECTIVE access_list simple_name COLON nonvoid_type_descriptor (EQUAL literal)?
- ( ({input.LA(1) == ANNOTATION_DIRECTIVE}? annotation {annotations.add($annotation.tree);})*
- ( END_FIELD_DIRECTIVE
- -> ^(I_FIELD[$start, "I_FIELD"] simple_name access_list ^(I_FIELD_TYPE nonvoid_type_descriptor) ^(I_FIELD_INITIAL_VALUE literal)? ^(I_ANNOTATIONS annotation*))
- | /*epsilon*/ {$smali_file::classAnnotations.addAll(annotations);}
- -> ^(I_FIELD[$start, "I_FIELD"] simple_name access_list ^(I_FIELD_TYPE nonvoid_type_descriptor) ^(I_FIELD_INITIAL_VALUE literal)? ^(I_ANNOTATIONS))
- )
- );
+ @init {List<CommonTree> annotations = new ArrayList<CommonTree>();}
+ : FIELD_DIRECTIVE access_list simple_name COLON nonvoid_type_descriptor (EQUAL literal)?
+ ( ({input.LA(1) == ANNOTATION_DIRECTIVE}? annotation {annotations.add($annotation.tree);})*
+ ( END_FIELD_DIRECTIVE
+ -> ^(I_FIELD[$start, "I_FIELD"] simple_name access_list ^(I_FIELD_TYPE nonvoid_type_descriptor) ^(I_FIELD_INITIAL_VALUE literal)? ^(I_ANNOTATIONS annotation*))
+ | /*epsilon*/ {$smali_file::classAnnotations.addAll(annotations);}
+ -> ^(I_FIELD[$start, "I_FIELD"] simple_name access_list ^(I_FIELD_TYPE nonvoid_type_descriptor) ^(I_FIELD_INITIAL_VALUE literal)? ^(I_ANNOTATIONS))
+ )
+ );
method
- scope {int currentAddress;}
- : {$method::currentAddress = 0;}
- METHOD_DIRECTIVE access_list method_name method_prototype statements_and_directives
- END_METHOD_DIRECTIVE
- -> ^(I_METHOD[$start, "I_METHOD"] method_name method_prototype access_list statements_and_directives);
+ scope {int currentAddress;}
+ : {$method::currentAddress = 0;}
+ METHOD_DIRECTIVE access_list method_name method_prototype statements_and_directives
+ END_METHOD_DIRECTIVE
+ -> ^(I_METHOD[$start, "I_METHOD"] method_name method_prototype access_list statements_and_directives);
statements_and_directives
- scope
- {
- boolean hasRegistersDirective;
- List<CommonTree> packedSwitchDeclarations;
- List<CommonTree> sparseSwitchDeclarations;
- List<CommonTree> methodAnnotations;
- }
- : {
- $method::currentAddress = 0;
- $statements_and_directives::hasRegistersDirective = false;
- $statements_and_directives::packedSwitchDeclarations = new ArrayList<CommonTree>();
- $statements_and_directives::sparseSwitchDeclarations = new ArrayList<CommonTree>();
- $statements_and_directives::methodAnnotations = new ArrayList<CommonTree>();
- }
- ( instruction {$method::currentAddress += $instruction.size/2;}
- | registers_directive
- | label
- | catch_directive
- | catchall_directive
- | parameter_directive
- | ordered_debug_directive
- | annotation {$statements_and_directives::methodAnnotations.add($annotation.tree);}
- )*
- -> registers_directive?
- ^(I_LABELS label*)
- {buildTree(I_PACKED_SWITCH_DECLARATIONS, "I_PACKED_SWITCH_DECLARATIONS", $statements_and_directives::packedSwitchDeclarations)}
- {buildTree(I_SPARSE_SWITCH_DECLARATIONS, "I_SPARSE_SWITCH_DECLARATIONS", $statements_and_directives::sparseSwitchDeclarations)}
- ^(I_STATEMENTS instruction*)
- ^(I_CATCHES catch_directive* catchall_directive*)
- ^(I_PARAMETERS parameter_directive*)
- ^(I_ORDERED_DEBUG_DIRECTIVES ordered_debug_directive*)
- {buildTree(I_ANNOTATIONS, "I_ANNOTATIONS", $statements_and_directives::methodAnnotations)};
+ scope
+ {
+ boolean hasRegistersDirective;
+ List<CommonTree> packedSwitchDeclarations;
+ List<CommonTree> sparseSwitchDeclarations;
+ List<CommonTree> methodAnnotations;
+ }
+ : {
+ $method::currentAddress = 0;
+ $statements_and_directives::hasRegistersDirective = false;
+ $statements_and_directives::packedSwitchDeclarations = new ArrayList<CommonTree>();
+ $statements_and_directives::sparseSwitchDeclarations = new ArrayList<CommonTree>();
+ $statements_and_directives::methodAnnotations = new ArrayList<CommonTree>();
+ }
+ ( instruction {$method::currentAddress += $instruction.size/2;}
+ | registers_directive
+ | label
+ | catch_directive
+ | catchall_directive
+ | parameter_directive
+ | ordered_debug_directive
+ | annotation {$statements_and_directives::methodAnnotations.add($annotation.tree);}
+ )*
+ -> registers_directive?
+ ^(I_LABELS label*)
+ {buildTree(I_PACKED_SWITCH_DECLARATIONS, "I_PACKED_SWITCH_DECLARATIONS", $statements_and_directives::packedSwitchDeclarations)}
+ {buildTree(I_SPARSE_SWITCH_DECLARATIONS, "I_SPARSE_SWITCH_DECLARATIONS", $statements_and_directives::sparseSwitchDeclarations)}
+ ^(I_STATEMENTS instruction*)
+ ^(I_CATCHES catch_directive* catchall_directive*)
+ ^(I_PARAMETERS parameter_directive*)
+ ^(I_ORDERED_DEBUG_DIRECTIVES ordered_debug_directive*)
+ {buildTree(I_ANNOTATIONS, "I_ANNOTATIONS", $statements_and_directives::methodAnnotations)};
registers_directive
- : (
- directive=REGISTERS_DIRECTIVE regCount=integral_literal -> ^(I_REGISTERS[$REGISTERS_DIRECTIVE, "I_REGISTERS"] $regCount)
- | directive=LOCALS_DIRECTIVE regCount2=integral_literal -> ^(I_LOCALS[$LOCALS_DIRECTIVE, "I_LOCALS"] $regCount2)
- )
- {
- if ($statements_and_directives::hasRegistersDirective) {
- throw new SemanticException(input, $directive, "There can only be a single .registers or .locals directive in a method");
- }
- $statements_and_directives::hasRegistersDirective=true;
- };
+ : (
+ directive=REGISTERS_DIRECTIVE regCount=integral_literal -> ^(I_REGISTERS[$REGISTERS_DIRECTIVE, "I_REGISTERS"] $regCount)
+ | directive=LOCALS_DIRECTIVE regCount2=integral_literal -> ^(I_LOCALS[$LOCALS_DIRECTIVE, "I_LOCALS"] $regCount2)
+ )
+ {
+ if ($statements_and_directives::hasRegistersDirective) {
+ throw new SemanticException(input, $directive, "There can only be a single .registers or .locals directive in a method");
+ }
+ $statements_and_directives::hasRegistersDirective=true;
+ };
/*identifiers are much more general than most languages. Any of the below can either be
the indicated type OR an identifier, depending on the context*/
simple_name
- : SIMPLE_NAME
- | ACCESS_SPEC -> SIMPLE_NAME[$ACCESS_SPEC]
- | VERIFICATION_ERROR_TYPE -> SIMPLE_NAME[$VERIFICATION_ERROR_TYPE]
- | POSITIVE_INTEGER_LITERAL -> SIMPLE_NAME[$POSITIVE_INTEGER_LITERAL]
- | NEGATIVE_INTEGER_LITERAL -> SIMPLE_NAME[$NEGATIVE_INTEGER_LITERAL]
- | FLOAT_LITERAL_OR_ID -> SIMPLE_NAME[$FLOAT_LITERAL_OR_ID]
- | DOUBLE_LITERAL_OR_ID -> SIMPLE_NAME[$DOUBLE_LITERAL_OR_ID]
- | BOOL_LITERAL -> SIMPLE_NAME[$BOOL_LITERAL]
- | NULL_LITERAL -> SIMPLE_NAME[$NULL_LITERAL]
- | REGISTER -> SIMPLE_NAME[$REGISTER]
- | PARAM_LIST_OR_ID -> SIMPLE_NAME[$PARAM_LIST_OR_ID]
- | PRIMITIVE_TYPE -> SIMPLE_NAME[$PRIMITIVE_TYPE]
- | VOID_TYPE -> SIMPLE_NAME[$VOID_TYPE]
- | ANNOTATION_VISIBILITY -> SIMPLE_NAME[$ANNOTATION_VISIBILITY]
- | INSTRUCTION_FORMAT10t -> SIMPLE_NAME[$INSTRUCTION_FORMAT10t]
- | INSTRUCTION_FORMAT10x -> SIMPLE_NAME[$INSTRUCTION_FORMAT10x]
- | INSTRUCTION_FORMAT10x_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT10x_ODEX]
- | INSTRUCTION_FORMAT11x -> SIMPLE_NAME[$INSTRUCTION_FORMAT11x]
- | INSTRUCTION_FORMAT12x_OR_ID -> SIMPLE_NAME[$INSTRUCTION_FORMAT12x_OR_ID]
- | INSTRUCTION_FORMAT21c_FIELD -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_FIELD]
- | INSTRUCTION_FORMAT21c_FIELD_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_FIELD_ODEX]
- | INSTRUCTION_FORMAT21c_STRING -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_STRING]
- | INSTRUCTION_FORMAT21c_TYPE -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_TYPE]
- | INSTRUCTION_FORMAT21t -> SIMPLE_NAME[$INSTRUCTION_FORMAT21t]
- | INSTRUCTION_FORMAT22c_FIELD -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_FIELD]
- | INSTRUCTION_FORMAT22c_FIELD_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_FIELD_ODEX]
- | INSTRUCTION_FORMAT22c_TYPE -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_TYPE]
- | INSTRUCTION_FORMAT22cs_FIELD -> SIMPLE_NAME[$INSTRUCTION_FORMAT22cs_FIELD]
- | INSTRUCTION_FORMAT22s_OR_ID -> SIMPLE_NAME[$INSTRUCTION_FORMAT22s_OR_ID]
- | INSTRUCTION_FORMAT22t -> SIMPLE_NAME[$INSTRUCTION_FORMAT22t]
- | INSTRUCTION_FORMAT23x -> SIMPLE_NAME[$INSTRUCTION_FORMAT23x]
- | INSTRUCTION_FORMAT31i_OR_ID -> SIMPLE_NAME[$INSTRUCTION_FORMAT31i_OR_ID]
- | INSTRUCTION_FORMAT31t -> SIMPLE_NAME[$INSTRUCTION_FORMAT31t]
- | INSTRUCTION_FORMAT35c_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_METHOD]
- | INSTRUCTION_FORMAT35c_METHOD_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_METHOD_ODEX]
- | INSTRUCTION_FORMAT35c_TYPE -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_TYPE]
- | INSTRUCTION_FORMAT35mi_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT35mi_METHOD]
- | INSTRUCTION_FORMAT35ms_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT35ms_METHOD]
- | INSTRUCTION_FORMAT51l -> SIMPLE_NAME[$INSTRUCTION_FORMAT51l];
+ : SIMPLE_NAME
+ | ACCESS_SPEC -> SIMPLE_NAME[$ACCESS_SPEC]
+ | VERIFICATION_ERROR_TYPE -> SIMPLE_NAME[$VERIFICATION_ERROR_TYPE]
+ | POSITIVE_INTEGER_LITERAL -> SIMPLE_NAME[$POSITIVE_INTEGER_LITERAL]
+ | NEGATIVE_INTEGER_LITERAL -> SIMPLE_NAME[$NEGATIVE_INTEGER_LITERAL]
+ | FLOAT_LITERAL_OR_ID -> SIMPLE_NAME[$FLOAT_LITERAL_OR_ID]
+ | DOUBLE_LITERAL_OR_ID -> SIMPLE_NAME[$DOUBLE_LITERAL_OR_ID]
+ | BOOL_LITERAL -> SIMPLE_NAME[$BOOL_LITERAL]
+ | NULL_LITERAL -> SIMPLE_NAME[$NULL_LITERAL]
+ | REGISTER -> SIMPLE_NAME[$REGISTER]
+ | PARAM_LIST_OR_ID -> SIMPLE_NAME[$PARAM_LIST_OR_ID]
+ | PRIMITIVE_TYPE -> SIMPLE_NAME[$PRIMITIVE_TYPE]
+ | VOID_TYPE -> SIMPLE_NAME[$VOID_TYPE]
+ | ANNOTATION_VISIBILITY -> SIMPLE_NAME[$ANNOTATION_VISIBILITY]
+ | INSTRUCTION_FORMAT10t -> SIMPLE_NAME[$INSTRUCTION_FORMAT10t]
+ | INSTRUCTION_FORMAT10x -> SIMPLE_NAME[$INSTRUCTION_FORMAT10x]
+ | INSTRUCTION_FORMAT10x_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT10x_ODEX]
+ | INSTRUCTION_FORMAT11x -> SIMPLE_NAME[$INSTRUCTION_FORMAT11x]
+ | INSTRUCTION_FORMAT12x_OR_ID -> SIMPLE_NAME[$INSTRUCTION_FORMAT12x_OR_ID]
+ | INSTRUCTION_FORMAT21c_FIELD -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_FIELD]
+ | INSTRUCTION_FORMAT21c_FIELD_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_FIELD_ODEX]
+ | INSTRUCTION_FORMAT21c_STRING -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_STRING]
+ | INSTRUCTION_FORMAT21c_TYPE -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_TYPE]
+ | INSTRUCTION_FORMAT21t -> SIMPLE_NAME[$INSTRUCTION_FORMAT21t]
+ | INSTRUCTION_FORMAT22c_FIELD -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_FIELD]
+ | INSTRUCTION_FORMAT22c_FIELD_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_FIELD_ODEX]
+ | INSTRUCTION_FORMAT22c_TYPE -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_TYPE]
+ | INSTRUCTION_FORMAT22cs_FIELD -> SIMPLE_NAME[$INSTRUCTION_FORMAT22cs_FIELD]
+ | INSTRUCTION_FORMAT22s_OR_ID -> SIMPLE_NAME[$INSTRUCTION_FORMAT22s_OR_ID]
+ | INSTRUCTION_FORMAT22t -> SIMPLE_NAME[$INSTRUCTION_FORMAT22t]
+ | INSTRUCTION_FORMAT23x -> SIMPLE_NAME[$INSTRUCTION_FORMAT23x]
+ | INSTRUCTION_FORMAT31i_OR_ID -> SIMPLE_NAME[$INSTRUCTION_FORMAT31i_OR_ID]
+ | INSTRUCTION_FORMAT31t -> SIMPLE_NAME[$INSTRUCTION_FORMAT31t]
+ | INSTRUCTION_FORMAT35c_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_METHOD]
+ | INSTRUCTION_FORMAT35c_METHOD_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_METHOD_ODEX]
+ | INSTRUCTION_FORMAT35c_TYPE -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_TYPE]
+ | INSTRUCTION_FORMAT35mi_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT35mi_METHOD]
+ | INSTRUCTION_FORMAT35ms_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT35ms_METHOD]
+ | INSTRUCTION_FORMAT51l -> SIMPLE_NAME[$INSTRUCTION_FORMAT51l];
method_name
- : simple_name
- | METHOD_NAME -> SIMPLE_NAME[$METHOD_NAME];
+ : simple_name
+ | METHOD_NAME -> SIMPLE_NAME[$METHOD_NAME];
method_prototype
- : OPEN_PAREN param_list CLOSE_PAREN type_descriptor
- -> ^(I_METHOD_PROTOTYPE[$start, "I_METHOD_PROTOTYPE"] ^(I_METHOD_RETURN_TYPE type_descriptor) param_list?);
+ : OPEN_PAREN param_list CLOSE_PAREN type_descriptor
+ -> ^(I_METHOD_PROTOTYPE[$start, "I_METHOD_PROTOTYPE"] ^(I_METHOD_RETURN_TYPE type_descriptor) param_list?);
param_list
- : PARAM_LIST -> { parseParamList((CommonToken)$PARAM_LIST) }
- | PARAM_LIST_OR_ID -> { parseParamList((CommonToken)$PARAM_LIST_OR_ID) }
- | nonvoid_type_descriptor*;
+ : PARAM_LIST -> { parseParamList((CommonToken)$PARAM_LIST) }
+ | PARAM_LIST_OR_ID -> { parseParamList((CommonToken)$PARAM_LIST_OR_ID) }
+ | nonvoid_type_descriptor*;
type_descriptor
- : VOID_TYPE
- | PRIMITIVE_TYPE
- | CLASS_DESCRIPTOR
- | ARRAY_DESCRIPTOR;
+ : VOID_TYPE
+ | PRIMITIVE_TYPE
+ | CLASS_DESCRIPTOR
+ | ARRAY_DESCRIPTOR;
nonvoid_type_descriptor
- : PRIMITIVE_TYPE
- | CLASS_DESCRIPTOR
- | ARRAY_DESCRIPTOR;
+ : PRIMITIVE_TYPE
+ | CLASS_DESCRIPTOR
+ | ARRAY_DESCRIPTOR;
reference_type_descriptor
- : CLASS_DESCRIPTOR
- | ARRAY_DESCRIPTOR;
+ : CLASS_DESCRIPTOR
+ | ARRAY_DESCRIPTOR;
integer_literal
- : POSITIVE_INTEGER_LITERAL -> INTEGER_LITERAL[$POSITIVE_INTEGER_LITERAL]
- | NEGATIVE_INTEGER_LITERAL -> INTEGER_LITERAL[$NEGATIVE_INTEGER_LITERAL];
+ : POSITIVE_INTEGER_LITERAL -> INTEGER_LITERAL[$POSITIVE_INTEGER_LITERAL]
+ | NEGATIVE_INTEGER_LITERAL -> INTEGER_LITERAL[$NEGATIVE_INTEGER_LITERAL];
float_literal
- : FLOAT_LITERAL_OR_ID -> FLOAT_LITERAL[$FLOAT_LITERAL_OR_ID]
- | FLOAT_LITERAL;
+ : FLOAT_LITERAL_OR_ID -> FLOAT_LITERAL[$FLOAT_LITERAL_OR_ID]
+ | FLOAT_LITERAL;
double_literal
- : DOUBLE_LITERAL_OR_ID -> DOUBLE_LITERAL[$DOUBLE_LITERAL_OR_ID]
- | DOUBLE_LITERAL;
+ : DOUBLE_LITERAL_OR_ID -> DOUBLE_LITERAL[$DOUBLE_LITERAL_OR_ID]
+ | DOUBLE_LITERAL;
literal
- : LONG_LITERAL
- | integer_literal
- | SHORT_LITERAL
- | BYTE_LITERAL
- | float_literal
- | double_literal
- | CHAR_LITERAL
- | STRING_LITERAL
- | BOOL_LITERAL
- | NULL_LITERAL
- | array_literal
- | subannotation
- | type_field_method_literal
- | enum_literal;
+ : LONG_LITERAL
+ | integer_literal
+ | SHORT_LITERAL
+ | BYTE_LITERAL
+ | float_literal
+ | double_literal
+ | CHAR_LITERAL
+ | STRING_LITERAL
+ | BOOL_LITERAL
+ | NULL_LITERAL
+ | array_literal
+ | subannotation
+ | type_field_method_literal
+ | enum_literal;
integral_literal
- : LONG_LITERAL
- | integer_literal
- | SHORT_LITERAL
- | CHAR_LITERAL
- | BYTE_LITERAL;
+ : LONG_LITERAL
+ | integer_literal
+ | SHORT_LITERAL
+ | CHAR_LITERAL
+ | BYTE_LITERAL;
fixed_32bit_literal
- : LONG_LITERAL
- | integer_literal
- | SHORT_LITERAL
- | BYTE_LITERAL
- | float_literal
- | CHAR_LITERAL
- | BOOL_LITERAL;
+ : LONG_LITERAL
+ | integer_literal
+ | SHORT_LITERAL
+ | BYTE_LITERAL
+ | float_literal
+ | CHAR_LITERAL
+ | BOOL_LITERAL;
fixed_literal returns[int size]
- : integer_literal {$size = 4;}
- | LONG_LITERAL {$size = 8;}
- | SHORT_LITERAL {$size = 2;}
- | BYTE_LITERAL {$size = 1;}
- | float_literal {$size = 4;}
- | double_literal {$size = 8;}
- | CHAR_LITERAL {$size = 2;}
- | BOOL_LITERAL {$size = 1;};
+ : integer_literal {$size = 4;}
+ | LONG_LITERAL {$size = 8;}
+ | SHORT_LITERAL {$size = 2;}
+ | BYTE_LITERAL {$size = 1;}
+ | float_literal {$size = 4;}
+ | double_literal {$size = 8;}
+ | CHAR_LITERAL {$size = 2;}
+ | BOOL_LITERAL {$size = 1;};
array_literal
- : OPEN_BRACE (literal (COMMA literal)* | ) CLOSE_BRACE
- -> ^(I_ENCODED_ARRAY[$start, "I_ENCODED_ARRAY"] literal*);
+ : OPEN_BRACE (literal (COMMA literal)* | ) CLOSE_BRACE
+ -> ^(I_ENCODED_ARRAY[$start, "I_ENCODED_ARRAY"] literal*);
annotation_element
- : simple_name EQUAL literal
- -> ^(I_ANNOTATION_ELEMENT[$start, "I_ANNOTATION_ELEMENT"] simple_name literal);
+ : simple_name EQUAL literal
+ -> ^(I_ANNOTATION_ELEMENT[$start, "I_ANNOTATION_ELEMENT"] simple_name literal);
annotation
- : ANNOTATION_DIRECTIVE ANNOTATION_VISIBILITY CLASS_DESCRIPTOR
- annotation_element* END_ANNOTATION_DIRECTIVE
- -> ^(I_ANNOTATION[$start, "I_ANNOTATION"] ANNOTATION_VISIBILITY ^(I_SUBANNOTATION[$start, "I_SUBANNOTATION"] CLASS_DESCRIPTOR annotation_element*));
+ : ANNOTATION_DIRECTIVE ANNOTATION_VISIBILITY CLASS_DESCRIPTOR
+ annotation_element* END_ANNOTATION_DIRECTIVE
+ -> ^(I_ANNOTATION[$start, "I_ANNOTATION"] ANNOTATION_VISIBILITY ^(I_SUBANNOTATION[$start, "I_SUBANNOTATION"] CLASS_DESCRIPTOR annotation_element*));
subannotation
- : SUBANNOTATION_DIRECTIVE CLASS_DESCRIPTOR annotation_element* END_SUBANNOTATION_DIRECTIVE
- -> ^(I_SUBANNOTATION[$start, "I_SUBANNOTATION"] CLASS_DESCRIPTOR annotation_element*);
+ : SUBANNOTATION_DIRECTIVE CLASS_DESCRIPTOR annotation_element* END_SUBANNOTATION_DIRECTIVE
+ -> ^(I_SUBANNOTATION[$start, "I_SUBANNOTATION"] CLASS_DESCRIPTOR annotation_element*);
enum_literal
- : ENUM_DIRECTIVE reference_type_descriptor ARROW simple_name COLON reference_type_descriptor
- -> ^(I_ENCODED_ENUM reference_type_descriptor simple_name reference_type_descriptor);
+ : ENUM_DIRECTIVE reference_type_descriptor ARROW simple_name COLON reference_type_descriptor
+ -> ^(I_ENCODED_ENUM reference_type_descriptor simple_name reference_type_descriptor);
type_field_method_literal
- : reference_type_descriptor
- ( ARROW
- ( simple_name COLON nonvoid_type_descriptor -> ^(I_ENCODED_FIELD reference_type_descriptor simple_name nonvoid_type_descriptor)
- | method_name method_prototype -> ^(I_ENCODED_METHOD reference_type_descriptor method_name method_prototype)
- )
- | -> reference_type_descriptor
- )
- | PRIMITIVE_TYPE
- | VOID_TYPE;
+ : reference_type_descriptor
+ ( ARROW
+ ( simple_name COLON nonvoid_type_descriptor -> ^(I_ENCODED_FIELD reference_type_descriptor simple_name nonvoid_type_descriptor)
+ | method_name method_prototype -> ^(I_ENCODED_METHOD reference_type_descriptor method_name method_prototype)
+ )
+ | -> reference_type_descriptor
+ )
+ | PRIMITIVE_TYPE
+ | VOID_TYPE;
fully_qualified_method
- : reference_type_descriptor ARROW method_name method_prototype
- -> reference_type_descriptor method_name method_prototype;
+ : reference_type_descriptor ARROW method_name method_prototype
+ -> reference_type_descriptor method_name method_prototype;
fully_qualified_field
- : reference_type_descriptor ARROW simple_name COLON nonvoid_type_descriptor
- -> reference_type_descriptor simple_name nonvoid_type_descriptor;
+ : reference_type_descriptor ARROW simple_name COLON nonvoid_type_descriptor
+ -> reference_type_descriptor simple_name nonvoid_type_descriptor;
label
- : COLON simple_name -> ^(I_LABEL[$COLON, "I_LABEL"] simple_name I_ADDRESS[$start, Integer.toString($method::currentAddress)]);
+ : COLON simple_name -> ^(I_LABEL[$COLON, "I_LABEL"] simple_name I_ADDRESS[$start, Integer.toString($method::currentAddress)]);
label_ref_or_offset
- : COLON simple_name -> simple_name
- | OFFSET
- | NEGATIVE_INTEGER_LITERAL -> OFFSET[$NEGATIVE_INTEGER_LITERAL];
+ : COLON simple_name -> simple_name
+ | OFFSET
+ | NEGATIVE_INTEGER_LITERAL -> OFFSET[$NEGATIVE_INTEGER_LITERAL];
register_list
- : REGISTER (COMMA REGISTER)* -> ^(I_REGISTER_LIST[$start, "I_REGISTER_LIST"] REGISTER*)
- | ->^(I_REGISTER_LIST[$start, "I_REGISTER_LIST"]);
+ : REGISTER (COMMA REGISTER)* -> ^(I_REGISTER_LIST[$start, "I_REGISTER_LIST"] REGISTER*)
+ | ->^(I_REGISTER_LIST[$start, "I_REGISTER_LIST"]);
register_range
- : (startreg=REGISTER (DOTDOT endreg=REGISTER)?)? -> ^(I_REGISTER_RANGE[$start, "I_REGISTER_RANGE"] $startreg? $endreg?);
+ : (startreg=REGISTER (DOTDOT endreg=REGISTER)?)? -> ^(I_REGISTER_RANGE[$start, "I_REGISTER_RANGE"] $startreg? $endreg?);
verification_error_reference
- : CLASS_DESCRIPTOR | fully_qualified_field | fully_qualified_method;
+ : CLASS_DESCRIPTOR | fully_qualified_field | fully_qualified_method;
catch_directive
- : CATCH_DIRECTIVE nonvoid_type_descriptor OPEN_BRACE from=label_ref_or_offset DOTDOT to=label_ref_or_offset CLOSE_BRACE using=label_ref_or_offset
- -> ^(I_CATCH[$start, "I_CATCH"] I_ADDRESS[$start, Integer.toString($method::currentAddress)] nonvoid_type_descriptor $from $to $using);
+ : CATCH_DIRECTIVE nonvoid_type_descriptor OPEN_BRACE from=label_ref_or_offset DOTDOT to=label_ref_or_offset CLOSE_BRACE using=label_ref_or_offset
+ -> ^(I_CATCH[$start, "I_CATCH"] I_ADDRESS[$start, Integer.toString($method::currentAddress)] nonvoid_type_descriptor $from $to $using);
catchall_directive
- : CATCHALL_DIRECTIVE OPEN_BRACE from=label_ref_or_offset DOTDOT to=label_ref_or_offset CLOSE_BRACE using=label_ref_or_offset
- -> ^(I_CATCHALL[$start, "I_CATCHALL"] I_ADDRESS[$start, Integer.toString($method::currentAddress)] $from $to $using);
+ : CATCHALL_DIRECTIVE OPEN_BRACE from=label_ref_or_offset DOTDOT to=label_ref_or_offset CLOSE_BRACE using=label_ref_or_offset
+ -> ^(I_CATCHALL[$start, "I_CATCHALL"] I_ADDRESS[$start, Integer.toString($method::currentAddress)] $from $to $using);
/*When there are annotations immediately after a parameter definition, we don't know whether they are parameter annotations
or method annotations until we determine if there is an .end parameter directive. In either case, we still "consume" and parse
the annotations. If it turns out that they are parameter annotations, we include them in the I_PARAMETER AST. Otherwise, we
add them to the $statements_and_directives::methodAnnotations list*/
parameter_directive
- @init {List<CommonTree> annotations = new ArrayList<CommonTree>();}
- : PARAMETER_DIRECTIVE
- STRING_LITERAL?
- ({input.LA(1) == ANNOTATION_DIRECTIVE}? annotation {annotations.add($annotation.tree);})*
+ @init {List<CommonTree> annotations = new ArrayList<CommonTree>();}
+ : PARAMETER_DIRECTIVE
+ STRING_LITERAL?
+ ({input.LA(1) == ANNOTATION_DIRECTIVE}? annotation {annotations.add($annotation.tree);})*
- ( END_PARAMETER_DIRECTIVE
- -> ^(I_PARAMETER[$start, "I_PARAMETER"] STRING_LITERAL? ^(I_ANNOTATIONS annotation*))
- | /*epsilon*/ {$statements_and_directives::methodAnnotations.addAll(annotations);}
- -> ^(I_PARAMETER[$start, "I_PARAMETER"] STRING_LITERAL? ^(I_ANNOTATIONS))
- );
+ ( END_PARAMETER_DIRECTIVE
+ -> ^(I_PARAMETER[$start, "I_PARAMETER"] STRING_LITERAL? ^(I_ANNOTATIONS annotation*))
+ | /*epsilon*/ {$statements_and_directives::methodAnnotations.addAll(annotations);}
+ -> ^(I_PARAMETER[$start, "I_PARAMETER"] STRING_LITERAL? ^(I_ANNOTATIONS))
+ );
ordered_debug_directive
- : line_directive
- | local_directive
- | end_local_directive
- | restart_local_directive
- | prologue_directive
- | epilogue_directive
- | source_directive;
+ : line_directive
+ | local_directive
+ | end_local_directive
+ | restart_local_directive
+ | prologue_directive
+ | epilogue_directive
+ | source_directive;
line_directive
- : LINE_DIRECTIVE integral_literal
- -> ^(I_LINE integral_literal I_ADDRESS[$start, Integer.toString($method::currentAddress)]);
+ : LINE_DIRECTIVE integral_literal
+ -> ^(I_LINE integral_literal I_ADDRESS[$start, Integer.toString($method::currentAddress)]);
local_directive
- : LOCAL_DIRECTIVE REGISTER COMMA simple_name COLON nonvoid_type_descriptor (COMMA STRING_LITERAL)?
- -> ^(I_LOCAL[$start, "I_LOCAL"] REGISTER simple_name nonvoid_type_descriptor STRING_LITERAL? I_ADDRESS[$start, Integer.toString($method::currentAddress)]);
+ : LOCAL_DIRECTIVE REGISTER COMMA simple_name COLON nonvoid_type_descriptor (COMMA STRING_LITERAL)?
+ -> ^(I_LOCAL[$start, "I_LOCAL"] REGISTER simple_name nonvoid_type_descriptor STRING_LITERAL? I_ADDRESS[$start, Integer.toString($method::currentAddress)]);
end_local_directive
- : END_LOCAL_DIRECTIVE REGISTER
- -> ^(I_END_LOCAL[$start, "I_END_LOCAL"] REGISTER I_ADDRESS[$start, Integer.toString($method::currentAddress)]);
+ : END_LOCAL_DIRECTIVE REGISTER
+ -> ^(I_END_LOCAL[$start, "I_END_LOCAL"] REGISTER I_ADDRESS[$start, Integer.toString($method::currentAddress)]);
restart_local_directive
- : RESTART_LOCAL_DIRECTIVE REGISTER
- -> ^(I_RESTART_LOCAL[$start, "I_RESTART_LOCAL"] REGISTER I_ADDRESS[$start, Integer.toString($method::currentAddress)]);
+ : RESTART_LOCAL_DIRECTIVE REGISTER
+ -> ^(I_RESTART_LOCAL[$start, "I_RESTART_LOCAL"] REGISTER I_ADDRESS[$start, Integer.toString($method::currentAddress)]);
prologue_directive
- : PROLOGUE_DIRECTIVE
- -> ^(I_PROLOGUE[$start, "I_PROLOGUE"] I_ADDRESS[$start, Integer.toString($method::currentAddress)]);
+ : PROLOGUE_DIRECTIVE
+ -> ^(I_PROLOGUE[$start, "I_PROLOGUE"] I_ADDRESS[$start, Integer.toString($method::currentAddress)]);
epilogue_directive
- : EPILOGUE_DIRECTIVE
- -> ^(I_EPILOGUE[$start, "I_EPILOGUE"] I_ADDRESS[$start, Integer.toString($method::currentAddress)]);
+ : EPILOGUE_DIRECTIVE
+ -> ^(I_EPILOGUE[$start, "I_EPILOGUE"] I_ADDRESS[$start, Integer.toString($method::currentAddress)]);
source_directive
- : SOURCE_DIRECTIVE STRING_LITERAL
- -> ^(I_SOURCE[$start, "I_SOURCE"] STRING_LITERAL I_ADDRESS[$start, Integer.toString($method::currentAddress)]);
+ : SOURCE_DIRECTIVE STRING_LITERAL
+ -> ^(I_SOURCE[$start, "I_SOURCE"] STRING_LITERAL I_ADDRESS[$start, Integer.toString($method::currentAddress)]);
instruction_format12x
- : INSTRUCTION_FORMAT12x
- | INSTRUCTION_FORMAT12x_OR_ID -> INSTRUCTION_FORMAT12x[$INSTRUCTION_FORMAT12x_OR_ID];
+ : INSTRUCTION_FORMAT12x
+ | INSTRUCTION_FORMAT12x_OR_ID -> INSTRUCTION_FORMAT12x[$INSTRUCTION_FORMAT12x_OR_ID];
instruction_format22s
- : INSTRUCTION_FORMAT22s
- | INSTRUCTION_FORMAT22s_OR_ID -> INSTRUCTION_FORMAT22s[$INSTRUCTION_FORMAT22s_OR_ID];
+ : INSTRUCTION_FORMAT22s
+ | INSTRUCTION_FORMAT22s_OR_ID -> INSTRUCTION_FORMAT22s[$INSTRUCTION_FORMAT22s_OR_ID];
instruction_format31i
- : INSTRUCTION_FORMAT31i
- | INSTRUCTION_FORMAT31i_OR_ID -> INSTRUCTION_FORMAT31i[$INSTRUCTION_FORMAT31i_OR_ID];
+ : INSTRUCTION_FORMAT31i
+ | INSTRUCTION_FORMAT31i_OR_ID -> INSTRUCTION_FORMAT31i[$INSTRUCTION_FORMAT31i_OR_ID];
instruction returns [int size]
- : insn_format10t { $size = $insn_format10t.size; }
- | insn_format10x { $size = $insn_format10x.size; }
- | insn_format10x_odex { $size = $insn_format10x_odex.size; }
- | insn_format11n { $size = $insn_format11n.size; }
- | insn_format11x { $size = $insn_format11x.size; }
- | insn_format12x { $size = $insn_format12x.size; }
- | insn_format20bc { $size = $insn_format20bc.size; }
- | insn_format20t { $size = $insn_format20t.size; }
- | insn_format21c_field { $size = $insn_format21c_field.size; }
- | insn_format21c_field_odex { $size = $insn_format21c_field_odex.size; }
- | insn_format21c_string { $size = $insn_format21c_string.size; }
- | insn_format21c_type { $size = $insn_format21c_type.size; }
- | insn_format21h { $size = $insn_format21h.size; }
- | insn_format21s { $size = $insn_format21s.size; }
- | insn_format21t { $size = $insn_format21t.size; }
- | insn_format22b { $size = $insn_format22b.size; }
- | insn_format22c_field { $size = $insn_format22c_field.size; }
- | insn_format22c_field_odex { $size = $insn_format22c_field_odex.size; }
- | insn_format22c_type { $size = $insn_format22c_type.size; }
- | insn_format22cs_field { $size = $insn_format22cs_field.size; }
- | insn_format22s { $size = $insn_format22s.size; }
- | insn_format22t { $size = $insn_format22t.size; }
- | insn_format22x { $size = $insn_format22x.size; }
- | insn_format23x { $size = $insn_format23x.size; }
- | insn_format30t { $size = $insn_format30t.size; }
- | insn_format31c { $size = $insn_format31c.size; }
- | insn_format31i { $size = $insn_format31i.size; }
- | insn_format31t { $size = $insn_format31t.size; }
- | insn_format32x { $size = $insn_format32x.size; }
- | insn_format35c_method { $size = $insn_format35c_method.size; }
- | insn_format35c_type { $size = $insn_format35c_type.size; }
- | insn_format35c_method_odex { $size = $insn_format35c_method_odex.size; }
- | insn_format35mi_method { $size = $insn_format35mi_method.size; }
- | insn_format35ms_method { $size = $insn_format35ms_method.size; }
- | insn_format3rc_method { $size = $insn_format3rc_method.size; }
- | insn_format3rc_method_odex { $size = $insn_format3rc_method_odex.size; }
- | insn_format3rc_type { $size = $insn_format3rc_type.size; }
- | insn_format3rmi_method { $size = $insn_format3rmi_method.size; }
- | insn_format3rms_method { $size = $insn_format3rms_method.size; }
- | insn_format51l { $size = $insn_format51l.size; }
- | insn_array_data_directive { $size = $insn_array_data_directive.size; }
- | insn_packed_switch_directive { $size = $insn_packed_switch_directive.size; }
- | insn_sparse_switch_directive { $size = $insn_sparse_switch_directive.size; };
+ : insn_format10t { $size = $insn_format10t.size; }
+ | insn_format10x { $size = $insn_format10x.size; }
+ | insn_format10x_odex { $size = $insn_format10x_odex.size; }
+ | insn_format11n { $size = $insn_format11n.size; }
+ | insn_format11x { $size = $insn_format11x.size; }
+ | insn_format12x { $size = $insn_format12x.size; }
+ | insn_format20bc { $size = $insn_format20bc.size; }
+ | insn_format20t { $size = $insn_format20t.size; }
+ | insn_format21c_field { $size = $insn_format21c_field.size; }
+ | insn_format21c_field_odex { $size = $insn_format21c_field_odex.size; }
+ | insn_format21c_string { $size = $insn_format21c_string.size; }
+ | insn_format21c_type { $size = $insn_format21c_type.size; }
+ | insn_format21h { $size = $insn_format21h.size; }
+ | insn_format21s { $size = $insn_format21s.size; }
+ | insn_format21t { $size = $insn_format21t.size; }
+ | insn_format22b { $size = $insn_format22b.size; }
+ | insn_format22c_field { $size = $insn_format22c_field.size; }
+ | insn_format22c_field_odex { $size = $insn_format22c_field_odex.size; }
+ | insn_format22c_type { $size = $insn_format22c_type.size; }
+ | insn_format22cs_field { $size = $insn_format22cs_field.size; }
+ | insn_format22s { $size = $insn_format22s.size; }
+ | insn_format22t { $size = $insn_format22t.size; }
+ | insn_format22x { $size = $insn_format22x.size; }
+ | insn_format23x { $size = $insn_format23x.size; }
+ | insn_format30t { $size = $insn_format30t.size; }
+ | insn_format31c { $size = $insn_format31c.size; }
+ | insn_format31i { $size = $insn_format31i.size; }
+ | insn_format31t { $size = $insn_format31t.size; }
+ | insn_format32x { $size = $insn_format32x.size; }
+ | insn_format35c_method { $size = $insn_format35c_method.size; }
+ | insn_format35c_type { $size = $insn_format35c_type.size; }
+ | insn_format35c_method_odex { $size = $insn_format35c_method_odex.size; }
+ | insn_format35mi_method { $size = $insn_format35mi_method.size; }
+ | insn_format35ms_method { $size = $insn_format35ms_method.size; }
+ | insn_format3rc_method { $size = $insn_format3rc_method.size; }
+ | insn_format3rc_method_odex { $size = $insn_format3rc_method_odex.size; }
+ | insn_format3rc_type { $size = $insn_format3rc_type.size; }
+ | insn_format3rmi_method { $size = $insn_format3rmi_method.size; }
+ | insn_format3rms_method { $size = $insn_format3rms_method.size; }
+ | insn_format51l { $size = $insn_format51l.size; }
+ | insn_array_data_directive { $size = $insn_array_data_directive.size; }
+ | insn_packed_switch_directive { $size = $insn_packed_switch_directive.size; }
+ | insn_sparse_switch_directive { $size = $insn_sparse_switch_directive.size; };
insn_format10t returns [int size]
- : //e.g. goto endloop:
- //e.g. goto +3
- INSTRUCTION_FORMAT10t label_ref_or_offset {$size = Format.Format10t.size;}
- -> ^(I_STATEMENT_FORMAT10t[$start, "I_STATEMENT_FORMAT10t"] INSTRUCTION_FORMAT10t label_ref_or_offset);
+ : //e.g. goto endloop:
+ //e.g. goto +3
+ INSTRUCTION_FORMAT10t label_ref_or_offset {$size = Format.Format10t.size;}
+ -> ^(I_STATEMENT_FORMAT10t[$start, "I_STATEMENT_FORMAT10t"] INSTRUCTION_FORMAT10t label_ref_or_offset);
insn_format10x returns [int size]
- : //e.g. return-void
- INSTRUCTION_FORMAT10x {$size = Format.Format10x.size;}
- -> ^(I_STATEMENT_FORMAT10x[$start, "I_STATEMENT_FORMAT10x"] INSTRUCTION_FORMAT10x);
+ : //e.g. return-void
+ INSTRUCTION_FORMAT10x {$size = Format.Format10x.size;}
+ -> ^(I_STATEMENT_FORMAT10x[$start, "I_STATEMENT_FORMAT10x"] INSTRUCTION_FORMAT10x);
insn_format10x_odex returns [int size]
- : //e.g. return-void-barrier
- INSTRUCTION_FORMAT10x_ODEX {$size = Format.Format10x.size;}
- {
- throwOdexedInstructionException(input, $INSTRUCTION_FORMAT10x_ODEX.text);
- };
+ : //e.g. return-void-barrier
+ INSTRUCTION_FORMAT10x_ODEX {$size = Format.Format10x.size;}
+ {
+ throwOdexedInstructionException(input, $INSTRUCTION_FORMAT10x_ODEX.text);
+ };
insn_format11n returns [int size]
- : //e.g. const/4 v0, 5
- INSTRUCTION_FORMAT11n REGISTER COMMA integral_literal {$size = Format.Format11n.size;}
- -> ^(I_STATEMENT_FORMAT11n[$start, "I_STATEMENT_FORMAT11n"] INSTRUCTION_FORMAT11n REGISTER integral_literal);
+ : //e.g. const/4 v0, 5
+ INSTRUCTION_FORMAT11n REGISTER COMMA integral_literal {$size = Format.Format11n.size;}
+ -> ^(I_STATEMENT_FORMAT11n[$start, "I_STATEMENT_FORMAT11n"] INSTRUCTION_FORMAT11n REGISTER integral_literal);
insn_format11x returns [int size]
- : //e.g. move-result-object v1
- INSTRUCTION_FORMAT11x REGISTER {$size = Format.Format11x.size;}
- -> ^(I_STATEMENT_FORMAT11x[$start, "I_STATEMENT_FORMAT11x"] INSTRUCTION_FORMAT11x REGISTER);
+ : //e.g. move-result-object v1
+ INSTRUCTION_FORMAT11x REGISTER {$size = Format.Format11x.size;}
+ -> ^(I_STATEMENT_FORMAT11x[$start, "I_STATEMENT_FORMAT11x"] INSTRUCTION_FORMAT11x REGISTER);
insn_format12x returns [int size]
- : //e.g. move v1 v2
- instruction_format12x REGISTER COMMA REGISTER {$size = Format.Format12x.size;}
- -> ^(I_STATEMENT_FORMAT12x[$start, "I_STATEMENT_FORMAT12x"] instruction_format12x REGISTER REGISTER);
+ : //e.g. move v1 v2
+ instruction_format12x REGISTER COMMA REGISTER {$size = Format.Format12x.size;}
+ -> ^(I_STATEMENT_FORMAT12x[$start, "I_STATEMENT_FORMAT12x"] instruction_format12x REGISTER REGISTER);
insn_format20bc returns [int size]
- : //e.g. throw-verification-error generic-error, Lsome/class;
- INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE COMMA verification_error_reference {$size += Format.Format20bc.size;}
- {
- if (!allowOdex || Opcode.getOpcodeByName($INSTRUCTION_FORMAT20bc.text) == null || apiLevel >= 14) {
- throwOdexedInstructionException(input, $INSTRUCTION_FORMAT20bc.text);
- }
- }
- -> ^(I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE verification_error_reference);
- //TODO: check if dalvik has a jumbo version of throw-verification-error
+ : //e.g. throw-verification-error generic-error, Lsome/class;
+ INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE COMMA verification_error_reference {$size += Format.Format20bc.size;}
+ {
+ if (!allowOdex || Opcode.getOpcodeByName($INSTRUCTION_FORMAT20bc.text) == null || apiLevel >= 14) {
+ throwOdexedInstructionException(input, $INSTRUCTION_FORMAT20bc.text);
+ }
+ }
+ -> ^(I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE verification_error_reference);
+ //TODO: check if dalvik has a jumbo version of throw-verification-error
insn_format20t returns [int size]
- : //e.g. goto/16 endloop:
- INSTRUCTION_FORMAT20t label_ref_or_offset {$size = Format.Format20t.size;}
- -> ^(I_STATEMENT_FORMAT20t[$start, "I_STATEMENT_FORMAT20t"] INSTRUCTION_FORMAT20t label_ref_or_offset);
+ : //e.g. goto/16 endloop:
+ INSTRUCTION_FORMAT20t label_ref_or_offset {$size = Format.Format20t.size;}
+ -> ^(I_STATEMENT_FORMAT20t[$start, "I_STATEMENT_FORMAT20t"] INSTRUCTION_FORMAT20t label_ref_or_offset);
insn_format21c_field returns [int size]
- : //e.g. sget-object v0, java/lang/System/out LJava/io/PrintStream;
- INSTRUCTION_FORMAT21c_FIELD REGISTER COMMA fully_qualified_field {$size = Format.Format21c.size;}
- -> ^(I_STATEMENT_FORMAT21c_FIELD[$start, "I_STATEMENT_FORMAT21c_FIELD"] INSTRUCTION_FORMAT21c_FIELD REGISTER fully_qualified_field);
+ : //e.g. sget-object v0, java/lang/System/out LJava/io/PrintStream;
+ INSTRUCTION_FORMAT21c_FIELD REGISTER COMMA fully_qualified_field {$size = Format.Format21c.size;}
+ -> ^(I_STATEMENT_FORMAT21c_FIELD[$start, "I_STATEMENT_FORMAT21c_FIELD"] INSTRUCTION_FORMAT21c_FIELD REGISTER fully_qualified_field);
insn_format21c_field_odex returns [int size]
- : //e.g. sget-object-volatile v0, java/lang/System/out LJava/io/PrintStream;
- INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER COMMA fully_qualified_field {$size = Format.Format21c.size;}
- {
- if (!allowOdex || Opcode.getOpcodeByName($INSTRUCTION_FORMAT21c_FIELD_ODEX.text) == null || apiLevel >= 14) {
- throwOdexedInstructionException(input, $INSTRUCTION_FORMAT21c_FIELD_ODEX.text);
- }
- }
- -> ^(I_STATEMENT_FORMAT21c_FIELD[$start, "I_STATEMENT_FORMAT21c_FIELD"] INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER fully_qualified_field);
+ : //e.g. sget-object-volatile v0, java/lang/System/out LJava/io/PrintStream;
+ INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER COMMA fully_qualified_field {$size = Format.Format21c.size;}
+ {
+ if (!allowOdex || Opcode.getOpcodeByName($INSTRUCTION_FORMAT21c_FIELD_ODEX.text) == null || apiLevel >= 14) {
+ throwOdexedInstructionException(input, $INSTRUCTION_FORMAT21c_FIELD_ODEX.text);
+ }
+ }
+ -> ^(I_STATEMENT_FORMAT21c_FIELD[$start, "I_STATEMENT_FORMAT21c_FIELD"] INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER fully_qualified_field);
insn_format21c_string returns [int size]
- : //e.g. const-string v1, "Hello World!"
- INSTRUCTION_FORMAT21c_STRING REGISTER COMMA STRING_LITERAL {$size = Format.Format21c.size;}
- -> ^(I_STATEMENT_FORMAT21c_STRING[$start, "I_STATEMENT_FORMAT21c_STRING"] INSTRUCTION_FORMAT21c_STRING REGISTER STRING_LITERAL);
+ : //e.g. const-string v1, "Hello World!"
+ INSTRUCTION_FORMAT21c_STRING REGISTER COMMA STRING_LITERAL {$size = Format.Format21c.size;}
+ -> ^(I_STATEMENT_FORMAT21c_STRING[$start, "I_STATEMENT_FORMAT21c_STRING"] INSTRUCTION_FORMAT21c_STRING REGISTER STRING_LITERAL);
insn_format21c_type returns [int size]
- : //e.g. const-class v2, Lorg/jf/HelloWorld2/HelloWorld2;
- INSTRUCTION_FORMAT21c_TYPE REGISTER COMMA reference_type_descriptor {$size = Format.Format21c.size;}
- -> ^(I_STATEMENT_FORMAT21c_TYPE[$start, "I_STATEMENT_FORMAT21c"] INSTRUCTION_FORMAT21c_TYPE REGISTER reference_type_descriptor);
+ : //e.g. const-class v2, Lorg/jf/HelloWorld2/HelloWorld2;
+ INSTRUCTION_FORMAT21c_TYPE REGISTER COMMA reference_type_descriptor {$size = Format.Format21c.size;}
+ -> ^(I_STATEMENT_FORMAT21c_TYPE[$start, "I_STATEMENT_FORMAT21c"] INSTRUCTION_FORMAT21c_TYPE REGISTER reference_type_descriptor);
insn_format21h returns [int size]
- : //e.g. const/high16 v1, 1234
- INSTRUCTION_FORMAT21h REGISTER COMMA integral_literal {$size = Format.Format21h.size;}
- -> ^(I_STATEMENT_FORMAT21h[$start, "I_STATEMENT_FORMAT21h"] INSTRUCTION_FORMAT21h REGISTER integral_literal);
+ : //e.g. const/high16 v1, 1234
+ INSTRUCTION_FORMAT21h REGISTER COMMA integral_literal {$size = Format.Format21h.size;}
+ -> ^(I_STATEMENT_FORMAT21h[$start, "I_STATEMENT_FORMAT21h"] INSTRUCTION_FORMAT21h REGISTER integral_literal);
insn_format21s returns [int size]
- : //e.g. const/16 v1, 1234
- INSTRUCTION_FORMAT21s REGISTER COMMA integral_literal {$size = Format.Format21s.size;}
- -> ^(I_STATEMENT_FORMAT21s[$start, "I_STATEMENT_FORMAT21s"] INSTRUCTION_FORMAT21s REGISTER integral_literal);
+ : //e.g. const/16 v1, 1234
+ INSTRUCTION_FORMAT21s REGISTER COMMA integral_literal {$size = Format.Format21s.size;}
+ -> ^(I_STATEMENT_FORMAT21s[$start, "I_STATEMENT_FORMAT21s"] INSTRUCTION_FORMAT21s REGISTER integral_literal);
insn_format21t returns [int size]
- : //e.g. if-eqz v0, endloop:
- INSTRUCTION_FORMAT21t REGISTER COMMA (label_ref_or_offset) {$size = Format.Format21t.size;}
- -> ^(I_STATEMENT_FORMAT21t[$start, "I_STATEMENT_FORMAT21t"] INSTRUCTION_FORMAT21t REGISTER label_ref_or_offset);
+ : //e.g. if-eqz v0, endloop:
+ INSTRUCTION_FORMAT21t REGISTER COMMA (label_ref_or_offset) {$size = Format.Format21t.size;}
+ -> ^(I_STATEMENT_FORMAT21t[$start, "I_STATEMENT_FORMAT21t"] INSTRUCTION_FORMAT21t REGISTER label_ref_or_offset);
insn_format22b returns [int size]
- : //e.g. add-int v0, v1, 123
- INSTRUCTION_FORMAT22b REGISTER COMMA REGISTER COMMA integral_literal {$size = Format.Format22b.size;}
- -> ^(I_STATEMENT_FORMAT22b[$start, "I_STATEMENT_FORMAT22b"] INSTRUCTION_FORMAT22b REGISTER REGISTER integral_literal);
+ : //e.g. add-int v0, v1, 123
+ INSTRUCTION_FORMAT22b REGISTER COMMA REGISTER COMMA integral_literal {$size = Format.Format22b.size;}
+ -> ^(I_STATEMENT_FORMAT22b[$start, "I_STATEMENT_FORMAT22b"] INSTRUCTION_FORMAT22b REGISTER REGISTER integral_literal);
insn_format22c_field returns [int size]
- : //e.g. iput-object v1, v0 org/jf/HelloWorld2/HelloWorld2.helloWorld Ljava/lang/String;
- INSTRUCTION_FORMAT22c_FIELD REGISTER COMMA REGISTER COMMA fully_qualified_field {$size = Format.Format22c.size;}
- -> ^(I_STATEMENT_FORMAT22c_FIELD[$start, "I_STATEMENT_FORMAT22c_FIELD"] INSTRUCTION_FORMAT22c_FIELD REGISTER REGISTER fully_qualified_field);
+ : //e.g. iput-object v1, v0 org/jf/HelloWorld2/HelloWorld2.helloWorld Ljava/lang/String;
+ INSTRUCTION_FORMAT22c_FIELD REGISTER COMMA REGISTER COMMA fully_qualified_field {$size = Format.Format22c.size;}
+ -> ^(I_STATEMENT_FORMAT22c_FIELD[$start, "I_STATEMENT_FORMAT22c_FIELD"] INSTRUCTION_FORMAT22c_FIELD REGISTER REGISTER fully_qualified_field);
insn_format22c_field_odex returns [int size]
- : //e.g. iput-object-volatile v1, v0 org/jf/HelloWorld2/HelloWorld2.helloWorld Ljava/lang/String;
- INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER COMMA REGISTER COMMA fully_qualified_field {$size = Format.Format22c.size;}
- {
- if (!allowOdex || Opcode.getOpcodeByName($INSTRUCTION_FORMAT22c_FIELD_ODEX.text) == null || apiLevel >= 14) {
- throwOdexedInstructionException(input, $INSTRUCTION_FORMAT22c_FIELD_ODEX.text);
- }
- }
- -> ^(I_STATEMENT_FORMAT22c_FIELD[$start, "I_STATEMENT_FORMAT22c_FIELD"] INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER REGISTER fully_qualified_field);
+ : //e.g. iput-object-volatile v1, v0 org/jf/HelloWorld2/HelloWorld2.helloWorld Ljava/lang/String;
+ INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER COMMA REGISTER COMMA fully_qualified_field {$size = Format.Format22c.size;}
+ {
+ if (!allowOdex || Opcode.getOpcodeByName($INSTRUCTION_FORMAT22c_FIELD_ODEX.text) == null || apiLevel >= 14) {
+ throwOdexedInstructionException(input, $INSTRUCTION_FORMAT22c_FIELD_ODEX.text);
+ }
+ }
+ -> ^(I_STATEMENT_FORMAT22c_FIELD[$start, "I_STATEMENT_FORMAT22c_FIELD"] INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER REGISTER fully_qualified_field);
insn_format22c_type returns [int size]
- : //e.g. instance-of v0, v1, Ljava/lang/String;
- INSTRUCTION_FORMAT22c_TYPE REGISTER COMMA REGISTER COMMA nonvoid_type_descriptor {$size = Format.Format22c.size;}
- -> ^(I_STATEMENT_FORMAT22c_TYPE[$start, "I_STATEMENT_FORMAT22c_TYPE"] INSTRUCTION_FORMAT22c_TYPE REGISTER REGISTER nonvoid_type_descriptor);
+ : //e.g. instance-of v0, v1, Ljava/lang/String;
+ INSTRUCTION_FORMAT22c_TYPE REGISTER COMMA REGISTER COMMA nonvoid_type_descriptor {$size = Format.Format22c.size;}
+ -> ^(I_STATEMENT_FORMAT22c_TYPE[$start, "I_STATEMENT_FORMAT22c_TYPE"] INSTRUCTION_FORMAT22c_TYPE REGISTER REGISTER nonvoid_type_descriptor);
insn_format22cs_field returns [int size]
- : //e.g. iget-quick v0, v1, field@0xc
- INSTRUCTION_FORMAT22cs_FIELD REGISTER COMMA REGISTER COMMA FIELD_OFFSET
- {
- throwOdexedInstructionException(input, $INSTRUCTION_FORMAT22cs_FIELD.text);
- };
+ : //e.g. iget-quick v0, v1, field@0xc
+ INSTRUCTION_FORMAT22cs_FIELD REGISTER COMMA REGISTER COMMA FIELD_OFFSET
+ {
+ throwOdexedInstructionException(input, $INSTRUCTION_FORMAT22cs_FIELD.text);
+ };
insn_format22s returns [int size]
- : //e.g. add-int/lit16 v0, v1, 12345
- instruction_format22s REGISTER COMMA REGISTER COMMA integral_literal {$size = Format.Format22s.size;}
- -> ^(I_STATEMENT_FORMAT22s[$start, "I_STATEMENT_FORMAT22s"] instruction_format22s REGISTER REGISTER integral_literal);
+ : //e.g. add-int/lit16 v0, v1, 12345
+ instruction_format22s REGISTER COMMA REGISTER COMMA integral_literal {$size = Format.Format22s.size;}
+ -> ^(I_STATEMENT_FORMAT22s[$start, "I_STATEMENT_FORMAT22s"] instruction_format22s REGISTER REGISTER integral_literal);
insn_format22t returns [int size]
- : //e.g. if-eq v0, v1, endloop:
- INSTRUCTION_FORMAT22t REGISTER COMMA REGISTER COMMA label_ref_or_offset {$size = Format.Format22t.size;}
- -> ^(I_STATEMENT_FORMAT22t[$start, "I_STATEMENT_FFORMAT22t"] INSTRUCTION_FORMAT22t REGISTER REGISTER label_ref_or_offset);
+ : //e.g. if-eq v0, v1, endloop:
+ INSTRUCTION_FORMAT22t REGISTER COMMA REGISTER COMMA label_ref_or_offset {$size = Format.Format22t.size;}
+ -> ^(I_STATEMENT_FORMAT22t[$start, "I_STATEMENT_FFORMAT22t"] INSTRUCTION_FORMAT22t REGISTER REGISTER label_ref_or_offset);
insn_format22x returns [int size]
- : //e.g. move/from16 v1, v1234
- INSTRUCTION_FORMAT22x REGISTER COMMA REGISTER {$size = Format.Format22x.size;}
- -> ^(I_STATEMENT_FORMAT22x[$start, "I_STATEMENT_FORMAT22x"] INSTRUCTION_FORMAT22x REGISTER REGISTER);
+ : //e.g. move/from16 v1, v1234
+ INSTRUCTION_FORMAT22x REGISTER COMMA REGISTER {$size = Format.Format22x.size;}
+ -> ^(I_STATEMENT_FORMAT22x[$start, "I_STATEMENT_FORMAT22x"] INSTRUCTION_FORMAT22x REGISTER REGISTER);
insn_format23x returns [int size]
- : //e.g. add-int v1, v2, v3
- INSTRUCTION_FORMAT23x REGISTER COMMA REGISTER COMMA REGISTER {$size = Format.Format23x.size;}
- -> ^(I_STATEMENT_FORMAT23x[$start, "I_STATEMENT_FORMAT23x"] INSTRUCTION_FORMAT23x REGISTER REGISTER REGISTER);
+ : //e.g. add-int v1, v2, v3
+ INSTRUCTION_FORMAT23x REGISTER COMMA REGISTER COMMA REGISTER {$size = Format.Format23x.size;}
+ -> ^(I_STATEMENT_FORMAT23x[$start, "I_STATEMENT_FORMAT23x"] INSTRUCTION_FORMAT23x REGISTER REGISTER REGISTER);
insn_format30t returns [int size]
- : //e.g. goto/32 endloop:
- INSTRUCTION_FORMAT30t label_ref_or_offset {$size = Format.Format30t.size;}
- -> ^(I_STATEMENT_FORMAT30t[$start, "I_STATEMENT_FORMAT30t"] INSTRUCTION_FORMAT30t label_ref_or_offset);
+ : //e.g. goto/32 endloop:
+ INSTRUCTION_FORMAT30t label_ref_or_offset {$size = Format.Format30t.size;}
+ -> ^(I_STATEMENT_FORMAT30t[$start, "I_STATEMENT_FORMAT30t"] INSTRUCTION_FORMAT30t label_ref_or_offset);
insn_format31c returns [int size]
- : //e.g. const-string/jumbo v1 "Hello World!"
- INSTRUCTION_FORMAT31c REGISTER COMMA STRING_LITERAL {$size = Format.Format31c.size;}
- ->^(I_STATEMENT_FORMAT31c[$start, "I_STATEMENT_FORMAT31c"] INSTRUCTION_FORMAT31c REGISTER STRING_LITERAL);
+ : //e.g. const-string/jumbo v1 "Hello World!"
+ INSTRUCTION_FORMAT31c REGISTER COMMA STRING_LITERAL {$size = Format.Format31c.size;}
+ ->^(I_STATEMENT_FORMAT31c[$start, "I_STATEMENT_FORMAT31c"] INSTRUCTION_FORMAT31c REGISTER STRING_LITERAL);
insn_format31i returns [int size]
- : //e.g. const v0, 123456
- instruction_format31i REGISTER COMMA fixed_32bit_literal {$size = Format.Format31i.size;}
- -> ^(I_STATEMENT_FORMAT31i[$start, "I_STATEMENT_FORMAT31i"] instruction_format31i REGISTER fixed_32bit_literal);
+ : //e.g. const v0, 123456
+ instruction_format31i REGISTER COMMA fixed_32bit_literal {$size = Format.Format31i.size;}
+ -> ^(I_STATEMENT_FORMAT31i[$start, "I_STATEMENT_FORMAT31i"] instruction_format31i REGISTER fixed_32bit_literal);
insn_format31t returns [int size]
- : //e.g. fill-array-data v0, ArrayData:
- INSTRUCTION_FORMAT31t REGISTER COMMA label_ref_or_offset {$size = Format.Format31t.size;}
- {
- if ($INSTRUCTION_FORMAT31t.text.equals("packed-switch")) {
- CommonTree root = new CommonTree(new CommonToken(I_PACKED_SWITCH_DECLARATION, "I_PACKED_SWITCH_DECLARATION"));
- CommonTree address = new CommonTree(new CommonToken(I_ADDRESS, Integer.toString($method::currentAddress)));
- root.addChild(address);
- root.addChild($label_ref_or_offset.tree.dupNode());
- $statements_and_directives::packedSwitchDeclarations.add(root);
- } else if ($INSTRUCTION_FORMAT31t.text.equals("sparse-switch")) {
- CommonTree root = new CommonTree(new CommonToken(I_SPARSE_SWITCH_DECLARATION, "I_SPARSE_SWITCH_DECLARATION"));
- CommonTree address = new CommonTree(new CommonToken(I_ADDRESS, Integer.toString($method::currentAddress)));
- root.addChild(address);
- root.addChild($label_ref_or_offset.tree.dupNode());
- $statements_and_directives::sparseSwitchDeclarations.add(root);
- }
- }
- -> ^(I_STATEMENT_FORMAT31t[$start, "I_STATEMENT_FORMAT31t"] INSTRUCTION_FORMAT31t REGISTER label_ref_or_offset);
+ : //e.g. fill-array-data v0, ArrayData:
+ INSTRUCTION_FORMAT31t REGISTER COMMA label_ref_or_offset {$size = Format.Format31t.size;}
+ {
+ if ($INSTRUCTION_FORMAT31t.text.equals("packed-switch")) {
+ CommonTree root = new CommonTree(new CommonToken(I_PACKED_SWITCH_DECLARATION, "I_PACKED_SWITCH_DECLARATION"));
+ CommonTree address = new CommonTree(new CommonToken(I_ADDRESS, Integer.toString($method::currentAddress)));
+ root.addChild(address);
+ root.addChild($label_ref_or_offset.tree.dupNode());
+ $statements_and_directives::packedSwitchDeclarations.add(root);
+ } else if ($INSTRUCTION_FORMAT31t.text.equals("sparse-switch")) {
+ CommonTree root = new CommonTree(new CommonToken(I_SPARSE_SWITCH_DECLARATION, "I_SPARSE_SWITCH_DECLARATION"));
+ CommonTree address = new CommonTree(new CommonToken(I_ADDRESS, Integer.toString($method::currentAddress)));
+ root.addChild(address);
+ root.addChild($label_ref_or_offset.tree.dupNode());
+ $statements_and_directives::sparseSwitchDeclarations.add(root);
+ }
+ }
+ -> ^(I_STATEMENT_FORMAT31t[$start, "I_STATEMENT_FORMAT31t"] INSTRUCTION_FORMAT31t REGISTER label_ref_or_offset);
insn_format32x returns [int size]
- : //e.g. move/16 v4567, v1234
- INSTRUCTION_FORMAT32x REGISTER COMMA REGISTER {$size = Format.Format32x.size;}
- -> ^(I_STATEMENT_FORMAT32x[$start, "I_STATEMENT_FORMAT32x"] INSTRUCTION_FORMAT32x REGISTER REGISTER);
+ : //e.g. move/16 v4567, v1234
+ INSTRUCTION_FORMAT32x REGISTER COMMA REGISTER {$size = Format.Format32x.size;}
+ -> ^(I_STATEMENT_FORMAT32x[$start, "I_STATEMENT_FORMAT32x"] INSTRUCTION_FORMAT32x REGISTER REGISTER);
insn_format35c_method returns [int size]
- : //e.g. invoke-virtual {v0,v1} java/io/PrintStream/print(Ljava/lang/Stream;)V
- INSTRUCTION_FORMAT35c_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA fully_qualified_method {$size = Format.Format35c.size;}
- -> ^(I_STATEMENT_FORMAT35c_METHOD[$start, "I_STATEMENT_FORMAT35c_METHOD"] INSTRUCTION_FORMAT35c_METHOD register_list fully_qualified_method);
+ : //e.g. invoke-virtual {v0,v1} java/io/PrintStream/print(Ljava/lang/Stream;)V
+ INSTRUCTION_FORMAT35c_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA fully_qualified_method {$size = Format.Format35c.size;}
+ -> ^(I_STATEMENT_FORMAT35c_METHOD[$start, "I_STATEMENT_FORMAT35c_METHOD"] INSTRUCTION_FORMAT35c_METHOD register_list fully_qualified_method);
insn_format35c_type returns [int size]
- : //e.g. filled-new-array {v0,v1}, I
- INSTRUCTION_FORMAT35c_TYPE OPEN_BRACE register_list CLOSE_BRACE COMMA nonvoid_type_descriptor {$size = Format.Format35c.size;}
- -> ^(I_STATEMENT_FORMAT35c_TYPE[$start, "I_STATEMENT_FORMAT35c_TYPE"] INSTRUCTION_FORMAT35c_TYPE register_list nonvoid_type_descriptor);
+ : //e.g. filled-new-array {v0,v1}, I
+ INSTRUCTION_FORMAT35c_TYPE OPEN_BRACE register_list CLOSE_BRACE COMMA nonvoid_type_descriptor {$size = Format.Format35c.size;}
+ -> ^(I_STATEMENT_FORMAT35c_TYPE[$start, "I_STATEMENT_FORMAT35c_TYPE"] INSTRUCTION_FORMAT35c_TYPE register_list nonvoid_type_descriptor);
insn_format35c_method_odex returns [int size]
- : //e.g. invoke-direct {p0}, Ljava/lang/Object;-><init>()V
- INSTRUCTION_FORMAT35c_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA fully_qualified_method
- {
- throwOdexedInstructionException(input, $INSTRUCTION_FORMAT35c_METHOD_ODEX.text);
- };
+ : //e.g. invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+ INSTRUCTION_FORMAT35c_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA fully_qualified_method
+ {
+ throwOdexedInstructionException(input, $INSTRUCTION_FORMAT35c_METHOD_ODEX.text);
+ };
insn_format35mi_method returns [int size]
- : //e.g. execute-inline {v0, v1}, inline@0x4
- INSTRUCTION_FORMAT35mi_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA INLINE_INDEX
- {
- throwOdexedInstructionException(input, $INSTRUCTION_FORMAT35mi_METHOD.text);
- };
+ : //e.g. execute-inline {v0, v1}, inline@0x4
+ INSTRUCTION_FORMAT35mi_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA INLINE_INDEX
+ {
+ throwOdexedInstructionException(input, $INSTRUCTION_FORMAT35mi_METHOD.text);
+ };
insn_format35ms_method returns [int size]
- : //e.g. invoke-virtual-quick {v0, v1}, vtable@0x4
- INSTRUCTION_FORMAT35ms_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA VTABLE_INDEX
- {
- throwOdexedInstructionException(input, $INSTRUCTION_FORMAT35ms_METHOD.text);
- };
+ : //e.g. invoke-virtual-quick {v0, v1}, vtable@0x4
+ INSTRUCTION_FORMAT35ms_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA VTABLE_INDEX
+ {
+ throwOdexedInstructionException(input, $INSTRUCTION_FORMAT35ms_METHOD.text);
+ };
insn_format3rc_method returns [int size]
- : //e.g. invoke-virtual/range {v25..v26}, java/lang/StringBuilder/append(Ljava/lang/String;)Ljava/lang/StringBuilder;
- INSTRUCTION_FORMAT3rc_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA fully_qualified_method {$size = Format.Format3rc.size;}
- -> ^(I_STATEMENT_FORMAT3rc_METHOD[$start, "I_STATEMENT_FORMAT3rc_METHOD"] INSTRUCTION_FORMAT3rc_METHOD register_range fully_qualified_method);
+ : //e.g. invoke-virtual/range {v25..v26}, java/lang/StringBuilder/append(Ljava/lang/String;)Ljava/lang/StringBuilder;
+ INSTRUCTION_FORMAT3rc_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA fully_qualified_method {$size = Format.Format3rc.size;}
+ -> ^(I_STATEMENT_FORMAT3rc_METHOD[$start, "I_STATEMENT_FORMAT3rc_METHOD"] INSTRUCTION_FORMAT3rc_METHOD register_range fully_qualified_method);
insn_format3rc_method_odex returns [int size]
- : //e.g. invoke-object-init/range {p0}, Ljava/lang/Object;-><init>()V
- INSTRUCTION_FORMAT3rc_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA fully_qualified_method
- {
- throwOdexedInstructionException(input, $INSTRUCTION_FORMAT3rc_METHOD_ODEX.text);
- };
+ : //e.g. invoke-object-init/range {p0}, Ljava/lang/Object;-><init>()V
+ INSTRUCTION_FORMAT3rc_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA fully_qualified_method
+ {
+ throwOdexedInstructionException(input, $INSTRUCTION_FORMAT3rc_METHOD_ODEX.text);
+ };
insn_format3rc_type returns [int size]
- : //e.g. filled-new-array/range {v0..v6}, I
- INSTRUCTION_FORMAT3rc_TYPE OPEN_BRACE register_range CLOSE_BRACE COMMA nonvoid_type_descriptor {$size = Format.Format3rc.size;}
- -> ^(I_STATEMENT_FORMAT3rc_TYPE[$start, "I_STATEMENT_FORMAT3rc_TYPE"] INSTRUCTION_FORMAT3rc_TYPE register_range nonvoid_type_descriptor);
+ : //e.g. filled-new-array/range {v0..v6}, I
+ INSTRUCTION_FORMAT3rc_TYPE OPEN_BRACE register_range CLOSE_BRACE COMMA nonvoid_type_descriptor {$size = Format.Format3rc.size;}
+ -> ^(I_STATEMENT_FORMAT3rc_TYPE[$start, "I_STATEMENT_FORMAT3rc_TYPE"] INSTRUCTION_FORMAT3rc_TYPE register_range nonvoid_type_descriptor);
insn_format3rmi_method returns [int size]
- : //e.g. execute-inline/range {v0 .. v10}, inline@0x14
- INSTRUCTION_FORMAT3rmi_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA INLINE_INDEX
- {
- throwOdexedInstructionException(input, $INSTRUCTION_FORMAT3rmi_METHOD.text);
- };
+ : //e.g. execute-inline/range {v0 .. v10}, inline@0x14
+ INSTRUCTION_FORMAT3rmi_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA INLINE_INDEX
+ {
+ throwOdexedInstructionException(input, $INSTRUCTION_FORMAT3rmi_METHOD.text);
+ };
insn_format3rms_method returns [int size]
- : //e.g. invoke-virtual-quick/range {v0 .. v10}, vtable@0x14
- INSTRUCTION_FORMAT3rms_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA VTABLE_INDEX
- {
- throwOdexedInstructionException(input, $INSTRUCTION_FORMAT3rms_METHOD.text);
- };
+ : //e.g. invoke-virtual-quick/range {v0 .. v10}, vtable@0x14
+ INSTRUCTION_FORMAT3rms_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA VTABLE_INDEX
+ {
+ throwOdexedInstructionException(input, $INSTRUCTION_FORMAT3rms_METHOD.text);
+ };
insn_format51l returns [int size]
- : //e.g. const-wide v0, 5000000000L
- INSTRUCTION_FORMAT51l REGISTER COMMA fixed_literal {$size = Format.Format51l.size;}
- -> ^(I_STATEMENT_FORMAT51l[$start, "I_STATEMENT_FORMAT51l"] INSTRUCTION_FORMAT51l REGISTER fixed_literal);
+ : //e.g. const-wide v0, 5000000000L
+ INSTRUCTION_FORMAT51l REGISTER COMMA fixed_literal {$size = Format.Format51l.size;}
+ -> ^(I_STATEMENT_FORMAT51l[$start, "I_STATEMENT_FORMAT51l"] INSTRUCTION_FORMAT51l REGISTER fixed_literal);
insn_array_data_directive returns [int size]
@init {boolean needsNop = false;}
- : ARRAY_DATA_DIRECTIVE
- {
- if (($method::currentAddress \% 2) != 0) {
- needsNop = true;
- $size = 2;
- } else {
- $size = 0;
- }
- }
+ : ARRAY_DATA_DIRECTIVE
+ {
+ if (($method::currentAddress \% 2) != 0) {
+ needsNop = true;
+ $size = 2;
+ } else {
+ $size = 0;
+ }
+ }
- integral_literal (fixed_literal {$size+=$fixed_literal.size;})* END_ARRAY_DATA_DIRECTIVE
- {$size = (($size + 1)/2)*2 + 8;}
+ integral_literal (fixed_literal {$size+=$fixed_literal.size;})* END_ARRAY_DATA_DIRECTIVE
+ {$size = (($size + 1)/2)*2 + 8;}
- /*add a nop statement before this if needed to force the correct alignment*/
- -> {needsNop}? ^(I_STATEMENT_FORMAT10x[$start, "I_STATEMENT_FORMAT10x"] INSTRUCTION_FORMAT10x[$start, "nop"])
- ^(I_STATEMENT_ARRAY_DATA ^(I_ARRAY_ELEMENT_SIZE integral_literal) ^(I_ARRAY_ELEMENTS fixed_literal*))
+ /*add a nop statement before this if needed to force the correct alignment*/
+ -> {needsNop}? ^(I_STATEMENT_FORMAT10x[$start, "I_STATEMENT_FORMAT10x"] INSTRUCTION_FORMAT10x[$start, "nop"])
+ ^(I_STATEMENT_ARRAY_DATA ^(I_ARRAY_ELEMENT_SIZE integral_literal) ^(I_ARRAY_ELEMENTS fixed_literal*))
- -> ^(I_STATEMENT_ARRAY_DATA[$start, "I_STATEMENT_ARRAY_DATA"] ^(I_ARRAY_ELEMENT_SIZE integral_literal)
- ^(I_ARRAY_ELEMENTS fixed_literal*));
+ -> ^(I_STATEMENT_ARRAY_DATA[$start, "I_STATEMENT_ARRAY_DATA"] ^(I_ARRAY_ELEMENT_SIZE integral_literal)
+ ^(I_ARRAY_ELEMENTS fixed_literal*));
insn_packed_switch_directive returns [int size]
@init {boolean needsNop = false; int targetCount = 0;}
: PACKED_SWITCH_DIRECTIVE
- {
- targetCount = 0;
- if (($method::currentAddress \% 2) != 0) {
- needsNop = true;
- $size = 2;
- } else {
- $size = 0;
- }
- }
+ {
+ targetCount = 0;
+ if (($method::currentAddress \% 2) != 0) {
+ needsNop = true;
+ $size = 2;
+ } else {
+ $size = 0;
+ }
+ }
- fixed_32bit_literal
+ fixed_32bit_literal
- (switch_target += label_ref_or_offset {$size+=4; targetCount++;})*
+ (switch_target += label_ref_or_offset {$size+=4; targetCount++;})*
- END_PACKED_SWITCH_DIRECTIVE {$size = $size + 8;}
+ END_PACKED_SWITCH_DIRECTIVE {$size = $size + 8;}
- /*add a nop statement before this if needed to force the correct alignment*/
- -> {needsNop}? ^(I_STATEMENT_FORMAT10x[$start, "I_STATEMENT_FORMAT10x"] INSTRUCTION_FORMAT10x[$start, "nop"])
- ^(I_STATEMENT_PACKED_SWITCH[$start, "I_STATEMENT_PACKED_SWITCH"]
- ^(I_PACKED_SWITCH_START_KEY[$start, "I_PACKED_SWITCH_START_KEY"] fixed_32bit_literal)
- ^(I_PACKED_SWITCH_TARGETS[$start, "I_PACKED_SWITCH_TARGETS"] I_PACKED_SWITCH_TARGET_COUNT[$start, Integer.toString(targetCount)] $switch_target*)
- )
+ /*add a nop statement before this if needed to force the correct alignment*/
+ -> {needsNop}? ^(I_STATEMENT_FORMAT10x[$start, "I_STATEMENT_FORMAT10x"] INSTRUCTION_FORMAT10x[$start, "nop"])
+ ^(I_STATEMENT_PACKED_SWITCH[$start, "I_STATEMENT_PACKED_SWITCH"]
+ ^(I_PACKED_SWITCH_START_KEY[$start, "I_PACKED_SWITCH_START_KEY"] fixed_32bit_literal)
+ ^(I_PACKED_SWITCH_TARGETS[$start, "I_PACKED_SWITCH_TARGETS"]
+ I_PACKED_SWITCH_TARGET_COUNT[$start, Integer.toString(targetCount)] $switch_target*)
+ )
- -> ^(I_STATEMENT_PACKED_SWITCH[$start, "I_STATEMENT_PACKED_SWITCH"]
- ^(I_PACKED_SWITCH_START_KEY[$start, "I_PACKED_SWITCH_START_KEY"] fixed_32bit_literal)
- ^(I_PACKED_SWITCH_TARGETS[$start, "I_PACKED_SWITCH_TARGETS"] I_PACKED_SWITCH_TARGET_COUNT[$start, Integer.toString(targetCount)] $switch_target*)
- );
+ -> ^(I_STATEMENT_PACKED_SWITCH[$start, "I_STATEMENT_PACKED_SWITCH"]
+ ^(I_PACKED_SWITCH_START_KEY[$start, "I_PACKED_SWITCH_START_KEY"] fixed_32bit_literal)
+ ^(I_PACKED_SWITCH_TARGETS[$start, "I_PACKED_SWITCH_TARGETS"]
+ I_PACKED_SWITCH_TARGET_COUNT[$start, Integer.toString(targetCount)] $switch_target*)
+ );
insn_sparse_switch_directive returns [int size]
@init {boolean needsNop = false; int targetCount = 0;}
- : SPARSE_SWITCH_DIRECTIVE
- {
- targetCount = 0;
- if (($method::currentAddress \% 2) != 0) {
- needsNop = true;
- $size = 2;
- } else {
- $size = 0;
- }
- }
+ : SPARSE_SWITCH_DIRECTIVE
+ {
+ targetCount = 0;
+ if (($method::currentAddress \% 2) != 0) {
+ needsNop = true;
+ $size = 2;
+ } else {
+ $size = 0;
+ }
+ }
- (fixed_32bit_literal ARROW switch_target += label_ref_or_offset {$size += 8; targetCount++;})*
+ (fixed_32bit_literal ARROW switch_target += label_ref_or_offset {$size += 8; targetCount++;})*
- END_SPARSE_SWITCH_DIRECTIVE {$size = $size + 4;}
+ END_SPARSE_SWITCH_DIRECTIVE {$size = $size + 4;}
- /*add a nop statement before this if needed to force the correct alignment*/
- -> {needsNop}? ^(I_STATEMENT_FORMAT10x[$start, "I_STATEMENT_FORMAT10x"] INSTRUCTION_FORMAT10x[$start, "nop"])
- ^(I_STATEMENT_SPARSE_SWITCH[$start, "I_STATEMENT_SPARSE_SWITCH"]
- I_SPARSE_SWITCH_TARGET_COUNT[$start, Integer.toString(targetCount)]
- ^(I_SPARSE_SWITCH_KEYS[$start, "I_SPARSE_SWITCH_KEYS"] fixed_32bit_literal*)
- ^(I_SPARSE_SWITCH_TARGETS $switch_target*))
- -> ^(I_STATEMENT_SPARSE_SWITCH[$start, "I_STATEMENT_SPARSE_SWITCH"]
- I_SPARSE_SWITCH_TARGET_COUNT[$start, Integer.toString(targetCount)]
- ^(I_SPARSE_SWITCH_KEYS[$start, "I_SPARSE_SWITCH_KEYS"] fixed_32bit_literal*)
- ^(I_SPARSE_SWITCH_TARGETS $switch_target*));
\ No newline at end of file
+ /*add a nop statement before this if needed to force the correct alignment*/
+ -> {needsNop}?
+ ^(I_STATEMENT_FORMAT10x[$start, "I_STATEMENT_FORMAT10x"] INSTRUCTION_FORMAT10x[$start, "nop"])
+ ^(I_STATEMENT_SPARSE_SWITCH[$start, "I_STATEMENT_SPARSE_SWITCH"]
+ I_SPARSE_SWITCH_TARGET_COUNT[$start, Integer.toString(targetCount)]
+ ^(I_SPARSE_SWITCH_KEYS[$start, "I_SPARSE_SWITCH_KEYS"] fixed_32bit_literal*)
+ ^(I_SPARSE_SWITCH_TARGETS $switch_target*)
+ )
+
+ -> ^(I_STATEMENT_SPARSE_SWITCH[$start, "I_STATEMENT_SPARSE_SWITCH"]
+ I_SPARSE_SWITCH_TARGET_COUNT[$start, Integer.toString(targetCount)]
+ ^(I_SPARSE_SWITCH_KEYS[$start, "I_SPARSE_SWITCH_KEYS"] fixed_32bit_literal*)
+ ^(I_SPARSE_SWITCH_TARGETS $switch_target*));
\ No newline at end of file
diff --git a/smali/src/main/antlr3/smaliTreeWalker.g b/smali/src/main/antlr3/smaliTreeWalker.g
index 2233859..44c0078 100644
--- a/smali/src/main/antlr3/smaliTreeWalker.g
+++ b/smali/src/main/antlr3/smaliTreeWalker.g
@@ -29,8 +29,8 @@
tree grammar smaliTreeWalker;
options {
- tokenVocab=smaliParser;
- ASTLabelType=CommonTree;
+ tokenVocab=smaliParser;
+ ASTLabelType=CommonTree;
}
@header {
@@ -50,857 +50,858 @@
}
@members {
- public DexFile dexFile;
- public TypeIdItem classType;
+ public DexFile dexFile;
+ public TypeIdItem classType;
- private byte parseRegister_nibble(String register, int totalMethodRegisters, int methodParameterRegisters)
- throws SemanticException {
- //register should be in the format "v12"
- int val = Byte.parseByte(register.substring(1));
- if (register.charAt(0) == 'p') {
- val = totalMethodRegisters - methodParameterRegisters + val;
- }
- if (val >= 2<<4) {
- throw new SemanticException(input, "The maximum allowed register in this context is list of registers is v15");
- }
- //the parser wouldn't have accepted a negative register, i.e. v-1, so we don't have to check for val<0;
- return (byte)val;
- }
+ private byte parseRegister_nibble(String register, int totalMethodRegisters, int methodParameterRegisters)
+ throws SemanticException {
+ //register should be in the format "v12"
+ int val = Byte.parseByte(register.substring(1));
+ if (register.charAt(0) == 'p') {
+ val = totalMethodRegisters - methodParameterRegisters + val;
+ }
+ if (val >= 2<<4) {
+ throw new SemanticException(input, "The maximum allowed register in this context is list of registers is v15");
+ }
+ //the parser wouldn't have accepted a negative register, i.e. v-1, so we don't have to check for val<0;
+ return (byte)val;
+ }
- //return a short, because java's byte is signed
- private short parseRegister_byte(String register, int totalMethodRegisters, int methodParameterRegisters)
- throws SemanticException {
- //register should be in the format "v123"
- int val = Short.parseShort(register.substring(1));
- if (register.charAt(0) == 'p') {
- val = totalMethodRegisters - methodParameterRegisters + val;
- }
- if (val >= 2<<8) {
- throw new SemanticException(input, "The maximum allowed register in this context is v255");
- }
- return (short)val;
- }
+ //return a short, because java's byte is signed
+ private short parseRegister_byte(String register, int totalMethodRegisters, int methodParameterRegisters)
+ throws SemanticException {
+ //register should be in the format "v123"
+ int val = Short.parseShort(register.substring(1));
+ if (register.charAt(0) == 'p') {
+ val = totalMethodRegisters - methodParameterRegisters + val;
+ }
+ if (val >= 2<<8) {
+ throw new SemanticException(input, "The maximum allowed register in this context is v255");
+ }
+ return (short)val;
+ }
- //return an int because java's short is signed
- private int parseRegister_short(String register, int totalMethodRegisters, int methodParameterRegisters)
- throws SemanticException {
- //register should be in the format "v12345"
- int val = Integer.parseInt(register.substring(1));
- if (register.charAt(0) == 'p') {
- val = totalMethodRegisters - methodParameterRegisters + val;
- }
- if (val >= 2<<16) {
- throw new SemanticException(input, "The maximum allowed register in this context is v65535");
- }
- //the parser wouldn't accept a negative register, i.e. v-1, so we don't have to check for val<0;
- return val;
- }
+ //return an int because java's short is signed
+ private int parseRegister_short(String register, int totalMethodRegisters, int methodParameterRegisters)
+ throws SemanticException {
+ //register should be in the format "v12345"
+ int val = Integer.parseInt(register.substring(1));
+ if (register.charAt(0) == 'p') {
+ val = totalMethodRegisters - methodParameterRegisters + val;
+ }
+ if (val >= 2<<16) {
+ throw new SemanticException(input, "The maximum allowed register in this context is v65535");
+ }
+ //the parser wouldn't accept a negative register, i.e. v-1, so we don't have to check for val<0;
+ return val;
+ }
- private static Pattern specialFloatRegex = Pattern.compile("((-)?infinityf)|(nanf)", Pattern.CASE_INSENSITIVE);
- private float parseFloat(String floatString) {
- Matcher m = specialFloatRegex.matcher(floatString);
- if (m.matches()) {
- //got an infinity
- if (m.start(1) != -1) {
- if (m.start(2) != -1) {
- return Float.NEGATIVE_INFINITY;
- } else {
- return Float.POSITIVE_INFINITY;
- }
- } else {
- return Float.NaN;
- }
- }
- return Float.parseFloat(floatString);
- }
+ private static Pattern specialFloatRegex = Pattern.compile("((-)?infinityf)|(nanf)", Pattern.CASE_INSENSITIVE);
+ private float parseFloat(String floatString) {
+ Matcher m = specialFloatRegex.matcher(floatString);
+ if (m.matches()) {
+ //got an infinity
+ if (m.start(1) != -1) {
+ if (m.start(2) != -1) {
+ return Float.NEGATIVE_INFINITY;
+ } else {
+ return Float.POSITIVE_INFINITY;
+ }
+ } else {
+ return Float.NaN;
+ }
+ }
+ return Float.parseFloat(floatString);
+ }
- private static Pattern specialDoubleRegex = Pattern.compile("((-)?infinityd?)|(nand?)", Pattern.CASE_INSENSITIVE);
- private double parseDouble(String doubleString) {
- Matcher m = specialDoubleRegex.matcher(doubleString);
- if (m.matches()) {
- //got an infinity
- if (m.start(1) != -1) {
- if (m.start(2) != -1) {
- return Double.NEGATIVE_INFINITY;
- } else {
- return Double.POSITIVE_INFINITY;
- }
- } else {
- return Double.NaN;
- }
- }
- return Double.parseDouble(doubleString);
- }
+ private static Pattern specialDoubleRegex = Pattern.compile("((-)?infinityd?)|(nand?)", Pattern.CASE_INSENSITIVE);
+ private double parseDouble(String doubleString) {
+ Matcher m = specialDoubleRegex.matcher(doubleString);
+ if (m.matches()) {
+ //got an infinity
+ if (m.start(1) != -1) {
+ if (m.start(2) != -1) {
+ return Double.NEGATIVE_INFINITY;
+ } else {
+ return Double.POSITIVE_INFINITY;
+ }
+ } else {
+ return Double.NaN;
+ }
+ }
+ return Double.parseDouble(doubleString);
+ }
- public String getErrorMessage(RecognitionException e, String[] tokenNames) {
- if ( e instanceof SemanticException ) {
- return e.getMessage();
- } else {
- return super.getErrorMessage(e, tokenNames);
- }
- }
+ public String getErrorMessage(RecognitionException e, String[] tokenNames) {
+ if ( e instanceof SemanticException ) {
+ return e.getMessage();
+ } else {
+ return super.getErrorMessage(e, tokenNames);
+ }
+ }
- public String getErrorHeader(RecognitionException e) {
- return getSourceName()+"["+ e.line+","+e.charPositionInLine+"]";
- }
+ public String getErrorHeader(RecognitionException e) {
+ return getSourceName()+"["+ e.line+","+e.charPositionInLine+"]";
+ }
}
smali_file
- : ^(I_CLASS_DEF header methods fields annotations)
- {
- AnnotationDirectoryItem annotationDirectoryItem = null;
- ClassDefItem classDefItem = null;
- ClassDataItem classDataItem = null;
+ : ^(I_CLASS_DEF header methods fields annotations)
+ {
+ AnnotationDirectoryItem annotationDirectoryItem = null;
+ ClassDefItem classDefItem = null;
+ ClassDataItem classDataItem = null;
- if ( $methods.methodAnnotations != null ||
- $methods.parameterAnnotations != null ||
- $fields.fieldAnnotations != null ||
- $annotations.annotationSetItem != null) {
- annotationDirectoryItem = AnnotationDirectoryItem.internAnnotationDirectoryItem(
- dexFile,
- $annotations.annotationSetItem,
- $fields.fieldAnnotations,
- $methods.methodAnnotations,
- $methods.parameterAnnotations);
- }
+ if ($methods.methodAnnotations != null ||
+ $methods.parameterAnnotations != null ||
+ $fields.fieldAnnotations != null ||
+ $annotations.annotationSetItem != null) {
+ annotationDirectoryItem = AnnotationDirectoryItem.internAnnotationDirectoryItem(
+ dexFile,
+ $annotations.annotationSetItem,
+ $fields.fieldAnnotations,
+ $methods.methodAnnotations,
+ $methods.parameterAnnotations);
+ }
- if ($fields.staticFields.size() != 0 || $fields.instanceFields.size() != 0 ||
- $methods.directMethods.size() != 0 || $methods.virtualMethods.size()!= 0) {
- classDataItem = ClassDataItem.internClassDataItem(dexFile, $fields.staticFields, $fields.instanceFields,
- $methods.directMethods, $methods.virtualMethods);
- }
+ if ($fields.staticFields.size() != 0 || $fields.instanceFields.size() != 0 ||
+ $methods.directMethods.size() != 0 || $methods.virtualMethods.size()!= 0) {
+ classDataItem = ClassDataItem.internClassDataItem(dexFile, $fields.staticFields, $fields.instanceFields,
+ $methods.directMethods, $methods.virtualMethods);
+ }
- classDefItem = ClassDefItem.internClassDefItem(dexFile, $header.classType, $header.accessFlags,
- $header.superType, $header.implementsList, $header.sourceSpec, annotationDirectoryItem,
- classDataItem, $fields.staticFieldInitialValues);
- };
- catch [Exception ex] {
- reportError(new SemanticException(input, ex));
- }
+ classDefItem = ClassDefItem.internClassDefItem(dexFile, $header.classType, $header.accessFlags,
+ $header.superType, $header.implementsList, $header.sourceSpec, annotationDirectoryItem,
+ classDataItem, $fields.staticFieldInitialValues);
+ };
+ catch [Exception ex] {
+ reportError(new SemanticException(input, ex));
+ }
-header returns[TypeIdItem classType, int accessFlags, TypeIdItem superType, TypeListItem implementsList, StringIdItem sourceSpec]
-: class_spec super_spec? implements_list source_spec
- {
- classType = $class_spec.type;
- $classType = classType;
- $accessFlags = $class_spec.accessFlags;
- $superType = $super_spec.type;
- $implementsList = $implements_list.implementsList;
- $sourceSpec = $source_spec.source;
- };
+header returns[TypeIdItem classType, int accessFlags, TypeIdItem superType, TypeListItem implementsList, StringIdItem sourceSpec]
+: class_spec super_spec? implements_list source_spec
+ {
+ classType = $class_spec.type;
+ $classType = classType;
+ $accessFlags = $class_spec.accessFlags;
+ $superType = $super_spec.type;
+ $implementsList = $implements_list.implementsList;
+ $sourceSpec = $source_spec.source;
+ };
class_spec returns[TypeIdItem type, int accessFlags]
- : class_type_descriptor access_list
- {
- $type = $class_type_descriptor.type;
- $accessFlags = $access_list.value;
- };
+ : class_type_descriptor access_list
+ {
+ $type = $class_type_descriptor.type;
+ $accessFlags = $access_list.value;
+ };
super_spec returns[TypeIdItem type]
- : ^(I_SUPER class_type_descriptor)
- {
- $type = $class_type_descriptor.type;
- };
+ : ^(I_SUPER class_type_descriptor)
+ {
+ $type = $class_type_descriptor.type;
+ };
implements_spec returns[TypeIdItem type]
- : ^(I_IMPLEMENTS class_type_descriptor)
- {
- $type = $class_type_descriptor.type;
- };
+ : ^(I_IMPLEMENTS class_type_descriptor)
+ {
+ $type = $class_type_descriptor.type;
+ };
implements_list returns[TypeListItem implementsList]
-@init { List<TypeIdItem> typeList; }
- : {typeList = new LinkedList<TypeIdItem>();}
- (implements_spec {typeList.add($implements_spec.type);} )*
- {
- if (typeList.size() > 0) {
- $implementsList = TypeListItem.internTypeListItem(dexFile, typeList);
- } else {
- $implementsList = null;
- }
- };
+@init { List<TypeIdItem> typeList; }
+ : {typeList = new LinkedList<TypeIdItem>();}
+ (implements_spec {typeList.add($implements_spec.type);} )*
+ {
+ if (typeList.size() > 0) {
+ $implementsList = TypeListItem.internTypeListItem(dexFile, typeList);
+ } else {
+ $implementsList = null;
+ }
+ };
source_spec returns[StringIdItem source]
- : {$source = null;}
- ^(I_SOURCE string_literal {$source = StringIdItem.internStringIdItem(dexFile, $string_literal.value);})
- | ;
+ : {$source = null;}
+ ^(I_SOURCE string_literal {$source = StringIdItem.internStringIdItem(dexFile, $string_literal.value);})
+ | /*epsilon*/;
access_list returns [int value]
- @init
- {
- $value = 0;
- }
- : ^(I_ACCESS_LIST
- (
- ACCESS_SPEC
- {
- $value |= AccessFlags.getAccessFlag($ACCESS_SPEC.getText()).getValue();
- }
- )*);
+ @init
+ {
+ $value = 0;
+ }
+ : ^(I_ACCESS_LIST
+ (
+ ACCESS_SPEC
+ {
+ $value |= AccessFlags.getAccessFlag($ACCESS_SPEC.getText()).getValue();
+ }
+ )*);
fields returns[List<ClassDataItem.EncodedField> staticFields, List<ClassDataItem.EncodedField> instanceFields,
- List<ClassDefItem.StaticFieldInitializer> staticFieldInitialValues, List<AnnotationDirectoryItem.FieldAnnotation> fieldAnnotations]
- @init
- {
- $staticFields = new LinkedList<ClassDataItem.EncodedField>();
- $instanceFields = new LinkedList<ClassDataItem.EncodedField>();
- $staticFieldInitialValues = new ArrayList<ClassDefItem.StaticFieldInitializer>();
- }
- : ^(I_FIELDS
- (field
- {
- if ($field.encodedField.isStatic()) {
- $staticFields.add($field.encodedField);
- $staticFieldInitialValues.add(new ClassDefItem.StaticFieldInitializer(
- $field.encodedValue, $field.encodedField));
- } else {
- $instanceFields.add($field.encodedField);
- }
- if ($field.fieldAnnotationSet != null) {
- if ($fieldAnnotations == null) {
- $fieldAnnotations = new LinkedList<AnnotationDirectoryItem.FieldAnnotation>();
- }
- AnnotationDirectoryItem.FieldAnnotation fieldAnnotation = new AnnotationDirectoryItem.FieldAnnotation(
- $field.encodedField.field, $field.fieldAnnotationSet);
- $fieldAnnotations.add(fieldAnnotation);
- }
- })*);
+ List<ClassDefItem.StaticFieldInitializer> staticFieldInitialValues, List<AnnotationDirectoryItem.FieldAnnotation> fieldAnnotations]
+ @init
+ {
+ $staticFields = new LinkedList<ClassDataItem.EncodedField>();
+ $instanceFields = new LinkedList<ClassDataItem.EncodedField>();
+ $staticFieldInitialValues = new ArrayList<ClassDefItem.StaticFieldInitializer>();
+ }
+ : ^(I_FIELDS
+ (field
+ {
+ if ($field.encodedField.isStatic()) {
+ $staticFields.add($field.encodedField);
+ $staticFieldInitialValues.add(new ClassDefItem.StaticFieldInitializer(
+ $field.encodedValue, $field.encodedField));
+ } else {
+ $instanceFields.add($field.encodedField);
+ }
+ if ($field.fieldAnnotationSet != null) {
+ if ($fieldAnnotations == null) {
+ $fieldAnnotations = new LinkedList<AnnotationDirectoryItem.FieldAnnotation>();
+ }
+ AnnotationDirectoryItem.FieldAnnotation fieldAnnotation = new AnnotationDirectoryItem.FieldAnnotation(
+ $field.encodedField.field, $field.fieldAnnotationSet);
+ $fieldAnnotations.add(fieldAnnotation);
+ }
+ })*);
methods returns[List<ClassDataItem.EncodedMethod> directMethods,
- List<ClassDataItem.EncodedMethod> virtualMethods,
- List<AnnotationDirectoryItem.MethodAnnotation> methodAnnotations,
- List<AnnotationDirectoryItem.ParameterAnnotation> parameterAnnotations]
- @init
- {
- $directMethods = new LinkedList<ClassDataItem.EncodedMethod>();
- $virtualMethods = new LinkedList<ClassDataItem.EncodedMethod>();
- }
- : ^(I_METHODS
- (method
- {
- if ($method.encodedMethod.isDirect()) {
- $directMethods.add($method.encodedMethod);
- } else {
- $virtualMethods.add($method.encodedMethod);
- }
- if ($method.methodAnnotationSet != null) {
- if ($methodAnnotations == null) {
- $methodAnnotations = new LinkedList<AnnotationDirectoryItem.MethodAnnotation>();
- }
- AnnotationDirectoryItem.MethodAnnotation methodAnnotation =
- new AnnotationDirectoryItem.MethodAnnotation($method.encodedMethod.method, $method.methodAnnotationSet);
- $methodAnnotations.add(methodAnnotation);
- }
- if ($method.parameterAnnotationSets != null) {
- if ($parameterAnnotations == null) {
- $parameterAnnotations = new LinkedList<AnnotationDirectoryItem.ParameterAnnotation>();
- }
- AnnotationDirectoryItem.ParameterAnnotation parameterAnnotation =
- new AnnotationDirectoryItem.ParameterAnnotation($method.encodedMethod.method,
- $method.parameterAnnotationSets);
- $parameterAnnotations.add(parameterAnnotation);
- }
- })*);
+ List<ClassDataItem.EncodedMethod> virtualMethods,
+ List<AnnotationDirectoryItem.MethodAnnotation> methodAnnotations,
+ List<AnnotationDirectoryItem.ParameterAnnotation> parameterAnnotations]
+ @init
+ {
+ $directMethods = new LinkedList<ClassDataItem.EncodedMethod>();
+ $virtualMethods = new LinkedList<ClassDataItem.EncodedMethod>();
+ }
+ : ^(I_METHODS
+ (method
+ {
+ if ($method.encodedMethod.isDirect()) {
+ $directMethods.add($method.encodedMethod);
+ } else {
+ $virtualMethods.add($method.encodedMethod);
+ }
+ if ($method.methodAnnotationSet != null) {
+ if ($methodAnnotations == null) {
+ $methodAnnotations = new LinkedList<AnnotationDirectoryItem.MethodAnnotation>();
+ }
+ AnnotationDirectoryItem.MethodAnnotation methodAnnotation =
+ new AnnotationDirectoryItem.MethodAnnotation($method.encodedMethod.method, $method.methodAnnotationSet);
+ $methodAnnotations.add(methodAnnotation);
+ }
+ if ($method.parameterAnnotationSets != null) {
+ if ($parameterAnnotations == null) {
+ $parameterAnnotations = new LinkedList<AnnotationDirectoryItem.ParameterAnnotation>();
+ }
+ AnnotationDirectoryItem.ParameterAnnotation parameterAnnotation =
+ new AnnotationDirectoryItem.ParameterAnnotation($method.encodedMethod.method,
+ $method.parameterAnnotationSets);
+ $parameterAnnotations.add(parameterAnnotation);
+ }
+ })*);
field returns [ClassDataItem.EncodedField encodedField, EncodedValue encodedValue, AnnotationSetItem fieldAnnotationSet]
- :^(I_FIELD SIMPLE_NAME access_list ^(I_FIELD_TYPE nonvoid_type_descriptor) field_initial_value annotations?)
- {
- StringIdItem memberName = StringIdItem.internStringIdItem(dexFile, $SIMPLE_NAME.text);
- TypeIdItem fieldType = $nonvoid_type_descriptor.type;
+ :^(I_FIELD SIMPLE_NAME access_list ^(I_FIELD_TYPE nonvoid_type_descriptor) field_initial_value annotations?)
+ {
+ StringIdItem memberName = StringIdItem.internStringIdItem(dexFile, $SIMPLE_NAME.text);
+ TypeIdItem fieldType = $nonvoid_type_descriptor.type;
- FieldIdItem fieldIdItem = FieldIdItem.internFieldIdItem(dexFile, classType, fieldType, memberName);
- $encodedField = new ClassDataItem.EncodedField(fieldIdItem, $access_list.value);
+ FieldIdItem fieldIdItem = FieldIdItem.internFieldIdItem(dexFile, classType, fieldType, memberName);
+ $encodedField = new ClassDataItem.EncodedField(fieldIdItem, $access_list.value);
- if ($field_initial_value.encodedValue != null) {
- if (!$encodedField.isStatic()) {
- throw new SemanticException(input, "Initial field values can only be specified for static fields.");
- }
+ if ($field_initial_value.encodedValue != null) {
+ if (!$encodedField.isStatic()) {
+ throw new SemanticException(input, "Initial field values can only be specified for static fields.");
+ }
- $encodedValue = $field_initial_value.encodedValue;
- } else {
- $encodedValue = null;
- }
+ $encodedValue = $field_initial_value.encodedValue;
+ } else {
+ $encodedValue = null;
+ }
- if ($annotations.annotationSetItem != null) {
- $fieldAnnotationSet = $annotations.annotationSetItem;
- }
- };
+ if ($annotations.annotationSetItem != null) {
+ $fieldAnnotationSet = $annotations.annotationSetItem;
+ }
+ };
field_initial_value returns[EncodedValue encodedValue]
- : ^(I_FIELD_INITIAL_VALUE literal) {$encodedValue = $literal.encodedValue;}
- | ;
+ : ^(I_FIELD_INITIAL_VALUE literal) {$encodedValue = $literal.encodedValue;}
+ | /*epsilon*/;
literal returns[EncodedValue encodedValue]
- : integer_literal { $encodedValue = new IntEncodedValue($integer_literal.value); }
- | long_literal { $encodedValue = new LongEncodedValue($long_literal.value); }
- | short_literal { $encodedValue = new ShortEncodedValue($short_literal.value); }
- | byte_literal { $encodedValue = new ByteEncodedValue($byte_literal.value); }
- | float_literal { $encodedValue = new FloatEncodedValue($float_literal.value); }
- | double_literal { $encodedValue = new DoubleEncodedValue($double_literal.value); }
- | char_literal { $encodedValue = new CharEncodedValue($char_literal.value); }
- | string_literal { $encodedValue = new StringEncodedValue(StringIdItem.internStringIdItem(dexFile, $string_literal.value)); }
- | bool_literal { $encodedValue = $bool_literal.value?BooleanEncodedValue.TrueValue:BooleanEncodedValue.FalseValue; }
- | NULL_LITERAL { $encodedValue = NullEncodedValue.NullValue; }
- | type_descriptor { $encodedValue = new TypeEncodedValue($type_descriptor.type); }
- | array_literal { $encodedValue = new ArrayEncodedValue($array_literal.values); }
- | subannotation { $encodedValue = new AnnotationEncodedValue($subannotation.annotationType, $subannotation.elementNames, $subannotation.elementValues); }
- | field_literal { $encodedValue = new FieldEncodedValue($field_literal.value); }
- | method_literal { $encodedValue = new MethodEncodedValue($method_literal.value); }
- | enum_literal { $encodedValue = new EnumEncodedValue($enum_literal.value); };
+ : integer_literal { $encodedValue = new IntEncodedValue($integer_literal.value); }
+ | long_literal { $encodedValue = new LongEncodedValue($long_literal.value); }
+ | short_literal { $encodedValue = new ShortEncodedValue($short_literal.value); }
+ | byte_literal { $encodedValue = new ByteEncodedValue($byte_literal.value); }
+ | float_literal { $encodedValue = new FloatEncodedValue($float_literal.value); }
+ | double_literal { $encodedValue = new DoubleEncodedValue($double_literal.value); }
+ | char_literal { $encodedValue = new CharEncodedValue($char_literal.value); }
+ | string_literal { $encodedValue = new StringEncodedValue(StringIdItem.internStringIdItem(dexFile, $string_literal.value)); }
+ | bool_literal { $encodedValue = $bool_literal.value?BooleanEncodedValue.TrueValue:BooleanEncodedValue.FalseValue; }
+ | NULL_LITERAL { $encodedValue = NullEncodedValue.NullValue; }
+ | type_descriptor { $encodedValue = new TypeEncodedValue($type_descriptor.type); }
+ | array_literal { $encodedValue = new ArrayEncodedValue($array_literal.values); }
+ | subannotation { $encodedValue = new AnnotationEncodedValue($subannotation.annotationType, $subannotation.elementNames, $subannotation.elementValues); }
+ | field_literal { $encodedValue = new FieldEncodedValue($field_literal.value); }
+ | method_literal { $encodedValue = new MethodEncodedValue($method_literal.value); }
+ | enum_literal { $encodedValue = new EnumEncodedValue($enum_literal.value); };
//everything but string
fixed_size_literal returns[byte[\] value]
- : integer_literal { $value = LiteralTools.intToBytes($integer_literal.value); }
- | long_literal { $value = LiteralTools.longToBytes($long_literal.value); }
- | short_literal { $value = LiteralTools.shortToBytes($short_literal.value); }
- | byte_literal { $value = new byte[] { $byte_literal.value }; }
- | float_literal { $value = LiteralTools.floatToBytes($float_literal.value); }
- | double_literal { $value = LiteralTools.doubleToBytes($double_literal.value); }
- | char_literal { $value = LiteralTools.charToBytes($char_literal.value); }
- | bool_literal { $value = LiteralTools.boolToBytes($bool_literal.value); };
+ : integer_literal { $value = LiteralTools.intToBytes($integer_literal.value); }
+ | long_literal { $value = LiteralTools.longToBytes($long_literal.value); }
+ | short_literal { $value = LiteralTools.shortToBytes($short_literal.value); }
+ | byte_literal { $value = new byte[] { $byte_literal.value }; }
+ | float_literal { $value = LiteralTools.floatToBytes($float_literal.value); }
+ | double_literal { $value = LiteralTools.doubleToBytes($double_literal.value); }
+ | char_literal { $value = LiteralTools.charToBytes($char_literal.value); }
+ | bool_literal { $value = LiteralTools.boolToBytes($bool_literal.value); };
//everything but string
fixed_64bit_literal returns[long value]
- : integer_literal { $value = $integer_literal.value; }
- | long_literal { $value = $long_literal.value; }
- | short_literal { $value = $short_literal.value; }
- | byte_literal { $value = $byte_literal.value; }
- | float_literal { $value = Float.floatToRawIntBits($float_literal.value); }
- | double_literal { $value = Double.doubleToRawLongBits($double_literal.value); }
- | char_literal { $value = $char_literal.value; }
- | bool_literal { $value = $bool_literal.value?1:0; };
+ : integer_literal { $value = $integer_literal.value; }
+ | long_literal { $value = $long_literal.value; }
+ | short_literal { $value = $short_literal.value; }
+ | byte_literal { $value = $byte_literal.value; }
+ | float_literal { $value = Float.floatToRawIntBits($float_literal.value); }
+ | double_literal { $value = Double.doubleToRawLongBits($double_literal.value); }
+ | char_literal { $value = $char_literal.value; }
+ | bool_literal { $value = $bool_literal.value?1:0; };
//everything but string and double
//long is allowed, but it must fit into an int
fixed_32bit_literal returns[int value]
- : integer_literal { $value = $integer_literal.value; }
- | long_literal { LiteralTools.checkInt($long_literal.value); $value = (int)$long_literal.value; }
- | short_literal { $value = $short_literal.value; }
- | byte_literal { $value = $byte_literal.value; }
- | float_literal { $value = Float.floatToRawIntBits($float_literal.value); }
- | char_literal { $value = $char_literal.value; }
- | bool_literal { $value = $bool_literal.value?1:0; };
+ : integer_literal { $value = $integer_literal.value; }
+ | long_literal { LiteralTools.checkInt($long_literal.value); $value = (int)$long_literal.value; }
+ | short_literal { $value = $short_literal.value; }
+ | byte_literal { $value = $byte_literal.value; }
+ | float_literal { $value = Float.floatToRawIntBits($float_literal.value); }
+ | char_literal { $value = $char_literal.value; }
+ | bool_literal { $value = $bool_literal.value?1:0; };
array_elements returns[List<byte[\]> values]
- : {$values = new ArrayList<byte[]>();}
- ^(I_ARRAY_ELEMENTS
- (fixed_size_literal
- {
- $values.add($fixed_size_literal.value);
- })*);
+ : {$values = new ArrayList<byte[]>();}
+ ^(I_ARRAY_ELEMENTS
+ (fixed_size_literal
+ {
+ $values.add($fixed_size_literal.value);
+ })*);
packed_switch_target_count returns[int targetCount]
- : I_PACKED_SWITCH_TARGET_COUNT {$targetCount = Integer.parseInt($I_PACKED_SWITCH_TARGET_COUNT.text);};
+ : I_PACKED_SWITCH_TARGET_COUNT {$targetCount = Integer.parseInt($I_PACKED_SWITCH_TARGET_COUNT.text);};
packed_switch_targets[int baseAddress] returns[int[\] targets]
- :
- ^(I_PACKED_SWITCH_TARGETS
- packed_switch_target_count
- {
- int targetCount = $packed_switch_target_count.targetCount;
- $targets = new int[targetCount];
- int targetsPosition = 0;
- }
+ :
+ ^(I_PACKED_SWITCH_TARGETS
+ packed_switch_target_count
+ {
+ int targetCount = $packed_switch_target_count.targetCount;
+ $targets = new int[targetCount];
+ int targetsPosition = 0;
+ }
- (offset_or_label
- {
- $targets[targetsPosition++] = ($method::currentAddress + $offset_or_label.offsetValue) - $baseAddress;
- })*
- );
+ (offset_or_label
+ {
+ $targets[targetsPosition++] = ($method::currentAddress + $offset_or_label.offsetValue) - $baseAddress;
+ })*
+ );
sparse_switch_target_count returns[int targetCount]
- : I_SPARSE_SWITCH_TARGET_COUNT {$targetCount = Integer.parseInt($I_SPARSE_SWITCH_TARGET_COUNT.text);};
+ : I_SPARSE_SWITCH_TARGET_COUNT {$targetCount = Integer.parseInt($I_SPARSE_SWITCH_TARGET_COUNT.text);};
sparse_switch_keys[int targetCount] returns[int[\] keys]
- : {
- $keys = new int[$targetCount];
- int keysPosition = 0;
- }
- ^(I_SPARSE_SWITCH_KEYS
- (fixed_32bit_literal
- {
- $keys[keysPosition++] = $fixed_32bit_literal.value;
- })*
- );
+ : {
+ $keys = new int[$targetCount];
+ int keysPosition = 0;
+ }
+ ^(I_SPARSE_SWITCH_KEYS
+ (fixed_32bit_literal
+ {
+ $keys[keysPosition++] = $fixed_32bit_literal.value;
+ })*
+ );
sparse_switch_targets[int baseAddress, int targetCount] returns[int[\] targets]
- : {
- $targets = new int[$targetCount];
- int targetsPosition = 0;
- }
- ^(I_SPARSE_SWITCH_TARGETS
- (offset_or_label
- {
- $targets[targetsPosition++] = ($method::currentAddress + $offset_or_label.offsetValue) - $baseAddress;
- })*
- );
+ : {
+ $targets = new int[$targetCount];
+ int targetsPosition = 0;
+ }
+ ^(I_SPARSE_SWITCH_TARGETS
+ (offset_or_label
+ {
+ $targets[targetsPosition++] = ($method::currentAddress + $offset_or_label.offsetValue) - $baseAddress;
+ })*
+ );
-method returns[ ClassDataItem.EncodedMethod encodedMethod,
- AnnotationSetItem methodAnnotationSet,
- AnnotationSetRefList parameterAnnotationSets]
- scope
- {
- HashMap<String, Integer> labels;
- TryListBuilder tryList;
- int currentAddress;
- DebugInfoBuilder debugInfo;
- HashMap<Integer, Integer> packedSwitchDeclarations;
- HashMap<Integer, Integer> sparseSwitchDeclarations;
- }
- @init
- {
- MethodIdItem methodIdItem = null;
- int totalMethodRegisters = 0;
- int methodParameterRegisters = 0;
- int accessFlags = 0;
- boolean isStatic = false;
- }
- : {
- $method::labels = new HashMap<String, Integer>();
- $method::tryList = new TryListBuilder();
- $method::currentAddress = 0;
- $method::debugInfo = new DebugInfoBuilder();
- $method::packedSwitchDeclarations = new HashMap<Integer, Integer>();
- $method::sparseSwitchDeclarations = new HashMap<Integer, Integer>();
- }
- ^( I_METHOD
- method_name_and_prototype
- access_list
- {
- methodIdItem = $method_name_and_prototype.methodIdItem;
- accessFlags = $access_list.value;
- isStatic = (accessFlags & AccessFlags.STATIC.getValue()) != 0;
- methodParameterRegisters = methodIdItem.getPrototype().getParameterRegisterCount();
- if (!isStatic) {
- methodParameterRegisters++;
- }
- }
- ( registers_directive
- {
- if ($registers_directive.isLocalsDirective) {
- totalMethodRegisters = $registers_directive.registers + methodParameterRegisters;
- } else {
- totalMethodRegisters = $registers_directive.registers;
- }
- }
- )?
- labels
- packed_switch_declarations
- sparse_switch_declarations
- statements[totalMethodRegisters, methodParameterRegisters]
- catches
- parameters
- ordered_debug_directives[totalMethodRegisters, methodParameterRegisters]
- annotations
- )
- {
- Pair<List<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> temp = $method::tryList.encodeTries();
- List<CodeItem.TryItem> tries = temp.first;
- List<CodeItem.EncodedCatchHandler> handlers = temp.second;
+method returns[ClassDataItem.EncodedMethod encodedMethod,
+ AnnotationSetItem methodAnnotationSet,
+ AnnotationSetRefList parameterAnnotationSets]
+ scope
+ {
+ HashMap<String, Integer> labels;
+ TryListBuilder tryList;
+ int currentAddress;
+ DebugInfoBuilder debugInfo;
+ HashMap<Integer, Integer> packedSwitchDeclarations;
+ HashMap<Integer, Integer> sparseSwitchDeclarations;
+ }
+ @init
+ {
+ MethodIdItem methodIdItem = null;
+ int totalMethodRegisters = 0;
+ int methodParameterRegisters = 0;
+ int accessFlags = 0;
+ boolean isStatic = false;
+ }
+ : {
+ $method::labels = new HashMap<String, Integer>();
+ $method::tryList = new TryListBuilder();
+ $method::currentAddress = 0;
+ $method::debugInfo = new DebugInfoBuilder();
+ $method::packedSwitchDeclarations = new HashMap<Integer, Integer>();
+ $method::sparseSwitchDeclarations = new HashMap<Integer, Integer>();
+ }
+ ^(I_METHOD
+ method_name_and_prototype
+ access_list
+ {
+ methodIdItem = $method_name_and_prototype.methodIdItem;
+ accessFlags = $access_list.value;
+ isStatic = (accessFlags & AccessFlags.STATIC.getValue()) != 0;
+ methodParameterRegisters = methodIdItem.getPrototype().getParameterRegisterCount();
+ if (!isStatic) {
+ methodParameterRegisters++;
+ }
+ }
+ (registers_directive
+ {
+ if ($registers_directive.isLocalsDirective) {
+ totalMethodRegisters = $registers_directive.registers + methodParameterRegisters;
+ } else {
+ totalMethodRegisters = $registers_directive.registers;
+ }
+ }
+ )?
+ labels
+ packed_switch_declarations
+ sparse_switch_declarations
+ statements[totalMethodRegisters, methodParameterRegisters]
+ catches
+ parameters
+ ordered_debug_directives[totalMethodRegisters, methodParameterRegisters]
+ annotations
+ )
+ {
+ Pair<List<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> temp = $method::tryList.encodeTries();
+ List<CodeItem.TryItem> tries = temp.first;
+ List<CodeItem.EncodedCatchHandler> handlers = temp.second;
- DebugInfoItem debugInfoItem = $method::debugInfo.encodeDebugInfo(dexFile);
+ DebugInfoItem debugInfoItem = $method::debugInfo.encodeDebugInfo(dexFile);
- CodeItem codeItem;
+ CodeItem codeItem;
- boolean isAbstract = false;
- boolean isNative = false;
+ boolean isAbstract = false;
+ boolean isNative = false;
- if ((accessFlags & AccessFlags.ABSTRACT.getValue()) != 0) {
- isAbstract = true;
- } else if ((accessFlags & AccessFlags.NATIVE.getValue()) != 0) {
- isNative = true;
- }
+ if ((accessFlags & AccessFlags.ABSTRACT.getValue()) != 0) {
+ isAbstract = true;
+ } else if ((accessFlags & AccessFlags.NATIVE.getValue()) != 0) {
+ isNative = true;
+ }
- if ($statements.instructions.size() == 0) {
- if (!isAbstract && !isNative) {
- throw new SemanticException(input, $I_METHOD, "A non-abstract/non-native method must have at least 1 instruction");
- }
+ if ($statements.instructions.size() == 0) {
+ if (!isAbstract && !isNative) {
+ throw new SemanticException(input, $I_METHOD, "A non-abstract/non-native method must have at least 1 instruction");
+ }
- String methodType;
- if (isAbstract) {
- methodType = "an abstract";
- } else {
- methodType = "a native";
- }
+ String methodType;
+ if (isAbstract) {
+ methodType = "an abstract";
+ } else {
+ methodType = "a native";
+ }
- if ($registers_directive.start != null) {
- if ($registers_directive.isLocalsDirective) {
- throw new SemanticException(input, $registers_directive.start, "A .locals directive is not valid in \%s method", methodType);
- } else {
- throw new SemanticException(input, $registers_directive.start, "A .registers directive is not valid in \%s method", methodType);
- }
- }
+ if ($registers_directive.start != null) {
+ if ($registers_directive.isLocalsDirective) {
+ throw new SemanticException(input, $registers_directive.start, "A .locals directive is not valid in \%s method", methodType);
+ } else {
+ throw new SemanticException(input, $registers_directive.start, "A .registers directive is not valid in \%s method", methodType);
+ }
+ }
- if ($method::labels.size() > 0) {
- throw new SemanticException(input, $I_METHOD, "Labels cannot be present in \%s method", methodType);
- }
+ if ($method::labels.size() > 0) {
+ throw new SemanticException(input, $I_METHOD, "Labels cannot be present in \%s method", methodType);
+ }
- if ((tries != null && tries.size() > 0) || (handlers != null && handlers.size() > 0)) {
- throw new SemanticException(input, $I_METHOD, "try/catch blocks cannot be present in \%s method", methodType);
- }
+ if ((tries != null && tries.size() > 0) || (handlers != null && handlers.size() > 0)) {
+ throw new SemanticException(input, $I_METHOD, "try/catch blocks cannot be present in \%s method", methodType);
+ }
- if (debugInfoItem != null) {
- throw new SemanticException(input, $I_METHOD, "debug directives cannot be present in \%s method", methodType);
- }
+ if (debugInfoItem != null) {
+ throw new SemanticException(input, $I_METHOD, "debug directives cannot be present in \%s method", methodType);
+ }
- codeItem = null;
- } else {
- if (isAbstract) {
- throw new SemanticException(input, $I_METHOD, "An abstract method cannot have any instructions");
- }
- if (isNative) {
- throw new SemanticException(input, $I_METHOD, "A native method cannot have any instructions");
- }
+ codeItem = null;
+ } else {
+ if (isAbstract) {
+ throw new SemanticException(input, $I_METHOD, "An abstract method cannot have any instructions");
+ }
+ if (isNative) {
+ throw new SemanticException(input, $I_METHOD, "A native method cannot have any instructions");
+ }
- if ($registers_directive.start == null) {
- throw new SemanticException(input, $I_METHOD, "A .registers or .locals directive must be present for a non-abstract/non-final method");
- }
+ if ($registers_directive.start == null) {
+ throw new SemanticException(input, $I_METHOD, "A .registers or .locals directive must be present for a non-abstract/non-final method");
+ }
- if (totalMethodRegisters < methodParameterRegisters) {
- throw new SemanticException(input, $registers_directive.start, "This method requires at least " +
- Integer.toString(methodParameterRegisters) +
- " registers, for the method parameters");
- }
+ if (totalMethodRegisters < methodParameterRegisters) {
+ throw new SemanticException(input, $registers_directive.start, "This method requires at least " +
+ Integer.toString(methodParameterRegisters) +
+ " registers, for the method parameters");
+ }
- int methodParameterCount = methodIdItem.getPrototype().getParameterRegisterCount();
- if ($method::debugInfo.getParameterNameCount() > methodParameterCount) {
- throw new SemanticException(input, $I_METHOD, "Too many parameter names specified. This method only has " +
- Integer.toString(methodParameterCount) +
- " parameters.");
- }
+ int methodParameterCount = methodIdItem.getPrototype().getParameterRegisterCount();
+ if ($method::debugInfo.getParameterNameCount() > methodParameterCount) {
+ throw new SemanticException(input, $I_METHOD, "Too many parameter names specified. This method only has " +
+ Integer.toString(methodParameterCount) +
+ " parameters.");
+ }
- codeItem = CodeItem.internCodeItem(dexFile,
- totalMethodRegisters,
- methodParameterRegisters,
- $statements.maxOutRegisters,
- debugInfoItem,
- $statements.instructions,
- tries,
- handlers);
- }
+ codeItem = CodeItem.internCodeItem(dexFile,
+ totalMethodRegisters,
+ methodParameterRegisters,
+ $statements.maxOutRegisters,
+ debugInfoItem,
+ $statements.instructions,
+ tries,
+ handlers);
+ }
- $encodedMethod = new ClassDataItem.EncodedMethod(methodIdItem, accessFlags, codeItem);
+ $encodedMethod = new ClassDataItem.EncodedMethod(methodIdItem, accessFlags, codeItem);
- if ($annotations.annotationSetItem != null) {
- $methodAnnotationSet = $annotations.annotationSetItem;
- }
+ if ($annotations.annotationSetItem != null) {
+ $methodAnnotationSet = $annotations.annotationSetItem;
+ }
- if ($parameters.parameterAnnotations != null) {
- $parameterAnnotationSets = $parameters.parameterAnnotations;
- }
- };
+ if ($parameters.parameterAnnotations != null) {
+ $parameterAnnotationSets = $parameters.parameterAnnotations;
+ }
+ };
method_prototype returns[ProtoIdItem protoIdItem]
- : ^(I_METHOD_PROTOTYPE ^(I_METHOD_RETURN_TYPE type_descriptor) field_type_list)
- {
- TypeIdItem returnType = $type_descriptor.type;
- List<TypeIdItem> parameterTypes = $field_type_list.types;
- TypeListItem parameterTypeListItem = null;
- if (parameterTypes != null && parameterTypes.size() > 0) {
- parameterTypeListItem = TypeListItem.internTypeListItem(dexFile, parameterTypes);
- }
+ : ^(I_METHOD_PROTOTYPE ^(I_METHOD_RETURN_TYPE type_descriptor) field_type_list)
+ {
+ TypeIdItem returnType = $type_descriptor.type;
+ List<TypeIdItem> parameterTypes = $field_type_list.types;
+ TypeListItem parameterTypeListItem = null;
+ if (parameterTypes != null && parameterTypes.size() > 0) {
+ parameterTypeListItem = TypeListItem.internTypeListItem(dexFile, parameterTypes);
+ }
- $protoIdItem = ProtoIdItem.internProtoIdItem(dexFile, returnType, parameterTypeListItem);
- };
+ $protoIdItem = ProtoIdItem.internProtoIdItem(dexFile, returnType, parameterTypeListItem);
+ };
method_name_and_prototype returns[MethodIdItem methodIdItem]
- : SIMPLE_NAME method_prototype
- {
- String methodNameString = $SIMPLE_NAME.text;
- StringIdItem methodName = StringIdItem.internStringIdItem(dexFile, methodNameString);
- ProtoIdItem protoIdItem = $method_prototype.protoIdItem;
+ : SIMPLE_NAME method_prototype
+ {
+ String methodNameString = $SIMPLE_NAME.text;
+ StringIdItem methodName = StringIdItem.internStringIdItem(dexFile, methodNameString);
+ ProtoIdItem protoIdItem = $method_prototype.protoIdItem;
- $methodIdItem = MethodIdItem.internMethodIdItem(dexFile, classType, protoIdItem, methodName);
- };
+ $methodIdItem = MethodIdItem.internMethodIdItem(dexFile, classType, protoIdItem, methodName);
+ };
field_type_list returns[List<TypeIdItem> types]
- @init
- {
- $types = new LinkedList<TypeIdItem>();
- }
- : (
- nonvoid_type_descriptor
- {
- $types.add($nonvoid_type_descriptor.type);
- }
- )*;
+ @init
+ {
+ $types = new LinkedList<TypeIdItem>();
+ }
+ : (
+ nonvoid_type_descriptor
+ {
+ $types.add($nonvoid_type_descriptor.type);
+ }
+ )*;
fully_qualified_method returns[MethodIdItem methodIdItem]
- : reference_type_descriptor SIMPLE_NAME method_prototype
- {
- TypeIdItem classType = $reference_type_descriptor.type;
- StringIdItem methodName = StringIdItem.internStringIdItem(dexFile, $SIMPLE_NAME.text);
- ProtoIdItem prototype = $method_prototype.protoIdItem;
- $methodIdItem = MethodIdItem.internMethodIdItem(dexFile, classType, prototype, methodName);
- };
+ : reference_type_descriptor SIMPLE_NAME method_prototype
+ {
+ TypeIdItem classType = $reference_type_descriptor.type;
+ StringIdItem methodName = StringIdItem.internStringIdItem(dexFile, $SIMPLE_NAME.text);
+ ProtoIdItem prototype = $method_prototype.protoIdItem;
+ $methodIdItem = MethodIdItem.internMethodIdItem(dexFile, classType, prototype, methodName);
+ };
fully_qualified_field returns[FieldIdItem fieldIdItem]
- : reference_type_descriptor SIMPLE_NAME nonvoid_type_descriptor
- {
- TypeIdItem classType = $reference_type_descriptor.type;
- StringIdItem fieldName = StringIdItem.internStringIdItem(dexFile, $SIMPLE_NAME.text);
- TypeIdItem fieldType = $nonvoid_type_descriptor.type;
- $fieldIdItem = FieldIdItem.internFieldIdItem(dexFile, classType, fieldType, fieldName);
- };
+ : reference_type_descriptor SIMPLE_NAME nonvoid_type_descriptor
+ {
+ TypeIdItem classType = $reference_type_descriptor.type;
+ StringIdItem fieldName = StringIdItem.internStringIdItem(dexFile, $SIMPLE_NAME.text);
+ TypeIdItem fieldType = $nonvoid_type_descriptor.type;
+ $fieldIdItem = FieldIdItem.internFieldIdItem(dexFile, classType, fieldType, fieldName);
+ };
registers_directive returns[boolean isLocalsDirective, int registers]
- : {$registers = 0;}
- ^( ( I_REGISTERS {$isLocalsDirective = false;}
- | I_LOCALS {$isLocalsDirective = true;}
- )
- short_integral_literal {$registers = $short_integral_literal.value;}
- );
+ : {$registers = 0;}
+ ^(( I_REGISTERS {$isLocalsDirective = false;}
+ | I_LOCALS {$isLocalsDirective = true;}
+ )
+ short_integral_literal {$registers = $short_integral_literal.value;}
+ );
labels
- : ^(I_LABELS label_def*);
+ : ^(I_LABELS label_def*);
label_def
- : ^(I_LABEL SIMPLE_NAME address)
- {
- if ($method::labels.containsKey($SIMPLE_NAME.text)) {
- throw new SemanticException(input, $I_LABEL, "Label " + $SIMPLE_NAME.text + " has multiple defintions.");
- }
+ : ^(I_LABEL SIMPLE_NAME address)
+ {
+ if ($method::labels.containsKey($SIMPLE_NAME.text)) {
+ throw new SemanticException(input, $I_LABEL, "Label " + $SIMPLE_NAME.text + " has multiple defintions.");
+ }
-
- $method::labels.put($SIMPLE_NAME.text, $address.address);
- };
+ $method::labels.put($SIMPLE_NAME.text, $address.address);
+ };
packed_switch_declarations
- : ^(I_PACKED_SWITCH_DECLARATIONS packed_switch_declaration*);
+ : ^(I_PACKED_SWITCH_DECLARATIONS packed_switch_declaration*);
packed_switch_declaration
- : ^(I_PACKED_SWITCH_DECLARATION address offset_or_label_absolute[$address.address])
- {
- int switchDataAddress = $offset_or_label_absolute.address;
- if ((switchDataAddress \% 2) != 0) {
- switchDataAddress++;
- }
- if (!$method::packedSwitchDeclarations.containsKey(switchDataAddress)) {
- $method::packedSwitchDeclarations.put(switchDataAddress, $address.address);
- }
- };
+ : ^(I_PACKED_SWITCH_DECLARATION address offset_or_label_absolute[$address.address])
+ {
+ int switchDataAddress = $offset_or_label_absolute.address;
+ if ((switchDataAddress \% 2) != 0) {
+ switchDataAddress++;
+ }
+ if (!$method::packedSwitchDeclarations.containsKey(switchDataAddress)) {
+ $method::packedSwitchDeclarations.put(switchDataAddress, $address.address);
+ }
+ };
sparse_switch_declarations
- : ^(I_SPARSE_SWITCH_DECLARATIONS sparse_switch_declaration*);
+ : ^(I_SPARSE_SWITCH_DECLARATIONS sparse_switch_declaration*);
sparse_switch_declaration
- : ^(I_SPARSE_SWITCH_DECLARATION address offset_or_label_absolute[$address.address])
- {
- int switchDataAddress = $offset_or_label_absolute.address;
- if ((switchDataAddress \% 2) != 0) {
- switchDataAddress++;
- }
- if (!$method::sparseSwitchDeclarations.containsKey(switchDataAddress)) {
- $method::sparseSwitchDeclarations.put(switchDataAddress, $address.address);
- }
+ : ^(I_SPARSE_SWITCH_DECLARATION address offset_or_label_absolute[$address.address])
+ {
+ int switchDataAddress = $offset_or_label_absolute.address;
+ if ((switchDataAddress \% 2) != 0) {
+ switchDataAddress++;
+ }
+ if (!$method::sparseSwitchDeclarations.containsKey(switchDataAddress)) {
+ $method::sparseSwitchDeclarations.put(switchDataAddress, $address.address);
+ }
- };
+ };
-catches : ^(I_CATCHES catch_directive* catchall_directive*);
+catches : ^(I_CATCHES catch_directive* catchall_directive*);
catch_directive
- : ^(I_CATCH address nonvoid_type_descriptor from=offset_or_label_absolute[$address.address] to=offset_or_label_absolute[$address.address]
- using=offset_or_label_absolute[$address.address])
- {
- TypeIdItem type = $nonvoid_type_descriptor.type;
- int startAddress = $from.address;
- int endAddress = $to.address;
- int handlerAddress = $using.address;
+ : ^(I_CATCH address nonvoid_type_descriptor from=offset_or_label_absolute[$address.address] to=offset_or_label_absolute[$address.address]
+ using=offset_or_label_absolute[$address.address])
+ {
+ TypeIdItem type = $nonvoid_type_descriptor.type;
+ int startAddress = $from.address;
+ int endAddress = $to.address;
+ int handlerAddress = $using.address;
- $method::tryList.addHandler(type, startAddress, endAddress, handlerAddress);
- };
+ $method::tryList.addHandler(type, startAddress, endAddress, handlerAddress);
+ };
catchall_directive
- : ^(I_CATCHALL address from=offset_or_label_absolute[$address.address] to=offset_or_label_absolute[$address.address]
- using=offset_or_label_absolute[$address.address])
- {
- int startAddress = $from.address;
- int endAddress = $to.address;
- int handlerAddress = $using.address;
+ : ^(I_CATCHALL address from=offset_or_label_absolute[$address.address] to=offset_or_label_absolute[$address.address]
+ using=offset_or_label_absolute[$address.address])
+ {
+ int startAddress = $from.address;
+ int endAddress = $to.address;
+ int handlerAddress = $using.address;
- $method::tryList.addCatchAllHandler(startAddress, endAddress, handlerAddress);
- };
+ $method::tryList.addCatchAllHandler(startAddress, endAddress, handlerAddress);
+ };
address returns[int address]
- : I_ADDRESS
- {
- $address = Integer.parseInt($I_ADDRESS.text);
- };
+ : I_ADDRESS
+ {
+ $address = Integer.parseInt($I_ADDRESS.text);
+ };
parameters returns[AnnotationSetRefList parameterAnnotations]
- @init
- {
- int parameterCount = 0;
- List<AnnotationSetItem> annotationSetItems = new ArrayList<AnnotationSetItem>();
- }
- : ^(I_PARAMETERS (parameter
- {
- if ($parameter.parameterAnnotationSet != null) {
- while (annotationSetItems.size() < parameterCount) {
- annotationSetItems.add(AnnotationSetItem.internAnnotationSetItem(dexFile, null));
- }
- annotationSetItems.add($parameter.parameterAnnotationSet);
- }
+ @init
+ {
+ int parameterCount = 0;
+ List<AnnotationSetItem> annotationSetItems = new ArrayList<AnnotationSetItem>();
+ }
+ : ^(I_PARAMETERS (parameter
+ {
+ if ($parameter.parameterAnnotationSet != null) {
+ while (annotationSetItems.size() < parameterCount) {
+ annotationSetItems.add(AnnotationSetItem.internAnnotationSetItem(dexFile, null));
+ }
+ annotationSetItems.add($parameter.parameterAnnotationSet);
+ }
- parameterCount++;
- })*
- )
- {
- if (annotationSetItems.size() > 0) {
- while (annotationSetItems.size() < parameterCount) {
- annotationSetItems.add(AnnotationSetItem.internAnnotationSetItem(dexFile, null));
- }
- $parameterAnnotations = AnnotationSetRefList.internAnnotationSetRefList(dexFile, annotationSetItems);
- }
- };
+ parameterCount++;
+ })*
+ )
+ {
+ if (annotationSetItems.size() > 0) {
+ while (annotationSetItems.size() < parameterCount) {
+ annotationSetItems.add(AnnotationSetItem.internAnnotationSetItem(dexFile, null));
+ }
+ $parameterAnnotations = AnnotationSetRefList.internAnnotationSetRefList(dexFile, annotationSetItems);
+ }
+ };
parameter returns[AnnotationSetItem parameterAnnotationSet]
- : ^(I_PARAMETER ( string_literal {$method::debugInfo.addParameterName($string_literal.value);}
- | {$method::debugInfo.addParameterName(null);}
- )
- annotations {$parameterAnnotationSet = $annotations.annotationSetItem;}
- );
+ : ^(I_PARAMETER (string_literal {$method::debugInfo.addParameterName($string_literal.value);}
+ | {$method::debugInfo.addParameterName(null);}
+ )
+ annotations {$parameterAnnotationSet = $annotations.annotationSetItem;}
+ );
ordered_debug_directives[int totalMethodRegisters, int methodParameterRegisters]
- : ^(I_ORDERED_DEBUG_DIRECTIVES ( line
- | local[$totalMethodRegisters, $methodParameterRegisters]
- | end_local[$totalMethodRegisters, $methodParameterRegisters]
- | restart_local[$totalMethodRegisters, $methodParameterRegisters]
- | prologue
- | epilogue
- | source
- )*);
+ : ^(I_ORDERED_DEBUG_DIRECTIVES
+ ( line
+ | local[$totalMethodRegisters, $methodParameterRegisters]
+ | end_local[$totalMethodRegisters, $methodParameterRegisters]
+ | restart_local[$totalMethodRegisters, $methodParameterRegisters]
+ | prologue
+ | epilogue
+ | source
+ )*
+ );
line
- : ^(I_LINE integral_literal address)
- {
- $method::debugInfo.addLine($address.address, $integral_literal.value);
- };
+ : ^(I_LINE integral_literal address)
+ {
+ $method::debugInfo.addLine($address.address, $integral_literal.value);
+ };
local[int totalMethodRegisters, int methodParameterRegisters]
- : ^(I_LOCAL REGISTER SIMPLE_NAME nonvoid_type_descriptor string_literal? address)
- {
- int registerNumber = parseRegister_short($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
+ : ^(I_LOCAL REGISTER SIMPLE_NAME nonvoid_type_descriptor string_literal? address)
+ {
+ int registerNumber = parseRegister_short($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
- if ($string_literal.value != null) {
- $method::debugInfo.addLocalExtended($address.address, registerNumber, $SIMPLE_NAME.text, $nonvoid_type_descriptor.type.getTypeDescriptor(), $string_literal.value);
- } else {
- $method::debugInfo.addLocal($address.address, registerNumber, $SIMPLE_NAME.text, $nonvoid_type_descriptor.type.getTypeDescriptor());
- }
- };
+ if ($string_literal.value != null) {
+ $method::debugInfo.addLocalExtended($address.address, registerNumber, $SIMPLE_NAME.text, $nonvoid_type_descriptor.type.getTypeDescriptor(), $string_literal.value);
+ } else {
+ $method::debugInfo.addLocal($address.address, registerNumber, $SIMPLE_NAME.text, $nonvoid_type_descriptor.type.getTypeDescriptor());
+ }
+ };
end_local[int totalMethodRegisters, int methodParameterRegisters]
- : ^(I_END_LOCAL REGISTER address)
- {
- int registerNumber = parseRegister_short($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
+ : ^(I_END_LOCAL REGISTER address)
+ {
+ int registerNumber = parseRegister_short($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
- $method::debugInfo.addEndLocal($address.address, registerNumber);
- };
+ $method::debugInfo.addEndLocal($address.address, registerNumber);
+ };
restart_local[int totalMethodRegisters, int methodParameterRegisters]
- : ^(I_RESTART_LOCAL REGISTER address)
- {
- int registerNumber = parseRegister_short($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
+ : ^(I_RESTART_LOCAL REGISTER address)
+ {
+ int registerNumber = parseRegister_short($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
- $method::debugInfo.addRestartLocal($address.address, registerNumber);
- };
+ $method::debugInfo.addRestartLocal($address.address, registerNumber);
+ };
prologue
- : ^(I_PROLOGUE address)
- {
- $method::debugInfo.addPrologue($address.address);
- };
+ : ^(I_PROLOGUE address)
+ {
+ $method::debugInfo.addPrologue($address.address);
+ };
epilogue
- : ^(I_EPILOGUE address)
- {
- $method::debugInfo.addEpilogue($address.address);
- };
+ : ^(I_EPILOGUE address)
+ {
+ $method::debugInfo.addEpilogue($address.address);
+ };
source
- : ^(I_SOURCE string_literal address)
- {
- $method::debugInfo.addSetFile($address.address, $string_literal.value);
- };
+ : ^(I_SOURCE string_literal address)
+ {
+ $method::debugInfo.addSetFile($address.address, $string_literal.value);
+ };
statements[int totalMethodRegisters, int methodParameterRegisters] returns[List<Instruction> instructions, int maxOutRegisters]
- @init
- {
- $instructions = new LinkedList<Instruction>();
- $maxOutRegisters = 0;
- }
- : ^(I_STATEMENTS (instruction[$totalMethodRegisters, $methodParameterRegisters, $instructions]
- {
- $method::currentAddress += $instructions.get($instructions.size() - 1).getSize($method::currentAddress);
- if ($maxOutRegisters < $instruction.outRegisters) {
- $maxOutRegisters = $instruction.outRegisters;
- }
- })*);
+ @init
+ {
+ $instructions = new LinkedList<Instruction>();
+ $maxOutRegisters = 0;
+ }
+ : ^(I_STATEMENTS (instruction[$totalMethodRegisters, $methodParameterRegisters, $instructions]
+ {
+ $method::currentAddress += $instructions.get($instructions.size() - 1).getSize($method::currentAddress);
+ if ($maxOutRegisters < $instruction.outRegisters) {
+ $maxOutRegisters = $instruction.outRegisters;
+ }
+ })*);
label_ref returns[int labelAddress]
- : SIMPLE_NAME
- {
- Integer labelAdd = $method::labels.get($SIMPLE_NAME.text);
+ : SIMPLE_NAME
+ {
+ Integer labelAdd = $method::labels.get($SIMPLE_NAME.text);
- if (labelAdd == null) {
- throw new SemanticException(input, $SIMPLE_NAME, "Label \"" + $SIMPLE_NAME.text + "\" is not defined.");
- }
+ if (labelAdd == null) {
+ throw new SemanticException(input, $SIMPLE_NAME, "Label \"" + $SIMPLE_NAME.text + "\" is not defined.");
+ }
- $labelAddress = labelAdd;
- };
+ $labelAddress = labelAdd;
+ };
-offset returns[int offsetValue]
- : OFFSET
- {
- String offsetText = $OFFSET.text;
- if (offsetText.charAt(0) == '+') {
- offsetText = offsetText.substring(1);
- }
- $offsetValue = LiteralTools.parseInt(offsetText);
- };
+offset returns[int offsetValue]
+ : OFFSET
+ {
+ String offsetText = $OFFSET.text;
+ if (offsetText.charAt(0) == '+') {
+ offsetText = offsetText.substring(1);
+ }
+ $offsetValue = LiteralTools.parseInt(offsetText);
+ };
offset_or_label_absolute[int baseAddress] returns[int address]
- : offset {$address = $offset.offsetValue + $baseAddress;}
- | label_ref {$address = $label_ref.labelAddress;};
+ : offset {$address = $offset.offsetValue + $baseAddress;}
+ | label_ref {$address = $label_ref.labelAddress;};
offset_or_label returns[int offsetValue]
- : offset {$offsetValue = $offset.offsetValue;}
- | label_ref {$offsetValue = $label_ref.labelAddress-$method::currentAddress;};
+ : offset {$offsetValue = $offset.offsetValue;}
+ | label_ref {$offsetValue = $label_ref.labelAddress-$method::currentAddress;};
register_list[int totalMethodRegisters, int methodParameterRegisters] returns[byte[\] registers, byte registerCount]
- @init
- {
- $registers = new byte[5];
- $registerCount = 0;
- }
- : ^(I_REGISTER_LIST
- (REGISTER
- {
- if ($registerCount == 5) {
- throw new SemanticException(input, $I_REGISTER_LIST, "A list of registers can only have a maximum of 5 registers. Use the <op>/range alternate opcode instead.");
- }
- $registers[$registerCount++] = parseRegister_nibble($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
- })*);
+ @init
+ {
+ $registers = new byte[5];
+ $registerCount = 0;
+ }
+ : ^(I_REGISTER_LIST
+ (REGISTER
+ {
+ if ($registerCount == 5) {
+ throw new SemanticException(input, $I_REGISTER_LIST, "A list of registers can only have a maximum of 5 registers. Use the <op>/range alternate opcode instead.");
+ }
+ $registers[$registerCount++] = parseRegister_nibble($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
+ })*);
register_range[int totalMethodRegisters, int methodParameterRegisters] returns[int startRegister, int endRegister]
- : ^(I_REGISTER_RANGE (startReg=REGISTER endReg=REGISTER?)?)
- {
- if ($startReg == null) {
- $startRegister = 0;
- $endRegister = -1;
- } else {
+ : ^(I_REGISTER_RANGE (startReg=REGISTER endReg=REGISTER?)?)
+ {
+ if ($startReg == null) {
+ $startRegister = 0;
+ $endRegister = -1;
+ } else {
$startRegister = parseRegister_short($startReg.text, $totalMethodRegisters, $methodParameterRegisters);
if ($endReg == null) {
$endRegister = $startRegister;
@@ -913,539 +914,539 @@
throw new SemanticException(input, $I_REGISTER_RANGE, "A register range must have the lower register listed first");
}
}
- }
- ;
+ }
+ ;
verification_error_reference returns[Item item]
- : CLASS_DESCRIPTOR
- {
- $item = TypeIdItem.internTypeIdItem(dexFile, $start.getText());
- }
- | fully_qualified_field
- {
- $item = $fully_qualified_field.fieldIdItem;
- }
- | fully_qualified_method
- {
- $item = $fully_qualified_method.methodIdItem;
- };
+ : CLASS_DESCRIPTOR
+ {
+ $item = TypeIdItem.internTypeIdItem(dexFile, $start.getText());
+ }
+ | fully_qualified_field
+ {
+ $item = $fully_qualified_field.fieldIdItem;
+ }
+ | fully_qualified_method
+ {
+ $item = $fully_qualified_method.methodIdItem;
+ };
verification_error_type returns[VerificationErrorType verificationErrorType]
- : VERIFICATION_ERROR_TYPE
- {
- $verificationErrorType = VerificationErrorType.fromString($VERIFICATION_ERROR_TYPE.text);
- };
+ : VERIFICATION_ERROR_TYPE
+ {
+ $verificationErrorType = VerificationErrorType.fromString($VERIFICATION_ERROR_TYPE.text);
+ };
instruction[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : insn_format10t[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format10t.outRegisters; }
- | insn_format10x[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format10x.outRegisters; }
- | insn_format11n[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format11n.outRegisters; }
- | insn_format11x[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format11x.outRegisters; }
- | insn_format12x[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format12x.outRegisters; }
- | insn_format20bc[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format20bc.outRegisters; }
- | insn_format20t[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format20t.outRegisters; }
- | insn_format21c_field[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format21c_field.outRegisters; }
- | insn_format21c_string[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format21c_string.outRegisters; }
- | insn_format21c_type[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format21c_type.outRegisters; }
- | insn_format21h[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format21h.outRegisters; }
- | insn_format21s[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format21s.outRegisters; }
- | insn_format21t[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format21t.outRegisters; }
- | insn_format22b[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format22b.outRegisters; }
- | insn_format22c_field[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format22c_field.outRegisters; }
- | insn_format22c_type[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format22c_type.outRegisters; }
- | insn_format22s[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format22s.outRegisters; }
- | insn_format22t[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format22t.outRegisters; }
- | insn_format22x[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format22x.outRegisters; }
- | insn_format23x[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format23x.outRegisters; }
- | insn_format30t[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format30t.outRegisters; }
- | insn_format31c[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format31c.outRegisters; }
- | insn_format31i[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format31i.outRegisters; }
- | insn_format31t[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format31t.outRegisters; }
- | insn_format32x[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format32x.outRegisters; }
- | insn_format35c_method[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format35c_method.outRegisters; }
- | insn_format35c_type[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format35c_type.outRegisters; }
- | insn_format3rc_method[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format3rc_method.outRegisters; }
- | insn_format3rc_type[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format3rc_type.outRegisters; }
- | insn_format51l_type[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format51l_type.outRegisters; }
- | insn_array_data_directive[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_array_data_directive.outRegisters; }
- | insn_packed_switch_directive[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_packed_switch_directive.outRegisters; }
- | insn_sparse_switch_directive[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_sparse_switch_directive.outRegisters; };
+ : insn_format10t[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format10t.outRegisters; }
+ | insn_format10x[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format10x.outRegisters; }
+ | insn_format11n[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format11n.outRegisters; }
+ | insn_format11x[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format11x.outRegisters; }
+ | insn_format12x[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format12x.outRegisters; }
+ | insn_format20bc[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format20bc.outRegisters; }
+ | insn_format20t[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format20t.outRegisters; }
+ | insn_format21c_field[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format21c_field.outRegisters; }
+ | insn_format21c_string[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format21c_string.outRegisters; }
+ | insn_format21c_type[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format21c_type.outRegisters; }
+ | insn_format21h[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format21h.outRegisters; }
+ | insn_format21s[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format21s.outRegisters; }
+ | insn_format21t[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format21t.outRegisters; }
+ | insn_format22b[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format22b.outRegisters; }
+ | insn_format22c_field[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format22c_field.outRegisters; }
+ | insn_format22c_type[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format22c_type.outRegisters; }
+ | insn_format22s[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format22s.outRegisters; }
+ | insn_format22t[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format22t.outRegisters; }
+ | insn_format22x[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format22x.outRegisters; }
+ | insn_format23x[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format23x.outRegisters; }
+ | insn_format30t[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format30t.outRegisters; }
+ | insn_format31c[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format31c.outRegisters; }
+ | insn_format31i[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format31i.outRegisters; }
+ | insn_format31t[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format31t.outRegisters; }
+ | insn_format32x[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format32x.outRegisters; }
+ | insn_format35c_method[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format35c_method.outRegisters; }
+ | insn_format35c_type[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format35c_type.outRegisters; }
+ | insn_format3rc_method[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format3rc_method.outRegisters; }
+ | insn_format3rc_type[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format3rc_type.outRegisters; }
+ | insn_format51l_type[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_format51l_type.outRegisters; }
+ | insn_array_data_directive[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_array_data_directive.outRegisters; }
+ | insn_packed_switch_directive[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_packed_switch_directive.outRegisters; }
+ | insn_sparse_switch_directive[$totalMethodRegisters, $methodParameterRegisters, $instructions] { $outRegisters = $insn_sparse_switch_directive.outRegisters; };
catch [Exception ex] {
- reportError(new SemanticException(input, ex));
- recover(input, null);
- }
+ reportError(new SemanticException(input, ex));
+ recover(input, null);
+ }
insn_format10t[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. goto endloop:
- {$outRegisters = 0;}
- ^(I_STATEMENT_FORMAT10t INSTRUCTION_FORMAT10t offset_or_label)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT10t.text);
+ : //e.g. goto endloop:
+ {$outRegisters = 0;}
+ ^(I_STATEMENT_FORMAT10t INSTRUCTION_FORMAT10t offset_or_label)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT10t.text);
- int addressOffset = $offset_or_label.offsetValue;
+ int addressOffset = $offset_or_label.offsetValue;
- $instructions.add(new Instruction10t(opcode, addressOffset));
- };
+ $instructions.add(new Instruction10t(opcode, addressOffset));
+ };
insn_format10x[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. return
- ^(I_STATEMENT_FORMAT10x INSTRUCTION_FORMAT10x)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT10x.text);
- $instructions.add(new Instruction10x(opcode));
- };
+ : //e.g. return
+ ^(I_STATEMENT_FORMAT10x INSTRUCTION_FORMAT10x)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT10x.text);
+ $instructions.add(new Instruction10x(opcode));
+ };
insn_format11n[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. const/4 v0, 5
- ^(I_STATEMENT_FORMAT11n INSTRUCTION_FORMAT11n REGISTER short_integral_literal)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT11n.text);
- byte regA = parseRegister_nibble($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
+ : //e.g. const/4 v0, 5
+ ^(I_STATEMENT_FORMAT11n INSTRUCTION_FORMAT11n REGISTER short_integral_literal)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT11n.text);
+ byte regA = parseRegister_nibble($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
- short litB = $short_integral_literal.value;
- LiteralTools.checkNibble(litB);
+ short litB = $short_integral_literal.value;
+ LiteralTools.checkNibble(litB);
- $instructions.add(new Instruction11n(opcode, regA, (byte)litB));
- };
+ $instructions.add(new Instruction11n(opcode, regA, (byte)litB));
+ };
insn_format11x[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. move-result-object v1
- ^(I_STATEMENT_FORMAT11x INSTRUCTION_FORMAT11x REGISTER)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT11x.text);
- short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
+ : //e.g. move-result-object v1
+ ^(I_STATEMENT_FORMAT11x INSTRUCTION_FORMAT11x REGISTER)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT11x.text);
+ short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
- $instructions.add(new Instruction11x(opcode, regA));
- };
+ $instructions.add(new Instruction11x(opcode, regA));
+ };
insn_format12x[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. move v1 v2
- ^(I_STATEMENT_FORMAT12x INSTRUCTION_FORMAT12x registerA=REGISTER registerB=REGISTER)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT12x.text);
- byte regA = parseRegister_nibble($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
- byte regB = parseRegister_nibble($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
+ : //e.g. move v1 v2
+ ^(I_STATEMENT_FORMAT12x INSTRUCTION_FORMAT12x registerA=REGISTER registerB=REGISTER)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT12x.text);
+ byte regA = parseRegister_nibble($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
+ byte regB = parseRegister_nibble($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
- $instructions.add(new Instruction12x(opcode, regA, regB));
- };
+ $instructions.add(new Instruction12x(opcode, regA, regB));
+ };
insn_format20bc[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. throw-verification-error generic-error, Lsome/class;
- ^(I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc verification_error_type verification_error_reference)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT20bc.text);
+ : //e.g. throw-verification-error generic-error, Lsome/class;
+ ^(I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc verification_error_type verification_error_reference)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT20bc.text);
- VerificationErrorType verificationErrorType = $verification_error_type.verificationErrorType;
- Item referencedItem = $verification_error_reference.item;
+ VerificationErrorType verificationErrorType = $verification_error_type.verificationErrorType;
+ Item referencedItem = $verification_error_reference.item;
- $instructions.add(new Instruction20bc(opcode, verificationErrorType, referencedItem));
- };
+ $instructions.add(new Instruction20bc(opcode, verificationErrorType, referencedItem));
+ };
insn_format20t[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. goto/16 endloop:
- ^(I_STATEMENT_FORMAT20t INSTRUCTION_FORMAT20t offset_or_label)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT20t.text);
+ : //e.g. goto/16 endloop:
+ ^(I_STATEMENT_FORMAT20t INSTRUCTION_FORMAT20t offset_or_label)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT20t.text);
- int addressOffset = $offset_or_label.offsetValue;
+ int addressOffset = $offset_or_label.offsetValue;
- $instructions.add(new Instruction20t(opcode, addressOffset));
- };
+ $instructions.add(new Instruction20t(opcode, addressOffset));
+ };
insn_format21c_field[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. sget_object v0, java/lang/System/out LJava/io/PrintStream;
- ^(I_STATEMENT_FORMAT21c_FIELD inst=(INSTRUCTION_FORMAT21c_FIELD | INSTRUCTION_FORMAT21c_FIELD_ODEX) REGISTER fully_qualified_field)
- {
- Opcode opcode = Opcode.getOpcodeByName($inst.text);
- short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
+ : //e.g. sget_object v0, java/lang/System/out LJava/io/PrintStream;
+ ^(I_STATEMENT_FORMAT21c_FIELD inst=(INSTRUCTION_FORMAT21c_FIELD | INSTRUCTION_FORMAT21c_FIELD_ODEX) REGISTER fully_qualified_field)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($inst.text);
+ short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
- FieldIdItem fieldIdItem = $fully_qualified_field.fieldIdItem;
+ FieldIdItem fieldIdItem = $fully_qualified_field.fieldIdItem;
- $instructions.add(new Instruction21c(opcode, regA, fieldIdItem));
- };
+ $instructions.add(new Instruction21c(opcode, regA, fieldIdItem));
+ };
insn_format21c_string[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. const-string v1, "Hello World!"
- ^(I_STATEMENT_FORMAT21c_STRING INSTRUCTION_FORMAT21c_STRING REGISTER string_literal)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT21c_STRING.text);
- short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
+ : //e.g. const-string v1, "Hello World!"
+ ^(I_STATEMENT_FORMAT21c_STRING INSTRUCTION_FORMAT21c_STRING REGISTER string_literal)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT21c_STRING.text);
+ short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
- StringIdItem stringIdItem = StringIdItem.internStringIdItem(dexFile, $string_literal.value);
+ StringIdItem stringIdItem = StringIdItem.internStringIdItem(dexFile, $string_literal.value);
- instructions.add(new Instruction21c(opcode, regA, stringIdItem));
- };
+ instructions.add(new Instruction21c(opcode, regA, stringIdItem));
+ };
insn_format21c_type[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. const-class v2, org/jf/HelloWorld2/HelloWorld2
- ^(I_STATEMENT_FORMAT21c_TYPE INSTRUCTION_FORMAT21c_TYPE REGISTER reference_type_descriptor)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT21c_TYPE.text);
- short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
+ : //e.g. const-class v2, org/jf/HelloWorld2/HelloWorld2
+ ^(I_STATEMENT_FORMAT21c_TYPE INSTRUCTION_FORMAT21c_TYPE REGISTER reference_type_descriptor)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT21c_TYPE.text);
+ short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
- TypeIdItem typeIdItem = $reference_type_descriptor.type;
+ TypeIdItem typeIdItem = $reference_type_descriptor.type;
- $instructions.add(new Instruction21c(opcode, regA, typeIdItem));
- };
+ $instructions.add(new Instruction21c(opcode, regA, typeIdItem));
+ };
insn_format21h[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. const/high16 v1, 1234
- ^(I_STATEMENT_FORMAT21h INSTRUCTION_FORMAT21h REGISTER short_integral_literal)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT21h.text);
- short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
+ : //e.g. const/high16 v1, 1234
+ ^(I_STATEMENT_FORMAT21h INSTRUCTION_FORMAT21h REGISTER short_integral_literal)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT21h.text);
+ short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
- short litB = $short_integral_literal.value;
+ short litB = $short_integral_literal.value;
- instructions.add(new Instruction21h(opcode, regA, litB));
- };
+ instructions.add(new Instruction21h(opcode, regA, litB));
+ };
insn_format21s[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. const/16 v1, 1234
- ^(I_STATEMENT_FORMAT21s INSTRUCTION_FORMAT21s REGISTER short_integral_literal)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT21s.text);
- short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
+ : //e.g. const/16 v1, 1234
+ ^(I_STATEMENT_FORMAT21s INSTRUCTION_FORMAT21s REGISTER short_integral_literal)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT21s.text);
+ short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
- short litB = $short_integral_literal.value;
+ short litB = $short_integral_literal.value;
- $instructions.add(new Instruction21s(opcode, regA, litB));
- };
+ $instructions.add(new Instruction21s(opcode, regA, litB));
+ };
insn_format21t[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. if-eqz v0, endloop:
- ^(I_STATEMENT_FORMAT21t INSTRUCTION_FORMAT21t REGISTER offset_or_label)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT21t.text);
- short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
+ : //e.g. if-eqz v0, endloop:
+ ^(I_STATEMENT_FORMAT21t INSTRUCTION_FORMAT21t REGISTER offset_or_label)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT21t.text);
+ short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
- int addressOffset = $offset_or_label.offsetValue;
+ int addressOffset = $offset_or_label.offsetValue;
- if (addressOffset < Short.MIN_VALUE || addressOffset > Short.MAX_VALUE) {
- throw new SemanticException(input, $offset_or_label.start, "The offset/label is out of range. The offset is " + Integer.toString(addressOffset) + " and the range for this opcode is [-32768, 32767].");
- }
+ if (addressOffset < Short.MIN_VALUE || addressOffset > Short.MAX_VALUE) {
+ throw new SemanticException(input, $offset_or_label.start, "The offset/label is out of range. The offset is " + Integer.toString(addressOffset) + " and the range for this opcode is [-32768, 32767].");
+ }
- $instructions.add(new Instruction21t(opcode, regA, (short)addressOffset));
- };
+ $instructions.add(new Instruction21t(opcode, regA, (short)addressOffset));
+ };
insn_format22b[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. add-int v0, v1, 123
- ^(I_STATEMENT_FORMAT22b INSTRUCTION_FORMAT22b registerA=REGISTER registerB=REGISTER short_integral_literal)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT22b.text);
- short regA = parseRegister_byte($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
- short regB = parseRegister_byte($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
+ : //e.g. add-int v0, v1, 123
+ ^(I_STATEMENT_FORMAT22b INSTRUCTION_FORMAT22b registerA=REGISTER registerB=REGISTER short_integral_literal)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT22b.text);
+ short regA = parseRegister_byte($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
+ short regB = parseRegister_byte($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
- short litC = $short_integral_literal.value;
- LiteralTools.checkByte(litC);
+ short litC = $short_integral_literal.value;
+ LiteralTools.checkByte(litC);
- $instructions.add(new Instruction22b(opcode, regA, regB, (byte)litC));
- };
+ $instructions.add(new Instruction22b(opcode, regA, regB, (byte)litC));
+ };
insn_format22c_field[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. iput-object v1, v0, org/jf/HelloWorld2/HelloWorld2.helloWorld Ljava/lang/String;
- ^(I_STATEMENT_FORMAT22c_FIELD inst=(INSTRUCTION_FORMAT22c_FIELD | INSTRUCTION_FORMAT22c_FIELD_ODEX) registerA=REGISTER registerB=REGISTER fully_qualified_field)
- {
- Opcode opcode = Opcode.getOpcodeByName($inst.text);
- byte regA = parseRegister_nibble($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
- byte regB = parseRegister_nibble($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
+ : //e.g. iput-object v1, v0, org/jf/HelloWorld2/HelloWorld2.helloWorld Ljava/lang/String;
+ ^(I_STATEMENT_FORMAT22c_FIELD inst=(INSTRUCTION_FORMAT22c_FIELD | INSTRUCTION_FORMAT22c_FIELD_ODEX) registerA=REGISTER registerB=REGISTER fully_qualified_field)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($inst.text);
+ byte regA = parseRegister_nibble($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
+ byte regB = parseRegister_nibble($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
- FieldIdItem fieldIdItem = $fully_qualified_field.fieldIdItem;
+ FieldIdItem fieldIdItem = $fully_qualified_field.fieldIdItem;
- $instructions.add(new Instruction22c(opcode, regA, regB, fieldIdItem));
- };
+ $instructions.add(new Instruction22c(opcode, regA, regB, fieldIdItem));
+ };
insn_format22c_type[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. instance-of v0, v1, Ljava/lang/String;
- ^(I_STATEMENT_FORMAT22c_TYPE INSTRUCTION_FORMAT22c_TYPE registerA=REGISTER registerB=REGISTER nonvoid_type_descriptor)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT22c_TYPE.text);
- byte regA = parseRegister_nibble($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
- byte regB = parseRegister_nibble($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
+ : //e.g. instance-of v0, v1, Ljava/lang/String;
+ ^(I_STATEMENT_FORMAT22c_TYPE INSTRUCTION_FORMAT22c_TYPE registerA=REGISTER registerB=REGISTER nonvoid_type_descriptor)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT22c_TYPE.text);
+ byte regA = parseRegister_nibble($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
+ byte regB = parseRegister_nibble($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
- TypeIdItem typeIdItem = $nonvoid_type_descriptor.type;
+ TypeIdItem typeIdItem = $nonvoid_type_descriptor.type;
- $instructions.add(new Instruction22c(opcode, regA, regB, typeIdItem));
- };
+ $instructions.add(new Instruction22c(opcode, regA, regB, typeIdItem));
+ };
insn_format22s[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. add-int/lit16 v0, v1, 12345
- ^(I_STATEMENT_FORMAT22s INSTRUCTION_FORMAT22s registerA=REGISTER registerB=REGISTER short_integral_literal)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT22s.text);
- byte regA = parseRegister_nibble($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
- byte regB = parseRegister_nibble($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
+ : //e.g. add-int/lit16 v0, v1, 12345
+ ^(I_STATEMENT_FORMAT22s INSTRUCTION_FORMAT22s registerA=REGISTER registerB=REGISTER short_integral_literal)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT22s.text);
+ byte regA = parseRegister_nibble($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
+ byte regB = parseRegister_nibble($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
- short litC = $short_integral_literal.value;
+ short litC = $short_integral_literal.value;
- $instructions.add(new Instruction22s(opcode, regA, regB, litC));
- };
+ $instructions.add(new Instruction22s(opcode, regA, regB, litC));
+ };
insn_format22t[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. if-eq v0, v1, endloop:
- ^(I_STATEMENT_FORMAT22t INSTRUCTION_FORMAT22t registerA=REGISTER registerB=REGISTER offset_or_label)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT22t.text);
- byte regA = parseRegister_nibble($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
- byte regB = parseRegister_nibble($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
+ : //e.g. if-eq v0, v1, endloop:
+ ^(I_STATEMENT_FORMAT22t INSTRUCTION_FORMAT22t registerA=REGISTER registerB=REGISTER offset_or_label)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT22t.text);
+ byte regA = parseRegister_nibble($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
+ byte regB = parseRegister_nibble($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
- int addressOffset = $offset_or_label.offsetValue;
+ int addressOffset = $offset_or_label.offsetValue;
- if (addressOffset < Short.MIN_VALUE || addressOffset > Short.MAX_VALUE) {
- throw new SemanticException(input, $offset_or_label.start, "The offset/label is out of range. The offset is " + Integer.toString(addressOffset) + " and the range for this opcode is [-32768, 32767].");
- }
+ if (addressOffset < Short.MIN_VALUE || addressOffset > Short.MAX_VALUE) {
+ throw new SemanticException(input, $offset_or_label.start, "The offset/label is out of range. The offset is " + Integer.toString(addressOffset) + " and the range for this opcode is [-32768, 32767].");
+ }
- $instructions.add(new Instruction22t(opcode, regA, regB, (short)addressOffset));
- };
+ $instructions.add(new Instruction22t(opcode, regA, regB, (short)addressOffset));
+ };
insn_format22x[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. move/from16 v1, v1234
- ^(I_STATEMENT_FORMAT22x INSTRUCTION_FORMAT22x registerA=REGISTER registerB=REGISTER)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT22x.text);
- short regA = parseRegister_byte($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
- int regB = parseRegister_short($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
+ : //e.g. move/from16 v1, v1234
+ ^(I_STATEMENT_FORMAT22x INSTRUCTION_FORMAT22x registerA=REGISTER registerB=REGISTER)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT22x.text);
+ short regA = parseRegister_byte($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
+ int regB = parseRegister_short($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
- $instructions.add(new Instruction22x(opcode, regA, regB));
- };
+ $instructions.add(new Instruction22x(opcode, regA, regB));
+ };
insn_format23x[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. add-int v1, v2, v3
- ^(I_STATEMENT_FORMAT23x INSTRUCTION_FORMAT23x registerA=REGISTER registerB=REGISTER registerC=REGISTER)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT23x.text);
- short regA = parseRegister_byte($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
- short regB = parseRegister_byte($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
- short regC = parseRegister_byte($registerC.text, $totalMethodRegisters, $methodParameterRegisters);
+ : //e.g. add-int v1, v2, v3
+ ^(I_STATEMENT_FORMAT23x INSTRUCTION_FORMAT23x registerA=REGISTER registerB=REGISTER registerC=REGISTER)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT23x.text);
+ short regA = parseRegister_byte($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
+ short regB = parseRegister_byte($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
+ short regC = parseRegister_byte($registerC.text, $totalMethodRegisters, $methodParameterRegisters);
- $instructions.add(new Instruction23x(opcode, regA, regB, regC));
- };
+ $instructions.add(new Instruction23x(opcode, regA, regB, regC));
+ };
insn_format30t[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. goto/32 endloop:
- ^(I_STATEMENT_FORMAT30t INSTRUCTION_FORMAT30t offset_or_label)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT30t.text);
+ : //e.g. goto/32 endloop:
+ ^(I_STATEMENT_FORMAT30t INSTRUCTION_FORMAT30t offset_or_label)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT30t.text);
- int addressOffset = $offset_or_label.offsetValue;
+ int addressOffset = $offset_or_label.offsetValue;
- $instructions.add(new Instruction30t(opcode, addressOffset));
- };
+ $instructions.add(new Instruction30t(opcode, addressOffset));
+ };
insn_format31c[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. const-string/jumbo v1 "Hello World!"
- ^(I_STATEMENT_FORMAT31c INSTRUCTION_FORMAT31c REGISTER string_literal)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT31c.text);
- short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
+ : //e.g. const-string/jumbo v1 "Hello World!"
+ ^(I_STATEMENT_FORMAT31c INSTRUCTION_FORMAT31c REGISTER string_literal)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT31c.text);
+ short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
- StringIdItem stringIdItem = StringIdItem.internStringIdItem(dexFile, $string_literal.value);
+ StringIdItem stringIdItem = StringIdItem.internStringIdItem(dexFile, $string_literal.value);
- $instructions.add(new Instruction31c(opcode, regA, stringIdItem));
- };
+ $instructions.add(new Instruction31c(opcode, regA, stringIdItem));
+ };
insn_format31i[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. const v0, 123456
- ^(I_STATEMENT_FORMAT31i INSTRUCTION_FORMAT31i REGISTER fixed_32bit_literal)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT31i.text);
- short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
+ : //e.g. const v0, 123456
+ ^(I_STATEMENT_FORMAT31i INSTRUCTION_FORMAT31i REGISTER fixed_32bit_literal)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT31i.text);
+ short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
- int litB = $fixed_32bit_literal.value;
+ int litB = $fixed_32bit_literal.value;
- $instructions.add(new Instruction31i(opcode, regA, litB));
- };
+ $instructions.add(new Instruction31i(opcode, regA, litB));
+ };
insn_format31t[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. fill-array-data v0, ArrayData:
- ^(I_STATEMENT_FORMAT31t INSTRUCTION_FORMAT31t REGISTER offset_or_label)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT31t.text);
+ : //e.g. fill-array-data v0, ArrayData:
+ ^(I_STATEMENT_FORMAT31t INSTRUCTION_FORMAT31t REGISTER offset_or_label)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT31t.text);
- short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
+ short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
- int addressOffset = $offset_or_label.offsetValue;
- if (($method::currentAddress + addressOffset) \% 2 != 0) {
- addressOffset++;
- }
+ int addressOffset = $offset_or_label.offsetValue;
+ if (($method::currentAddress + addressOffset) \% 2 != 0) {
+ addressOffset++;
+ }
- $instructions.add(new Instruction31t(opcode, regA, addressOffset));
- };
+ $instructions.add(new Instruction31t(opcode, regA, addressOffset));
+ };
insn_format32x[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. move/16 v5678, v1234
- ^(I_STATEMENT_FORMAT32x INSTRUCTION_FORMAT32x registerA=REGISTER registerB=REGISTER)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT32x.text);
- int regA = parseRegister_short($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
- int regB = parseRegister_short($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
+ : //e.g. move/16 v5678, v1234
+ ^(I_STATEMENT_FORMAT32x INSTRUCTION_FORMAT32x registerA=REGISTER registerB=REGISTER)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT32x.text);
+ int regA = parseRegister_short($registerA.text, $totalMethodRegisters, $methodParameterRegisters);
+ int regB = parseRegister_short($registerB.text, $totalMethodRegisters, $methodParameterRegisters);
- $instructions.add(new Instruction32x(opcode, regA, regB));
- };
+ $instructions.add(new Instruction32x(opcode, regA, regB));
+ };
insn_format35c_method[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. invoke-virtual {v0,v1} java/io/PrintStream/print(Ljava/lang/Stream;)V
- ^(I_STATEMENT_FORMAT35c_METHOD INSTRUCTION_FORMAT35c_METHOD register_list[$totalMethodRegisters, $methodParameterRegisters] fully_qualified_method)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT35c_METHOD.text);
+ : //e.g. invoke-virtual {v0,v1} java/io/PrintStream/print(Ljava/lang/Stream;)V
+ ^(I_STATEMENT_FORMAT35c_METHOD INSTRUCTION_FORMAT35c_METHOD register_list[$totalMethodRegisters, $methodParameterRegisters] fully_qualified_method)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT35c_METHOD.text);
- //this depends on the fact that register_list returns a byte[5]
- byte[] registers = $register_list.registers;
- byte registerCount = $register_list.registerCount;
- $outRegisters = registerCount;
+ //this depends on the fact that register_list returns a byte[5]
+ byte[] registers = $register_list.registers;
+ byte registerCount = $register_list.registerCount;
+ $outRegisters = registerCount;
- MethodIdItem methodIdItem = $fully_qualified_method.methodIdItem;
+ MethodIdItem methodIdItem = $fully_qualified_method.methodIdItem;
- $instructions.add(new Instruction35c(opcode, registerCount, registers[0], registers[1], registers[2], registers[3], registers[4], methodIdItem));
- };
+ $instructions.add(new Instruction35c(opcode, registerCount, registers[0], registers[1], registers[2], registers[3], registers[4], methodIdItem));
+ };
insn_format35c_type[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. filled-new-array {v0,v1}, I
- ^(I_STATEMENT_FORMAT35c_TYPE INSTRUCTION_FORMAT35c_TYPE register_list[$totalMethodRegisters, $methodParameterRegisters] nonvoid_type_descriptor)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT35c_TYPE.text);
+ : //e.g. filled-new-array {v0,v1}, I
+ ^(I_STATEMENT_FORMAT35c_TYPE INSTRUCTION_FORMAT35c_TYPE register_list[$totalMethodRegisters, $methodParameterRegisters] nonvoid_type_descriptor)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT35c_TYPE.text);
- //this depends on the fact that register_list returns a byte[5]
- byte[] registers = $register_list.registers;
- byte registerCount = $register_list.registerCount;
- $outRegisters = registerCount;
+ //this depends on the fact that register_list returns a byte[5]
+ byte[] registers = $register_list.registers;
+ byte registerCount = $register_list.registerCount;
+ $outRegisters = registerCount;
- TypeIdItem typeIdItem = $nonvoid_type_descriptor.type;
+ TypeIdItem typeIdItem = $nonvoid_type_descriptor.type;
- $instructions.add(new Instruction35c(opcode, registerCount, registers[0], registers[1], registers[2], registers[3], registers[4], typeIdItem));
- };
+ $instructions.add(new Instruction35c(opcode, registerCount, registers[0], registers[1], registers[2], registers[3], registers[4], typeIdItem));
+ };
insn_format3rc_method[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. invoke-virtual/range {v25..v26} java/lang/StringBuilder/append(Ljava/lang/String;)Ljava/lang/StringBuilder;
- ^(I_STATEMENT_FORMAT3rc_METHOD INSTRUCTION_FORMAT3rc_METHOD register_range[$totalMethodRegisters, $methodParameterRegisters] fully_qualified_method)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT3rc_METHOD.text);
- int startRegister = $register_range.startRegister;
- int endRegister = $register_range.endRegister;
+ : //e.g. invoke-virtual/range {v25..v26} java/lang/StringBuilder/append(Ljava/lang/String;)Ljava/lang/StringBuilder;
+ ^(I_STATEMENT_FORMAT3rc_METHOD INSTRUCTION_FORMAT3rc_METHOD register_range[$totalMethodRegisters, $methodParameterRegisters] fully_qualified_method)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT3rc_METHOD.text);
+ int startRegister = $register_range.startRegister;
+ int endRegister = $register_range.endRegister;
- int registerCount = endRegister-startRegister+1;
- $outRegisters = registerCount;
+ int registerCount = endRegister-startRegister+1;
+ $outRegisters = registerCount;
- MethodIdItem methodIdItem = $fully_qualified_method.methodIdItem;
+ MethodIdItem methodIdItem = $fully_qualified_method.methodIdItem;
- $instructions.add(new Instruction3rc(opcode, (short)registerCount, startRegister, methodIdItem));
- };
+ $instructions.add(new Instruction3rc(opcode, (short)registerCount, startRegister, methodIdItem));
+ };
insn_format3rc_type[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. filled-new-array/range {v0..v6} I
- ^(I_STATEMENT_FORMAT3rc_TYPE INSTRUCTION_FORMAT3rc_TYPE register_range[$totalMethodRegisters, $methodParameterRegisters] nonvoid_type_descriptor)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT3rc_TYPE.text);
- int startRegister = $register_range.startRegister;
- int endRegister = $register_range.endRegister;
+ : //e.g. filled-new-array/range {v0..v6} I
+ ^(I_STATEMENT_FORMAT3rc_TYPE INSTRUCTION_FORMAT3rc_TYPE register_range[$totalMethodRegisters, $methodParameterRegisters] nonvoid_type_descriptor)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT3rc_TYPE.text);
+ int startRegister = $register_range.startRegister;
+ int endRegister = $register_range.endRegister;
- int registerCount = endRegister-startRegister+1;
- $outRegisters = registerCount;
+ int registerCount = endRegister-startRegister+1;
+ $outRegisters = registerCount;
- TypeIdItem typeIdItem = $nonvoid_type_descriptor.type;
+ TypeIdItem typeIdItem = $nonvoid_type_descriptor.type;
- $instructions.add(new Instruction3rc(opcode, (short)registerCount, startRegister, typeIdItem));
- };
+ $instructions.add(new Instruction3rc(opcode, (short)registerCount, startRegister, typeIdItem));
+ };
insn_format51l_type[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. const-wide v0, 5000000000L
- ^(I_STATEMENT_FORMAT51l INSTRUCTION_FORMAT51l REGISTER fixed_64bit_literal)
- {
- Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT51l.text);
- short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
+ : //e.g. const-wide v0, 5000000000L
+ ^(I_STATEMENT_FORMAT51l INSTRUCTION_FORMAT51l REGISTER fixed_64bit_literal)
+ {
+ Opcode opcode = Opcode.getOpcodeByName($INSTRUCTION_FORMAT51l.text);
+ short regA = parseRegister_byte($REGISTER.text, $totalMethodRegisters, $methodParameterRegisters);
- long litB = $fixed_64bit_literal.value;
+ long litB = $fixed_64bit_literal.value;
- $instructions.add(new Instruction51l(opcode, regA, litB));
- };
+ $instructions.add(new Instruction51l(opcode, regA, litB));
+ };
insn_array_data_directive[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- : //e.g. .array-data 4 1000000 .end array-data
- ^(I_STATEMENT_ARRAY_DATA ^(I_ARRAY_ELEMENT_SIZE short_integral_literal) array_elements)
- {
- if (($method::currentAddress \% 2) != 0) {
- $instructions.add(new Instruction10x(Opcode.NOP));
- $method::currentAddress++;
- }
+ : //e.g. .array-data 4 1000000 .end array-data
+ ^(I_STATEMENT_ARRAY_DATA ^(I_ARRAY_ELEMENT_SIZE short_integral_literal) array_elements)
+ {
+ if (($method::currentAddress \% 2) != 0) {
+ $instructions.add(new Instruction10x(Opcode.NOP));
+ $method::currentAddress++;
+ }
- int elementWidth = $short_integral_literal.value;
- List<byte[]> byteValues = $array_elements.values;
+ int elementWidth = $short_integral_literal.value;
+ List<byte[]> byteValues = $array_elements.values;
- int length = 0;
- for (byte[] byteValue: byteValues) {
- length+=byteValue.length;
- }
+ int length = 0;
+ for (byte[] byteValue: byteValues) {
+ length+=byteValue.length;
+ }
- byte[] encodedValues = new byte[length];
- int index = 0;
- for (byte[] byteValue: byteValues) {
- System.arraycopy(byteValue, 0, encodedValues, index, byteValue.length);
- index+=byteValue.length;
- }
+ byte[] encodedValues = new byte[length];
+ int index = 0;
+ for (byte[] byteValue: byteValues) {
+ System.arraycopy(byteValue, 0, encodedValues, index, byteValue.length);
+ index+=byteValue.length;
+ }
- $instructions.add(new ArrayDataPseudoInstruction(elementWidth, encodedValues));
- };
+ $instructions.add(new ArrayDataPseudoInstruction(elementWidth, encodedValues));
+ };
insn_packed_switch_directive[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- :
- ^(I_STATEMENT_PACKED_SWITCH ^(I_PACKED_SWITCH_START_KEY fixed_32bit_literal)
- {
- if (($method::currentAddress \% 2) != 0) {
- $instructions.add(new Instruction10x(Opcode.NOP));
- $method::currentAddress++;
- }
- Integer baseAddress = $method::packedSwitchDeclarations.get($method::currentAddress);
- if (baseAddress == null) {
- baseAddress = 0;
- }
- }
- packed_switch_targets[baseAddress])
- {
+ :
+ ^(I_STATEMENT_PACKED_SWITCH ^(I_PACKED_SWITCH_START_KEY fixed_32bit_literal)
+ {
+ if (($method::currentAddress \% 2) != 0) {
+ $instructions.add(new Instruction10x(Opcode.NOP));
+ $method::currentAddress++;
+ }
+ Integer baseAddress = $method::packedSwitchDeclarations.get($method::currentAddress);
+ if (baseAddress == null) {
+ baseAddress = 0;
+ }
+ }
+ packed_switch_targets[baseAddress])
+ {
- int startKey = $fixed_32bit_literal.value;
- int[] targets = $packed_switch_targets.targets;
+ int startKey = $fixed_32bit_literal.value;
+ int[] targets = $packed_switch_targets.targets;
- $instructions.add(new PackedSwitchDataPseudoInstruction(startKey, targets));
- };
+ $instructions.add(new PackedSwitchDataPseudoInstruction(startKey, targets));
+ };
insn_sparse_switch_directive[int totalMethodRegisters, int methodParameterRegisters, List<Instruction> instructions] returns[int outRegisters]
- :
- ^(I_STATEMENT_SPARSE_SWITCH sparse_switch_target_count sparse_switch_keys[$sparse_switch_target_count.targetCount]
- {
- if (($method::currentAddress \% 2) != 0) {
- $instructions.add(new Instruction10x(Opcode.NOP));
- $method::currentAddress++;
- }
- Integer baseAddress = $method::sparseSwitchDeclarations.get($method::currentAddress);
- if (baseAddress == null) {
- baseAddress = 0;
- }
- }
+ :
+ ^(I_STATEMENT_SPARSE_SWITCH sparse_switch_target_count sparse_switch_keys[$sparse_switch_target_count.targetCount]
+ {
+ if (($method::currentAddress \% 2) != 0) {
+ $instructions.add(new Instruction10x(Opcode.NOP));
+ $method::currentAddress++;
+ }
+ Integer baseAddress = $method::sparseSwitchDeclarations.get($method::currentAddress);
+ if (baseAddress == null) {
+ baseAddress = 0;
+ }
+ }
- sparse_switch_targets[baseAddress, $sparse_switch_target_count.targetCount])
- {
- int[] keys = $sparse_switch_keys.keys;
- int[] targets = $sparse_switch_targets.targets;
+ sparse_switch_targets[baseAddress, $sparse_switch_target_count.targetCount])
+ {
+ int[] keys = $sparse_switch_keys.keys;
+ int[] targets = $sparse_switch_targets.targets;
- $instructions.add(new SparseSwitchDataPseudoInstruction(keys, targets));
- };
+ $instructions.add(new SparseSwitchDataPseudoInstruction(keys, targets));
+ };
nonvoid_type_descriptor returns [TypeIdItem type]
- : (PRIMITIVE_TYPE
- | CLASS_DESCRIPTOR
- | ARRAY_DESCRIPTOR)
- {
- $type = TypeIdItem.internTypeIdItem(dexFile, $start.getText());
- };
+ : (PRIMITIVE_TYPE
+ | CLASS_DESCRIPTOR
+ | ARRAY_DESCRIPTOR)
+ {
+ $type = TypeIdItem.internTypeIdItem(dexFile, $start.getText());
+ };
reference_type_descriptor returns [TypeIdItem type]
- : (CLASS_DESCRIPTOR
- | ARRAY_DESCRIPTOR)
- {
- $type = TypeIdItem.internTypeIdItem(dexFile, $start.getText());
- };
+ : (CLASS_DESCRIPTOR
+ | ARRAY_DESCRIPTOR)
+ {
+ $type = TypeIdItem.internTypeIdItem(dexFile, $start.getText());
+ };
@@ -1453,140 +1454,142 @@
class_type_descriptor returns [TypeIdItem type]
- : CLASS_DESCRIPTOR
- {
- $type = TypeIdItem.internTypeIdItem(dexFile, $CLASS_DESCRIPTOR.text);
- };
+ : CLASS_DESCRIPTOR
+ {
+ $type = TypeIdItem.internTypeIdItem(dexFile, $CLASS_DESCRIPTOR.text);
+ };
type_descriptor returns [TypeIdItem type]
- : VOID_TYPE {$type = TypeIdItem.internTypeIdItem(dexFile, "V");}
- | nonvoid_type_descriptor {$type = $nonvoid_type_descriptor.type;}
- ;
+ : VOID_TYPE {$type = TypeIdItem.internTypeIdItem(dexFile, "V");}
+ | nonvoid_type_descriptor {$type = $nonvoid_type_descriptor.type;}
+ ;
short_integral_literal returns[short value]
- : long_literal
- {
- LiteralTools.checkShort($long_literal.value);
- $value = (short)$long_literal.value;
- }
- | integer_literal
- {
- LiteralTools.checkShort($integer_literal.value);
- $value = (short)$integer_literal.value;
- }
- | short_literal {$value = $short_literal.value;}
- | char_literal {$value = (short)$char_literal.value;}
- | byte_literal {$value = $byte_literal.value;};
+ : long_literal
+ {
+ LiteralTools.checkShort($long_literal.value);
+ $value = (short)$long_literal.value;
+ }
+ | integer_literal
+ {
+ LiteralTools.checkShort($integer_literal.value);
+ $value = (short)$integer_literal.value;
+ }
+ | short_literal {$value = $short_literal.value;}
+ | char_literal {$value = (short)$char_literal.value;}
+ | byte_literal {$value = $byte_literal.value;};
integral_literal returns[int value]
- : long_literal
- {
- LiteralTools.checkInt($long_literal.value);
- $value = (int)$long_literal.value;
- }
- | integer_literal {$value = $integer_literal.value;}
- | short_literal {$value = $short_literal.value;}
- | byte_literal {$value = $byte_literal.value;};
+ : long_literal
+ {
+ LiteralTools.checkInt($long_literal.value);
+ $value = (int)$long_literal.value;
+ }
+ | integer_literal {$value = $integer_literal.value;}
+ | short_literal {$value = $short_literal.value;}
+ | byte_literal {$value = $byte_literal.value;};
integer_literal returns[int value]
- : INTEGER_LITERAL { $value = LiteralTools.parseInt($INTEGER_LITERAL.text); };
+ : INTEGER_LITERAL { $value = LiteralTools.parseInt($INTEGER_LITERAL.text); };
long_literal returns[long value]
- : LONG_LITERAL { $value = LiteralTools.parseLong($LONG_LITERAL.text); };
+ : LONG_LITERAL { $value = LiteralTools.parseLong($LONG_LITERAL.text); };
short_literal returns[short value]
- : SHORT_LITERAL { $value = LiteralTools.parseShort($SHORT_LITERAL.text); };
+ : SHORT_LITERAL { $value = LiteralTools.parseShort($SHORT_LITERAL.text); };
byte_literal returns[byte value]
- : BYTE_LITERAL { $value = LiteralTools.parseByte($BYTE_LITERAL.text); };
+ : BYTE_LITERAL { $value = LiteralTools.parseByte($BYTE_LITERAL.text); };
float_literal returns[float value]
- : FLOAT_LITERAL { $value = parseFloat($FLOAT_LITERAL.text); };
+ : FLOAT_LITERAL { $value = parseFloat($FLOAT_LITERAL.text); };
double_literal returns[double value]
- : DOUBLE_LITERAL { $value = parseDouble($DOUBLE_LITERAL.text); };
+ : DOUBLE_LITERAL { $value = parseDouble($DOUBLE_LITERAL.text); };
char_literal returns[char value]
- : CHAR_LITERAL { $value = $CHAR_LITERAL.text.charAt(1); };
+ : CHAR_LITERAL { $value = $CHAR_LITERAL.text.charAt(1); };
string_literal returns[String value]
- : STRING_LITERAL
- {
- $value = $STRING_LITERAL.text;
- $value = $value.substring(1,$value.length()-1);
- };
+ : STRING_LITERAL
+ {
+ $value = $STRING_LITERAL.text;
+ $value = $value.substring(1,$value.length()-1);
+ };
bool_literal returns[boolean value]
- : BOOL_LITERAL { $value = Boolean.parseBoolean($BOOL_LITERAL.text); };
+ : BOOL_LITERAL { $value = Boolean.parseBoolean($BOOL_LITERAL.text); };
array_literal returns[EncodedValue[\] values]
- : {ArrayList<EncodedValue> valuesList = new ArrayList<EncodedValue>();}
- ^(I_ENCODED_ARRAY (literal {valuesList.add($literal.encodedValue);})*)
- {
- $values = new EncodedValue[valuesList.size()];
- valuesList.toArray($values);
- };
+ : {ArrayList<EncodedValue> valuesList = new ArrayList<EncodedValue>();}
+ ^(I_ENCODED_ARRAY (literal {valuesList.add($literal.encodedValue);})*)
+ {
+ $values = new EncodedValue[valuesList.size()];
+ valuesList.toArray($values);
+ };
annotations returns[AnnotationSetItem annotationSetItem]
- : {ArrayList<AnnotationItem> annotationList = new ArrayList<AnnotationItem>();}
- ^(I_ANNOTATIONS (annotation {annotationList.add($annotation.annotationItem);} )*)
- {
- if (annotationList.size() > 0) {
- $annotationSetItem = AnnotationSetItem.internAnnotationSetItem(dexFile, annotationList);
- }
- };
+ : {ArrayList<AnnotationItem> annotationList = new ArrayList<AnnotationItem>();}
+ ^(I_ANNOTATIONS (annotation {annotationList.add($annotation.annotationItem);} )*)
+ {
+ if (annotationList.size() > 0) {
+ $annotationSetItem = AnnotationSetItem.internAnnotationSetItem(dexFile, annotationList);
+ }
+ };
annotation returns[AnnotationItem annotationItem]
- : ^(I_ANNOTATION ANNOTATION_VISIBILITY subannotation)
- {
- AnnotationVisibility visibility = AnnotationVisibility.valueOf($ANNOTATION_VISIBILITY.text.toUpperCase());
- AnnotationEncodedSubValue encodedAnnotation = new AnnotationEncodedSubValue($subannotation.annotationType,
- $subannotation.elementNames, $subannotation.elementValues);
- $annotationItem = AnnotationItem.internAnnotationItem(dexFile, visibility, encodedAnnotation);
- };
+ : ^(I_ANNOTATION ANNOTATION_VISIBILITY subannotation)
+ {
+ AnnotationVisibility visibility = AnnotationVisibility.valueOf($ANNOTATION_VISIBILITY.text.toUpperCase());
+ AnnotationEncodedSubValue encodedAnnotation = new AnnotationEncodedSubValue($subannotation.annotationType,
+ $subannotation.elementNames, $subannotation.elementValues);
+ $annotationItem = AnnotationItem.internAnnotationItem(dexFile, visibility, encodedAnnotation);
+ };
annotation_element returns[StringIdItem elementName, EncodedValue elementValue]
- : ^(I_ANNOTATION_ELEMENT SIMPLE_NAME literal)
- {
- $elementName = StringIdItem.internStringIdItem(dexFile, $SIMPLE_NAME.text);
- $elementValue = $literal.encodedValue;
- };
+ : ^(I_ANNOTATION_ELEMENT SIMPLE_NAME literal)
+ {
+ $elementName = StringIdItem.internStringIdItem(dexFile, $SIMPLE_NAME.text);
+ $elementValue = $literal.encodedValue;
+ };
subannotation returns[TypeIdItem annotationType, StringIdItem[\] elementNames, EncodedValue[\] elementValues]
- : {ArrayList<StringIdItem> elementNamesList = new ArrayList<StringIdItem>();
- ArrayList<EncodedValue> elementValuesList = new ArrayList<EncodedValue>();}
- ^( I_SUBANNOTATION
- class_type_descriptor
- (annotation_element
- {
- elementNamesList.add($annotation_element.elementName);
- elementValuesList.add($annotation_element.elementValue);
- } )* )
- {
- $annotationType = $class_type_descriptor.type;
- $elementNames = new StringIdItem[elementNamesList.size()];
- elementNamesList.toArray($elementNames);
- $elementValues = new EncodedValue[elementValuesList.size()];
- elementValuesList.toArray($elementValues);
- };
+ : {ArrayList<StringIdItem> elementNamesList = new ArrayList<StringIdItem>();
+ ArrayList<EncodedValue> elementValuesList = new ArrayList<EncodedValue>();}
+ ^(I_SUBANNOTATION
+ class_type_descriptor
+ (annotation_element
+ {
+ elementNamesList.add($annotation_element.elementName);
+ elementValuesList.add($annotation_element.elementValue);
+ }
+ )*
+ )
+ {
+ $annotationType = $class_type_descriptor.type;
+ $elementNames = new StringIdItem[elementNamesList.size()];
+ elementNamesList.toArray($elementNames);
+ $elementValues = new EncodedValue[elementValuesList.size()];
+ elementValuesList.toArray($elementValues);
+ };
field_literal returns[FieldIdItem value]
- : ^(I_ENCODED_FIELD fully_qualified_field)
- {
- $value = $fully_qualified_field.fieldIdItem;
- };
+ : ^(I_ENCODED_FIELD fully_qualified_field)
+ {
+ $value = $fully_qualified_field.fieldIdItem;
+ };
method_literal returns[MethodIdItem value]
- : ^(I_ENCODED_METHOD fully_qualified_method)
- {
- $value = $fully_qualified_method.methodIdItem;
- };
+ : ^(I_ENCODED_METHOD fully_qualified_method)
+ {
+ $value = $fully_qualified_method.methodIdItem;
+ };
enum_literal returns[FieldIdItem value]
- : ^(I_ENCODED_ENUM fully_qualified_field)
- {
- $value = $fully_qualified_field.fieldIdItem;
- };
+ : ^(I_ENCODED_ENUM fully_qualified_field)
+ {
+ $value = $fully_qualified_field.fieldIdItem;
+ };
diff --git a/util/src/main/java/ds/tree/RadixTreeNode.java b/util/src/main/java/ds/tree/RadixTreeNode.java
index 287e0e9..fabdd38 100644
--- a/util/src/main/java/ds/tree/RadixTreeNode.java
+++ b/util/src/main/java/ds/tree/RadixTreeNode.java
@@ -85,19 +85,19 @@
this.childern = childern;
}
- public int getNumberOfMatchingCharacters(String key) {
- int numberOfMatchingCharacters = 0;
+ public int getNumberOfMatchingCharacters(String key) {
+ int numberOfMatchingCharacters = 0;
while (numberOfMatchingCharacters < key.length() && numberOfMatchingCharacters < this.getKey().length()) {
if (key.charAt(numberOfMatchingCharacters) != this.getKey().charAt(numberOfMatchingCharacters)) {
break;
}
numberOfMatchingCharacters++;
}
- return numberOfMatchingCharacters;
- }
+ return numberOfMatchingCharacters;
+ }
@Override
public String toString() {
- return key;
+ return key;
}
}
diff --git a/util/src/main/java/ds/tree/VisitorImpl.java b/util/src/main/java/ds/tree/VisitorImpl.java
index 20409e0..ff4e8d1 100644
--- a/util/src/main/java/ds/tree/VisitorImpl.java
+++ b/util/src/main/java/ds/tree/VisitorImpl.java
@@ -11,17 +11,17 @@
protected R result;
- public VisitorImpl() {
- this.result = null;
- }
+ public VisitorImpl() {
+ this.result = null;
+ }
- public VisitorImpl(R initialValue) {
- this.result = initialValue;
- }
+ public VisitorImpl(R initialValue) {
+ this.result = initialValue;
+ }
- public R getResult() {
- return result;
- }
+ public R getResult() {
+ return result;
+ }
- abstract public void visit(String key, RadixTreeNode<T> parent, RadixTreeNode<T> node);
+ abstract public void visit(String key, RadixTreeNode<T> parent, RadixTreeNode<T> node);
}
\ No newline at end of file
