| // $ANTLR 3.5 /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g 2015-02-19 13:37:39 |
| |
| package org.jf.smali; |
| |
| import com.google.common.collect.ImmutableSet; |
| import com.google.common.collect.Iterables; |
| import com.google.common.collect.Lists; |
| import com.google.common.collect.Maps; |
| import org.antlr.runtime.BitSet; |
| import org.antlr.runtime.*; |
| import org.antlr.runtime.tree.CommonTree; |
| import org.antlr.runtime.tree.TreeNodeStream; |
| import org.antlr.runtime.tree.TreeParser; |
| import org.antlr.runtime.tree.TreeRuleReturnScope; |
| import org.jf.dexlib2.*; |
| import org.jf.dexlib2.builder.Label; |
| import org.jf.dexlib2.builder.MethodImplementationBuilder; |
| import org.jf.dexlib2.builder.SwitchLabelElement; |
| import org.jf.dexlib2.builder.instruction.*; |
| import org.jf.dexlib2.iface.Annotation; |
| import org.jf.dexlib2.iface.AnnotationElement; |
| import org.jf.dexlib2.iface.ClassDef; |
| import org.jf.dexlib2.iface.MethodImplementation; |
| import org.jf.dexlib2.iface.reference.FieldReference; |
| import org.jf.dexlib2.iface.reference.MethodReference; |
| import org.jf.dexlib2.iface.value.EncodedValue; |
| import org.jf.dexlib2.immutable.ImmutableAnnotation; |
| import org.jf.dexlib2.immutable.ImmutableAnnotationElement; |
| import org.jf.dexlib2.immutable.reference.ImmutableFieldReference; |
| import org.jf.dexlib2.immutable.reference.ImmutableMethodReference; |
| import org.jf.dexlib2.immutable.reference.ImmutableReference; |
| import org.jf.dexlib2.immutable.reference.ImmutableTypeReference; |
| import org.jf.dexlib2.immutable.value.*; |
| import org.jf.dexlib2.util.MethodUtil; |
| import org.jf.dexlib2.writer.InstructionFactory; |
| import org.jf.dexlib2.writer.builder.*; |
| import org.jf.util.LinearSearch; |
| |
| import java.util.*; |
| |
| |
| import org.antlr.runtime.*; |
| import org.antlr.runtime.tree.*; |
| import java.util.Stack; |
| import java.util.List; |
| import java.util.ArrayList; |
| |
| @SuppressWarnings("all") |
| public class smaliTreeWalker extends TreeParser { |
| public static final String[] tokenNames = new String[] { |
| "<invalid>", "<EOR>", "<DOWN>", "<UP>", "ACCESS_SPEC", "ANNOTATION_DIRECTIVE", |
| "ANNOTATION_VISIBILITY", "ARRAY_DATA_DIRECTIVE", "ARRAY_DESCRIPTOR", "ARROW", |
| "BOOL_LITERAL", "BYTE_LITERAL", "CATCHALL_DIRECTIVE", "CATCH_DIRECTIVE", |
| "CHAR_LITERAL", "CLASS_DESCRIPTOR", "CLASS_DIRECTIVE", "CLOSE_BRACE", |
| "CLOSE_PAREN", "COLON", "COMMA", "DOTDOT", "DOUBLE_LITERAL", "DOUBLE_LITERAL_OR_ID", |
| "END_ANNOTATION_DIRECTIVE", "END_ARRAY_DATA_DIRECTIVE", "END_FIELD_DIRECTIVE", |
| "END_LOCAL_DIRECTIVE", "END_METHOD_DIRECTIVE", "END_PACKED_SWITCH_DIRECTIVE", |
| "END_PARAMETER_DIRECTIVE", "END_SPARSE_SWITCH_DIRECTIVE", "END_SUBANNOTATION_DIRECTIVE", |
| "ENUM_DIRECTIVE", "EPILOGUE_DIRECTIVE", "EQUAL", "FIELD_DIRECTIVE", "FIELD_OFFSET", |
| "FLOAT_LITERAL", "FLOAT_LITERAL_OR_ID", "IMPLEMENTS_DIRECTIVE", "INLINE_INDEX", |
| "INSTRUCTION_FORMAT10t", "INSTRUCTION_FORMAT10x", "INSTRUCTION_FORMAT10x_ODEX", |
| "INSTRUCTION_FORMAT11n", "INSTRUCTION_FORMAT11x", "INSTRUCTION_FORMAT12x", |
| "INSTRUCTION_FORMAT12x_OR_ID", "INSTRUCTION_FORMAT20bc", "INSTRUCTION_FORMAT20t", |
| "INSTRUCTION_FORMAT21c_FIELD", "INSTRUCTION_FORMAT21c_FIELD_ODEX", "INSTRUCTION_FORMAT21c_STRING", |
| "INSTRUCTION_FORMAT21c_TYPE", "INSTRUCTION_FORMAT21ih", "INSTRUCTION_FORMAT21lh", |
| "INSTRUCTION_FORMAT21s", "INSTRUCTION_FORMAT21t", "INSTRUCTION_FORMAT22b", |
| "INSTRUCTION_FORMAT22c_FIELD", "INSTRUCTION_FORMAT22c_FIELD_ODEX", "INSTRUCTION_FORMAT22c_TYPE", |
| "INSTRUCTION_FORMAT22cs_FIELD", "INSTRUCTION_FORMAT22s", "INSTRUCTION_FORMAT22s_OR_ID", |
| "INSTRUCTION_FORMAT22t", "INSTRUCTION_FORMAT22x", "INSTRUCTION_FORMAT23x", |
| "INSTRUCTION_FORMAT30t", "INSTRUCTION_FORMAT31c", "INSTRUCTION_FORMAT31i", |
| "INSTRUCTION_FORMAT31i_OR_ID", "INSTRUCTION_FORMAT31t", "INSTRUCTION_FORMAT32x", |
| "INSTRUCTION_FORMAT35c_METHOD", "INSTRUCTION_FORMAT35c_METHOD_ODEX", "INSTRUCTION_FORMAT35c_TYPE", |
| "INSTRUCTION_FORMAT35mi_METHOD", "INSTRUCTION_FORMAT35ms_METHOD", "INSTRUCTION_FORMAT3rc_METHOD", |
| "INSTRUCTION_FORMAT3rc_METHOD_ODEX", "INSTRUCTION_FORMAT3rc_TYPE", "INSTRUCTION_FORMAT3rmi_METHOD", |
| "INSTRUCTION_FORMAT3rms_METHOD", "INSTRUCTION_FORMAT51l", "INTEGER_LITERAL", |
| "INVALID_TOKEN", "I_ACCESS_LIST", "I_ANNOTATION", "I_ANNOTATIONS", "I_ANNOTATION_ELEMENT", |
| "I_ARRAY_ELEMENTS", "I_ARRAY_ELEMENT_SIZE", "I_CATCH", "I_CATCHALL", "I_CATCHES", |
| "I_CLASS_DEF", "I_ENCODED_ARRAY", "I_ENCODED_ENUM", "I_ENCODED_FIELD", |
| "I_ENCODED_METHOD", "I_END_LOCAL", "I_EPILOGUE", "I_FIELD", "I_FIELDS", |
| "I_FIELD_INITIAL_VALUE", "I_FIELD_TYPE", "I_IMPLEMENTS", "I_LABEL", "I_LINE", |
| "I_LOCAL", "I_LOCALS", "I_METHOD", "I_METHODS", "I_METHOD_PROTOTYPE", |
| "I_METHOD_RETURN_TYPE", "I_ORDERED_METHOD_ITEMS", "I_PACKED_SWITCH_ELEMENTS", |
| "I_PACKED_SWITCH_START_KEY", "I_PARAMETER", "I_PARAMETERS", "I_PARAMETER_NOT_SPECIFIED", |
| "I_PROLOGUE", "I_REGISTERS", "I_REGISTER_LIST", "I_REGISTER_RANGE", "I_RESTART_LOCAL", |
| "I_SOURCE", "I_SPARSE_SWITCH_ELEMENTS", "I_STATEMENT_ARRAY_DATA", "I_STATEMENT_FORMAT10t", |
| "I_STATEMENT_FORMAT10x", "I_STATEMENT_FORMAT11n", "I_STATEMENT_FORMAT11x", |
| "I_STATEMENT_FORMAT12x", "I_STATEMENT_FORMAT20bc", "I_STATEMENT_FORMAT20t", |
| "I_STATEMENT_FORMAT21c_FIELD", "I_STATEMENT_FORMAT21c_STRING", "I_STATEMENT_FORMAT21c_TYPE", |
| "I_STATEMENT_FORMAT21ih", "I_STATEMENT_FORMAT21lh", "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_PACKED_SWITCH", "I_STATEMENT_SPARSE_SWITCH", "I_SUBANNOTATION", |
| "I_SUPER", "LINE_COMMENT", "LINE_DIRECTIVE", "LOCALS_DIRECTIVE", "LOCAL_DIRECTIVE", |
| "LONG_LITERAL", "MEMBER_NAME", "METHOD_DIRECTIVE", "NEGATIVE_INTEGER_LITERAL", |
| "NULL_LITERAL", "OPEN_BRACE", "OPEN_PAREN", "PACKED_SWITCH_DIRECTIVE", |
| "PARAMETER_DIRECTIVE", "PARAM_LIST_END", "PARAM_LIST_OR_ID_END", "PARAM_LIST_OR_ID_START", |
| "PARAM_LIST_START", "POSITIVE_INTEGER_LITERAL", "PRIMITIVE_TYPE", "PROLOGUE_DIRECTIVE", |
| "REGISTER", "REGISTERS_DIRECTIVE", "RESTART_LOCAL_DIRECTIVE", "SHORT_LITERAL", |
| "SIMPLE_NAME", "SOURCE_DIRECTIVE", "SPARSE_SWITCH_DIRECTIVE", "STRING_LITERAL", |
| "SUBANNOTATION_DIRECTIVE", "SUPER_DIRECTIVE", "VERIFICATION_ERROR_TYPE", |
| "VOID_TYPE", "VTABLE_INDEX", "WHITE_SPACE" |
| }; |
| public static final int EOF=-1; |
| public static final int ACCESS_SPEC=4; |
| public static final int ANNOTATION_DIRECTIVE=5; |
| public static final int ANNOTATION_VISIBILITY=6; |
| public static final int ARRAY_DATA_DIRECTIVE=7; |
| public static final int ARRAY_DESCRIPTOR=8; |
| public static final int ARROW=9; |
| public static final int BOOL_LITERAL=10; |
| public static final int BYTE_LITERAL=11; |
| public static final int CATCHALL_DIRECTIVE=12; |
| public static final int CATCH_DIRECTIVE=13; |
| public static final int CHAR_LITERAL=14; |
| public static final int CLASS_DESCRIPTOR=15; |
| public static final int CLASS_DIRECTIVE=16; |
| public static final int CLOSE_BRACE=17; |
| public static final int CLOSE_PAREN=18; |
| public static final int COLON=19; |
| public static final int COMMA=20; |
| public static final int DOTDOT=21; |
| public static final int DOUBLE_LITERAL=22; |
| public static final int DOUBLE_LITERAL_OR_ID=23; |
| public static final int END_ANNOTATION_DIRECTIVE=24; |
| public static final int END_ARRAY_DATA_DIRECTIVE=25; |
| public static final int END_FIELD_DIRECTIVE=26; |
| public static final int END_LOCAL_DIRECTIVE=27; |
| public static final int END_METHOD_DIRECTIVE=28; |
| public static final int END_PACKED_SWITCH_DIRECTIVE=29; |
| public static final int END_PARAMETER_DIRECTIVE=30; |
| public static final int END_SPARSE_SWITCH_DIRECTIVE=31; |
| public static final int END_SUBANNOTATION_DIRECTIVE=32; |
| public static final int ENUM_DIRECTIVE=33; |
| public static final int EPILOGUE_DIRECTIVE=34; |
| public static final int EQUAL=35; |
| public static final int FIELD_DIRECTIVE=36; |
| public static final int FIELD_OFFSET=37; |
| public static final int FLOAT_LITERAL=38; |
| public static final int FLOAT_LITERAL_OR_ID=39; |
| public static final int IMPLEMENTS_DIRECTIVE=40; |
| public static final int INLINE_INDEX=41; |
| public static final int INSTRUCTION_FORMAT10t=42; |
| public static final int INSTRUCTION_FORMAT10x=43; |
| public static final int INSTRUCTION_FORMAT10x_ODEX=44; |
| public static final int INSTRUCTION_FORMAT11n=45; |
| public static final int INSTRUCTION_FORMAT11x=46; |
| public static final int INSTRUCTION_FORMAT12x=47; |
| public static final int INSTRUCTION_FORMAT12x_OR_ID=48; |
| public static final int INSTRUCTION_FORMAT20bc=49; |
| public static final int INSTRUCTION_FORMAT20t=50; |
| public static final int INSTRUCTION_FORMAT21c_FIELD=51; |
| public static final int INSTRUCTION_FORMAT21c_FIELD_ODEX=52; |
| public static final int INSTRUCTION_FORMAT21c_STRING=53; |
| public static final int INSTRUCTION_FORMAT21c_TYPE=54; |
| public static final int INSTRUCTION_FORMAT21ih=55; |
| public static final int INSTRUCTION_FORMAT21lh=56; |
| public static final int INSTRUCTION_FORMAT21s=57; |
| public static final int INSTRUCTION_FORMAT21t=58; |
| public static final int INSTRUCTION_FORMAT22b=59; |
| public static final int INSTRUCTION_FORMAT22c_FIELD=60; |
| public static final int INSTRUCTION_FORMAT22c_FIELD_ODEX=61; |
| public static final int INSTRUCTION_FORMAT22c_TYPE=62; |
| public static final int INSTRUCTION_FORMAT22cs_FIELD=63; |
| public static final int INSTRUCTION_FORMAT22s=64; |
| public static final int INSTRUCTION_FORMAT22s_OR_ID=65; |
| public static final int INSTRUCTION_FORMAT22t=66; |
| public static final int INSTRUCTION_FORMAT22x=67; |
| public static final int INSTRUCTION_FORMAT23x=68; |
| public static final int INSTRUCTION_FORMAT30t=69; |
| public static final int INSTRUCTION_FORMAT31c=70; |
| public static final int INSTRUCTION_FORMAT31i=71; |
| public static final int INSTRUCTION_FORMAT31i_OR_ID=72; |
| public static final int INSTRUCTION_FORMAT31t=73; |
| public static final int INSTRUCTION_FORMAT32x=74; |
| public static final int INSTRUCTION_FORMAT35c_METHOD=75; |
| public static final int INSTRUCTION_FORMAT35c_METHOD_ODEX=76; |
| public static final int INSTRUCTION_FORMAT35c_TYPE=77; |
| public static final int INSTRUCTION_FORMAT35mi_METHOD=78; |
| public static final int INSTRUCTION_FORMAT35ms_METHOD=79; |
| public static final int INSTRUCTION_FORMAT3rc_METHOD=80; |
| public static final int INSTRUCTION_FORMAT3rc_METHOD_ODEX=81; |
| public static final int INSTRUCTION_FORMAT3rc_TYPE=82; |
| public static final int INSTRUCTION_FORMAT3rmi_METHOD=83; |
| public static final int INSTRUCTION_FORMAT3rms_METHOD=84; |
| public static final int INSTRUCTION_FORMAT51l=85; |
| public static final int INTEGER_LITERAL=86; |
| public static final int INVALID_TOKEN=87; |
| public static final int I_ACCESS_LIST=88; |
| public static final int I_ANNOTATION=89; |
| public static final int I_ANNOTATIONS=90; |
| public static final int I_ANNOTATION_ELEMENT=91; |
| public static final int I_ARRAY_ELEMENTS=92; |
| public static final int I_ARRAY_ELEMENT_SIZE=93; |
| public static final int I_CATCH=94; |
| public static final int I_CATCHALL=95; |
| public static final int I_CATCHES=96; |
| public static final int I_CLASS_DEF=97; |
| public static final int I_ENCODED_ARRAY=98; |
| public static final int I_ENCODED_ENUM=99; |
| public static final int I_ENCODED_FIELD=100; |
| public static final int I_ENCODED_METHOD=101; |
| public static final int I_END_LOCAL=102; |
| public static final int I_EPILOGUE=103; |
| public static final int I_FIELD=104; |
| public static final int I_FIELDS=105; |
| public static final int I_FIELD_INITIAL_VALUE=106; |
| public static final int I_FIELD_TYPE=107; |
| public static final int I_IMPLEMENTS=108; |
| public static final int I_LABEL=109; |
| public static final int I_LINE=110; |
| public static final int I_LOCAL=111; |
| public static final int I_LOCALS=112; |
| public static final int I_METHOD=113; |
| public static final int I_METHODS=114; |
| public static final int I_METHOD_PROTOTYPE=115; |
| public static final int I_METHOD_RETURN_TYPE=116; |
| public static final int I_ORDERED_METHOD_ITEMS=117; |
| public static final int I_PACKED_SWITCH_ELEMENTS=118; |
| public static final int I_PACKED_SWITCH_START_KEY=119; |
| public static final int I_PARAMETER=120; |
| public static final int I_PARAMETERS=121; |
| public static final int I_PARAMETER_NOT_SPECIFIED=122; |
| public static final int I_PROLOGUE=123; |
| public static final int I_REGISTERS=124; |
| public static final int I_REGISTER_LIST=125; |
| public static final int I_REGISTER_RANGE=126; |
| public static final int I_RESTART_LOCAL=127; |
| public static final int I_SOURCE=128; |
| public static final int I_SPARSE_SWITCH_ELEMENTS=129; |
| public static final int I_STATEMENT_ARRAY_DATA=130; |
| public static final int I_STATEMENT_FORMAT10t=131; |
| public static final int I_STATEMENT_FORMAT10x=132; |
| public static final int I_STATEMENT_FORMAT11n=133; |
| public static final int I_STATEMENT_FORMAT11x=134; |
| public static final int I_STATEMENT_FORMAT12x=135; |
| public static final int I_STATEMENT_FORMAT20bc=136; |
| public static final int I_STATEMENT_FORMAT20t=137; |
| public static final int I_STATEMENT_FORMAT21c_FIELD=138; |
| public static final int I_STATEMENT_FORMAT21c_STRING=139; |
| public static final int I_STATEMENT_FORMAT21c_TYPE=140; |
| public static final int I_STATEMENT_FORMAT21ih=141; |
| public static final int I_STATEMENT_FORMAT21lh=142; |
| public static final int I_STATEMENT_FORMAT21s=143; |
| public static final int I_STATEMENT_FORMAT21t=144; |
| public static final int I_STATEMENT_FORMAT22b=145; |
| public static final int I_STATEMENT_FORMAT22c_FIELD=146; |
| public static final int I_STATEMENT_FORMAT22c_TYPE=147; |
| public static final int I_STATEMENT_FORMAT22s=148; |
| public static final int I_STATEMENT_FORMAT22t=149; |
| public static final int I_STATEMENT_FORMAT22x=150; |
| public static final int I_STATEMENT_FORMAT23x=151; |
| public static final int I_STATEMENT_FORMAT30t=152; |
| public static final int I_STATEMENT_FORMAT31c=153; |
| public static final int I_STATEMENT_FORMAT31i=154; |
| public static final int I_STATEMENT_FORMAT31t=155; |
| public static final int I_STATEMENT_FORMAT32x=156; |
| public static final int I_STATEMENT_FORMAT35c_METHOD=157; |
| public static final int I_STATEMENT_FORMAT35c_TYPE=158; |
| public static final int I_STATEMENT_FORMAT3rc_METHOD=159; |
| public static final int I_STATEMENT_FORMAT3rc_TYPE=160; |
| public static final int I_STATEMENT_FORMAT51l=161; |
| public static final int I_STATEMENT_PACKED_SWITCH=162; |
| public static final int I_STATEMENT_SPARSE_SWITCH=163; |
| public static final int I_SUBANNOTATION=164; |
| public static final int I_SUPER=165; |
| public static final int LINE_COMMENT=166; |
| public static final int LINE_DIRECTIVE=167; |
| public static final int LOCALS_DIRECTIVE=168; |
| public static final int LOCAL_DIRECTIVE=169; |
| public static final int LONG_LITERAL=170; |
| public static final int MEMBER_NAME=171; |
| public static final int METHOD_DIRECTIVE=172; |
| public static final int NEGATIVE_INTEGER_LITERAL=173; |
| public static final int NULL_LITERAL=174; |
| public static final int OPEN_BRACE=175; |
| public static final int OPEN_PAREN=176; |
| public static final int PACKED_SWITCH_DIRECTIVE=177; |
| public static final int PARAMETER_DIRECTIVE=178; |
| public static final int PARAM_LIST_END=179; |
| public static final int PARAM_LIST_OR_ID_END=180; |
| public static final int PARAM_LIST_OR_ID_START=181; |
| public static final int PARAM_LIST_START=182; |
| public static final int POSITIVE_INTEGER_LITERAL=183; |
| public static final int PRIMITIVE_TYPE=184; |
| public static final int PROLOGUE_DIRECTIVE=185; |
| public static final int REGISTER=186; |
| public static final int REGISTERS_DIRECTIVE=187; |
| public static final int RESTART_LOCAL_DIRECTIVE=188; |
| public static final int SHORT_LITERAL=189; |
| public static final int SIMPLE_NAME=190; |
| public static final int SOURCE_DIRECTIVE=191; |
| public static final int SPARSE_SWITCH_DIRECTIVE=192; |
| public static final int STRING_LITERAL=193; |
| public static final int SUBANNOTATION_DIRECTIVE=194; |
| public static final int SUPER_DIRECTIVE=195; |
| public static final int VERIFICATION_ERROR_TYPE=196; |
| public static final int VOID_TYPE=197; |
| public static final int VTABLE_INDEX=198; |
| public static final int WHITE_SPACE=199; |
| |
| // delegates |
| public TreeParser[] getDelegates() { |
| return new TreeParser[] {}; |
| } |
| |
| // delegators |
| |
| |
| public smaliTreeWalker(TreeNodeStream input) { |
| this(input, new RecognizerSharedState()); |
| } |
| public smaliTreeWalker(TreeNodeStream input, RecognizerSharedState state) { |
| super(input, state); |
| } |
| |
| @Override public String[] getTokenNames() { return smaliTreeWalker.tokenNames; } |
| @Override public String getGrammarFileName() { return "/mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g"; } |
| |
| |
| public String classType; |
| private boolean verboseErrors = false; |
| private int apiLevel = 15; |
| private Opcodes opcodes = new Opcodes(apiLevel); |
| private DexBuilder dexBuilder; |
| |
| public void setDexBuilder(DexBuilder dexBuilder) { |
| this.dexBuilder = dexBuilder; |
| } |
| |
| public void setApiLevel(int apiLevel) { |
| this.opcodes = new Opcodes(apiLevel); |
| this.apiLevel = apiLevel; |
| } |
| |
| public void setVerboseErrors(boolean verboseErrors) { |
| this.verboseErrors = verboseErrors; |
| } |
| |
| private byte parseRegister_nibble(String register) |
| throws SemanticException { |
| int totalMethodRegisters = method_stack.peek().totalMethodRegisters; |
| int methodParameterRegisters = method_stack.peek().methodParameterRegisters; |
| |
| //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) |
| throws SemanticException { |
| int totalMethodRegisters = method_stack.peek().totalMethodRegisters; |
| int methodParameterRegisters = method_stack.peek().methodParameterRegisters; |
| //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) |
| throws SemanticException { |
| int totalMethodRegisters = method_stack.peek().totalMethodRegisters; |
| int methodParameterRegisters = method_stack.peek().methodParameterRegisters; |
| //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; |
| } |
| |
| 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+"]"; |
| } |
| |
| |
| |
| // $ANTLR start "smali_file" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:159:1: smali_file returns [ClassDef classDef] : ^( I_CLASS_DEF header methods fields annotations ) ; |
| public final ClassDef smali_file() throws RecognitionException { |
| ClassDef classDef = null; |
| |
| |
| TreeRuleReturnScope header1 =null; |
| Set<Annotation> annotations2 =null; |
| List<BuilderField> fields3 =null; |
| List<BuilderMethod> methods4 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:160:3: ( ^( I_CLASS_DEF header methods fields annotations ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:160:5: ^( I_CLASS_DEF header methods fields annotations ) |
| { |
| match(input,I_CLASS_DEF,FOLLOW_I_CLASS_DEF_in_smali_file52); |
| match(input, Token.DOWN, null); |
| pushFollow(FOLLOW_header_in_smali_file54); |
| header1=header(); |
| state._fsp--; |
| |
| pushFollow(FOLLOW_methods_in_smali_file56); |
| methods4=methods(); |
| state._fsp--; |
| |
| pushFollow(FOLLOW_fields_in_smali_file58); |
| fields3=fields(); |
| state._fsp--; |
| |
| pushFollow(FOLLOW_annotations_in_smali_file60); |
| annotations2=annotations(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| classDef = dexBuilder.internClassDef((header1!=null?((smaliTreeWalker.header_return)header1).classType:null), (header1!=null?((smaliTreeWalker.header_return)header1).accessFlags:0), (header1!=null?((smaliTreeWalker.header_return)header1).superType:null), |
| (header1!=null?((smaliTreeWalker.header_return)header1).implementsList:null), (header1!=null?((smaliTreeWalker.header_return)header1).sourceSpec:null), annotations2, fields3, methods4); |
| |
| } |
| |
| } |
| catch (Exception ex) { |
| |
| if (verboseErrors) { |
| ex.printStackTrace(System.err); |
| } |
| reportError(new SemanticException(input, ex)); |
| |
| } |
| |
| finally { |
| // do for sure before leaving |
| } |
| return classDef; |
| } |
| // $ANTLR end "smali_file" |
| |
| |
| public static class header_return extends TreeRuleReturnScope { |
| public String classType; |
| public int accessFlags; |
| public String superType; |
| public List<String> implementsList; |
| public String sourceSpec; |
| }; |
| |
| |
| // $ANTLR start "header" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:173:1: header returns [String classType, int accessFlags, String superType, List<String> implementsList, String sourceSpec] : class_spec ( super_spec )? implements_list source_spec ; |
| public final smaliTreeWalker.header_return header() throws RecognitionException { |
| smaliTreeWalker.header_return retval = new smaliTreeWalker.header_return(); |
| retval.start = input.LT(1); |
| |
| TreeRuleReturnScope class_spec5 =null; |
| String super_spec6 =null; |
| List<String> implements_list7 =null; |
| String source_spec8 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:174:3: ( class_spec ( super_spec )? implements_list source_spec ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:174:3: class_spec ( super_spec )? implements_list source_spec |
| { |
| pushFollow(FOLLOW_class_spec_in_header85); |
| class_spec5=class_spec(); |
| state._fsp--; |
| |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:174:14: ( super_spec )? |
| int alt1=2; |
| int LA1_0 = input.LA(1); |
| if ( (LA1_0==I_SUPER) ) { |
| alt1=1; |
| } |
| switch (alt1) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:174:14: super_spec |
| { |
| pushFollow(FOLLOW_super_spec_in_header87); |
| super_spec6=super_spec(); |
| state._fsp--; |
| |
| } |
| break; |
| |
| } |
| |
| pushFollow(FOLLOW_implements_list_in_header90); |
| implements_list7=implements_list(); |
| state._fsp--; |
| |
| pushFollow(FOLLOW_source_spec_in_header92); |
| source_spec8=source_spec(); |
| state._fsp--; |
| |
| |
| classType = (class_spec5!=null?((smaliTreeWalker.class_spec_return)class_spec5).type:null); |
| retval.classType = classType; |
| retval.accessFlags = (class_spec5!=null?((smaliTreeWalker.class_spec_return)class_spec5).accessFlags:0); |
| retval.superType = super_spec6; |
| retval.implementsList = implements_list7; |
| retval.sourceSpec = source_spec8; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return retval; |
| } |
| // $ANTLR end "header" |
| |
| |
| public static class class_spec_return extends TreeRuleReturnScope { |
| public String type; |
| public int accessFlags; |
| }; |
| |
| |
| // $ANTLR start "class_spec" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:185:1: class_spec returns [String type, int accessFlags] : CLASS_DESCRIPTOR access_list ; |
| public final smaliTreeWalker.class_spec_return class_spec() throws RecognitionException { |
| smaliTreeWalker.class_spec_return retval = new smaliTreeWalker.class_spec_return(); |
| retval.start = input.LT(1); |
| |
| CommonTree CLASS_DESCRIPTOR9=null; |
| int access_list10 =0; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:186:3: ( CLASS_DESCRIPTOR access_list ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:186:5: CLASS_DESCRIPTOR access_list |
| { |
| CLASS_DESCRIPTOR9=(CommonTree)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_class_spec110); |
| pushFollow(FOLLOW_access_list_in_class_spec112); |
| access_list10=access_list(); |
| state._fsp--; |
| |
| |
| retval.type = (CLASS_DESCRIPTOR9!=null?CLASS_DESCRIPTOR9.getText():null); |
| retval.accessFlags = access_list10; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return retval; |
| } |
| // $ANTLR end "class_spec" |
| |
| |
| |
| // $ANTLR start "super_spec" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:192:1: super_spec returns [String type] : ^( I_SUPER CLASS_DESCRIPTOR ) ; |
| public final String super_spec() throws RecognitionException { |
| String type = null; |
| |
| |
| CommonTree CLASS_DESCRIPTOR11=null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:193:3: ( ^( I_SUPER CLASS_DESCRIPTOR ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:193:5: ^( I_SUPER CLASS_DESCRIPTOR ) |
| { |
| match(input,I_SUPER,FOLLOW_I_SUPER_in_super_spec130); |
| match(input, Token.DOWN, null); |
| CLASS_DESCRIPTOR11=(CommonTree)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_super_spec132); |
| match(input, Token.UP, null); |
| |
| |
| type = (CLASS_DESCRIPTOR11!=null?CLASS_DESCRIPTOR11.getText():null); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return type; |
| } |
| // $ANTLR end "super_spec" |
| |
| |
| |
| // $ANTLR start "implements_spec" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:199:1: implements_spec returns [String type] : ^( I_IMPLEMENTS CLASS_DESCRIPTOR ) ; |
| public final String implements_spec() throws RecognitionException { |
| String type = null; |
| |
| |
| CommonTree CLASS_DESCRIPTOR12=null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:200:3: ( ^( I_IMPLEMENTS CLASS_DESCRIPTOR ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:200:5: ^( I_IMPLEMENTS CLASS_DESCRIPTOR ) |
| { |
| match(input,I_IMPLEMENTS,FOLLOW_I_IMPLEMENTS_in_implements_spec152); |
| match(input, Token.DOWN, null); |
| CLASS_DESCRIPTOR12=(CommonTree)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_implements_spec154); |
| match(input, Token.UP, null); |
| |
| |
| type = (CLASS_DESCRIPTOR12!=null?CLASS_DESCRIPTOR12.getText():null); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return type; |
| } |
| // $ANTLR end "implements_spec" |
| |
| |
| |
| // $ANTLR start "implements_list" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:205:1: implements_list returns [List<String> implementsList] : ( implements_spec )* ; |
| public final List<String> implements_list() throws RecognitionException { |
| List<String> implementsList = null; |
| |
| |
| String implements_spec13 =null; |
| |
| List<String> typeList; |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:207:3: ( ( implements_spec )* ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:207:5: ( implements_spec )* |
| { |
| typeList = Lists.newArrayList(); |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:208:5: ( implements_spec )* |
| loop2: |
| while (true) { |
| int alt2=2; |
| int LA2_0 = input.LA(1); |
| if ( (LA2_0==I_IMPLEMENTS) ) { |
| alt2=1; |
| } |
| |
| switch (alt2) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:208:6: implements_spec |
| { |
| pushFollow(FOLLOW_implements_spec_in_implements_list184); |
| implements_spec13=implements_spec(); |
| state._fsp--; |
| |
| typeList.add(implements_spec13); |
| } |
| break; |
| |
| default : |
| break loop2; |
| } |
| } |
| |
| |
| if (typeList.size() > 0) { |
| implementsList = typeList; |
| } else { |
| implementsList = null; |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return implementsList; |
| } |
| // $ANTLR end "implements_list" |
| |
| |
| |
| // $ANTLR start "source_spec" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:217:1: source_spec returns [String source] : ( ^( I_SOURCE string_literal ) |); |
| public final String source_spec() throws RecognitionException { |
| String source = null; |
| |
| |
| String string_literal14 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:218:3: ( ^( I_SOURCE string_literal ) |) |
| int alt3=2; |
| int LA3_0 = input.LA(1); |
| if ( (LA3_0==I_SOURCE) ) { |
| alt3=1; |
| } |
| else if ( (LA3_0==I_METHODS) ) { |
| alt3=2; |
| } |
| |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 3, 0, input); |
| throw nvae; |
| } |
| |
| switch (alt3) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:218:5: ^( I_SOURCE string_literal ) |
| { |
| source = null; |
| match(input,I_SOURCE,FOLLOW_I_SOURCE_in_source_spec213); |
| match(input, Token.DOWN, null); |
| pushFollow(FOLLOW_string_literal_in_source_spec215); |
| string_literal14=string_literal(); |
| state._fsp--; |
| |
| source = string_literal14; |
| match(input, Token.UP, null); |
| |
| } |
| break; |
| case 2 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:220:16: |
| { |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return source; |
| } |
| // $ANTLR end "source_spec" |
| |
| |
| |
| // $ANTLR start "access_list" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:222:1: access_list returns [int value] : ^( I_ACCESS_LIST ( ACCESS_SPEC )* ) ; |
| public final int access_list() throws RecognitionException { |
| int value = 0; |
| |
| |
| CommonTree ACCESS_SPEC15=null; |
| |
| |
| value = 0; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:227:3: ( ^( I_ACCESS_LIST ( ACCESS_SPEC )* ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:227:5: ^( I_ACCESS_LIST ( ACCESS_SPEC )* ) |
| { |
| match(input,I_ACCESS_LIST,FOLLOW_I_ACCESS_LIST_in_access_list248); |
| if ( input.LA(1)==Token.DOWN ) { |
| match(input, Token.DOWN, null); |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:228:7: ( ACCESS_SPEC )* |
| loop4: |
| while (true) { |
| int alt4=2; |
| int LA4_0 = input.LA(1); |
| if ( (LA4_0==ACCESS_SPEC) ) { |
| alt4=1; |
| } |
| |
| switch (alt4) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:229:9: ACCESS_SPEC |
| { |
| ACCESS_SPEC15=(CommonTree)match(input,ACCESS_SPEC,FOLLOW_ACCESS_SPEC_in_access_list266); |
| |
| value |= AccessFlags.getAccessFlag(ACCESS_SPEC15.getText()).getValue(); |
| |
| } |
| break; |
| |
| default : |
| break loop4; |
| } |
| } |
| |
| match(input, Token.UP, null); |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return value; |
| } |
| // $ANTLR end "access_list" |
| |
| |
| |
| // $ANTLR start "fields" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:236:1: fields returns [List<BuilderField> fields] : ^( I_FIELDS ( field )* ) ; |
| public final List<BuilderField> fields() throws RecognitionException { |
| List<BuilderField> fields = null; |
| |
| |
| BuilderField field16 =null; |
| |
| fields = Lists.newArrayList(); |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:238:3: ( ^( I_FIELDS ( field )* ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:238:5: ^( I_FIELDS ( field )* ) |
| { |
| match(input,I_FIELDS,FOLLOW_I_FIELDS_in_fields308); |
| if ( input.LA(1)==Token.DOWN ) { |
| match(input, Token.DOWN, null); |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:239:7: ( field )* |
| loop5: |
| while (true) { |
| int alt5=2; |
| int LA5_0 = input.LA(1); |
| if ( (LA5_0==I_FIELD) ) { |
| alt5=1; |
| } |
| |
| switch (alt5) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:239:8: field |
| { |
| pushFollow(FOLLOW_field_in_fields317); |
| field16=field(); |
| state._fsp--; |
| |
| |
| fields.add(field16); |
| |
| } |
| break; |
| |
| default : |
| break loop5; |
| } |
| } |
| |
| match(input, Token.UP, null); |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return fields; |
| } |
| // $ANTLR end "fields" |
| |
| |
| |
| // $ANTLR start "methods" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:244:1: methods returns [List<BuilderMethod> methods] : ^( I_METHODS ( method )* ) ; |
| public final List<BuilderMethod> methods() throws RecognitionException { |
| List<BuilderMethod> methods = null; |
| |
| |
| BuilderMethod method17 =null; |
| |
| methods = Lists.newArrayList(); |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:246:3: ( ^( I_METHODS ( method )* ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:246:5: ^( I_METHODS ( method )* ) |
| { |
| match(input,I_METHODS,FOLLOW_I_METHODS_in_methods349); |
| if ( input.LA(1)==Token.DOWN ) { |
| match(input, Token.DOWN, null); |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:247:7: ( method )* |
| loop6: |
| while (true) { |
| int alt6=2; |
| int LA6_0 = input.LA(1); |
| if ( (LA6_0==I_METHOD) ) { |
| alt6=1; |
| } |
| |
| switch (alt6) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:247:8: method |
| { |
| pushFollow(FOLLOW_method_in_methods358); |
| method17=method(); |
| state._fsp--; |
| |
| |
| methods.add(method17); |
| |
| } |
| break; |
| |
| default : |
| break loop6; |
| } |
| } |
| |
| match(input, Token.UP, null); |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return methods; |
| } |
| // $ANTLR end "methods" |
| |
| |
| |
| // $ANTLR start "field" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:252:1: field returns [BuilderField field] : ^( I_FIELD SIMPLE_NAME access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) field_initial_value ( annotations )? ) ; |
| public final BuilderField field() throws RecognitionException { |
| BuilderField field = null; |
| |
| |
| CommonTree SIMPLE_NAME20=null; |
| int access_list18 =0; |
| EncodedValue field_initial_value19 =null; |
| TreeRuleReturnScope nonvoid_type_descriptor21 =null; |
| Set<Annotation> annotations22 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:253:3: ( ^( I_FIELD SIMPLE_NAME access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) field_initial_value ( annotations )? ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:253:4: ^( I_FIELD SIMPLE_NAME access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) field_initial_value ( annotations )? ) |
| { |
| match(input,I_FIELD,FOLLOW_I_FIELD_in_field383); |
| match(input, Token.DOWN, null); |
| SIMPLE_NAME20=(CommonTree)match(input,SIMPLE_NAME,FOLLOW_SIMPLE_NAME_in_field385); |
| pushFollow(FOLLOW_access_list_in_field387); |
| access_list18=access_list(); |
| state._fsp--; |
| |
| match(input,I_FIELD_TYPE,FOLLOW_I_FIELD_TYPE_in_field390); |
| match(input, Token.DOWN, null); |
| pushFollow(FOLLOW_nonvoid_type_descriptor_in_field392); |
| nonvoid_type_descriptor21=nonvoid_type_descriptor(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| pushFollow(FOLLOW_field_initial_value_in_field395); |
| field_initial_value19=field_initial_value(); |
| state._fsp--; |
| |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:253:98: ( annotations )? |
| int alt7=2; |
| int LA7_0 = input.LA(1); |
| if ( (LA7_0==I_ANNOTATIONS) ) { |
| alt7=1; |
| } |
| switch (alt7) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:253:98: annotations |
| { |
| pushFollow(FOLLOW_annotations_in_field397); |
| annotations22=annotations(); |
| state._fsp--; |
| |
| } |
| break; |
| |
| } |
| |
| match(input, Token.UP, null); |
| |
| |
| int accessFlags = access_list18; |
| |
| |
| if (!AccessFlags.STATIC.isSet(accessFlags) && field_initial_value19 != null) { |
| throw new SemanticException(input, "Initial field values can only be specified for static fields."); |
| } |
| |
| field = dexBuilder.internField(classType, (SIMPLE_NAME20!=null?SIMPLE_NAME20.getText():null), (nonvoid_type_descriptor21!=null?((smaliTreeWalker.nonvoid_type_descriptor_return)nonvoid_type_descriptor21).type:null), access_list18, |
| field_initial_value19, annotations22); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return field; |
| } |
| // $ANTLR end "field" |
| |
| |
| |
| // $ANTLR start "field_initial_value" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:267:1: field_initial_value returns [EncodedValue encodedValue] : ( ^( I_FIELD_INITIAL_VALUE literal ) |); |
| public final EncodedValue field_initial_value() throws RecognitionException { |
| EncodedValue encodedValue = null; |
| |
| |
| EncodedValue literal23 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:268:3: ( ^( I_FIELD_INITIAL_VALUE literal ) |) |
| int alt8=2; |
| int LA8_0 = input.LA(1); |
| if ( (LA8_0==I_FIELD_INITIAL_VALUE) ) { |
| alt8=1; |
| } |
| else if ( (LA8_0==UP||LA8_0==I_ANNOTATIONS) ) { |
| alt8=2; |
| } |
| |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 8, 0, input); |
| throw nvae; |
| } |
| |
| switch (alt8) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:268:5: ^( I_FIELD_INITIAL_VALUE literal ) |
| { |
| match(input,I_FIELD_INITIAL_VALUE,FOLLOW_I_FIELD_INITIAL_VALUE_in_field_initial_value418); |
| match(input, Token.DOWN, null); |
| pushFollow(FOLLOW_literal_in_field_initial_value420); |
| literal23=literal(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| encodedValue = literal23; |
| } |
| break; |
| case 2 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:269:16: |
| { |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return encodedValue; |
| } |
| // $ANTLR end "field_initial_value" |
| |
| |
| |
| // $ANTLR start "literal" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:271:1: literal returns [EncodedValue encodedValue] : ( integer_literal | long_literal | short_literal | byte_literal | float_literal | double_literal | char_literal | string_literal | bool_literal | NULL_LITERAL | type_descriptor | array_literal | subannotation | field_literal | method_literal | enum_literal ); |
| public final EncodedValue literal() throws RecognitionException { |
| EncodedValue encodedValue = null; |
| |
| |
| int integer_literal24 =0; |
| long long_literal25 =0; |
| short short_literal26 =0; |
| byte byte_literal27 =0; |
| float float_literal28 =0.0f; |
| double double_literal29 =0.0; |
| char char_literal30 =0; |
| String string_literal31 =null; |
| boolean bool_literal32 =false; |
| String type_descriptor33 =null; |
| List<EncodedValue> array_literal34 =null; |
| TreeRuleReturnScope subannotation35 =null; |
| FieldReference field_literal36 =null; |
| MethodReference method_literal37 =null; |
| FieldReference enum_literal38 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:272:3: ( integer_literal | long_literal | short_literal | byte_literal | float_literal | double_literal | char_literal | string_literal | bool_literal | NULL_LITERAL | type_descriptor | array_literal | subannotation | field_literal | method_literal | enum_literal ) |
| int alt9=16; |
| switch ( input.LA(1) ) { |
| case INTEGER_LITERAL: |
| { |
| alt9=1; |
| } |
| break; |
| case LONG_LITERAL: |
| { |
| alt9=2; |
| } |
| break; |
| case SHORT_LITERAL: |
| { |
| alt9=3; |
| } |
| break; |
| case BYTE_LITERAL: |
| { |
| alt9=4; |
| } |
| break; |
| case FLOAT_LITERAL: |
| { |
| alt9=5; |
| } |
| break; |
| case DOUBLE_LITERAL: |
| { |
| alt9=6; |
| } |
| break; |
| case CHAR_LITERAL: |
| { |
| alt9=7; |
| } |
| break; |
| case STRING_LITERAL: |
| { |
| alt9=8; |
| } |
| break; |
| case BOOL_LITERAL: |
| { |
| alt9=9; |
| } |
| break; |
| case NULL_LITERAL: |
| { |
| alt9=10; |
| } |
| break; |
| case ARRAY_DESCRIPTOR: |
| case CLASS_DESCRIPTOR: |
| case PRIMITIVE_TYPE: |
| case VOID_TYPE: |
| { |
| alt9=11; |
| } |
| break; |
| case I_ENCODED_ARRAY: |
| { |
| alt9=12; |
| } |
| break; |
| case I_SUBANNOTATION: |
| { |
| alt9=13; |
| } |
| break; |
| case I_ENCODED_FIELD: |
| { |
| alt9=14; |
| } |
| break; |
| case I_ENCODED_METHOD: |
| { |
| alt9=15; |
| } |
| break; |
| case I_ENCODED_ENUM: |
| { |
| alt9=16; |
| } |
| break; |
| default: |
| NoViableAltException nvae = |
| new NoViableAltException("", 9, 0, input); |
| throw nvae; |
| } |
| switch (alt9) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:272:5: integer_literal |
| { |
| pushFollow(FOLLOW_integer_literal_in_literal442); |
| integer_literal24=integer_literal(); |
| state._fsp--; |
| |
| encodedValue = new ImmutableIntEncodedValue(integer_literal24); |
| } |
| break; |
| case 2 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:273:5: long_literal |
| { |
| pushFollow(FOLLOW_long_literal_in_literal450); |
| long_literal25=long_literal(); |
| state._fsp--; |
| |
| encodedValue = new ImmutableLongEncodedValue(long_literal25); |
| } |
| break; |
| case 3 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:274:5: short_literal |
| { |
| pushFollow(FOLLOW_short_literal_in_literal458); |
| short_literal26=short_literal(); |
| state._fsp--; |
| |
| encodedValue = new ImmutableShortEncodedValue(short_literal26); |
| } |
| break; |
| case 4 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:275:5: byte_literal |
| { |
| pushFollow(FOLLOW_byte_literal_in_literal466); |
| byte_literal27=byte_literal(); |
| state._fsp--; |
| |
| encodedValue = new ImmutableByteEncodedValue(byte_literal27); |
| } |
| break; |
| case 5 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:276:5: float_literal |
| { |
| pushFollow(FOLLOW_float_literal_in_literal474); |
| float_literal28=float_literal(); |
| state._fsp--; |
| |
| encodedValue = new ImmutableFloatEncodedValue(float_literal28); |
| } |
| break; |
| case 6 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:277:5: double_literal |
| { |
| pushFollow(FOLLOW_double_literal_in_literal482); |
| double_literal29=double_literal(); |
| state._fsp--; |
| |
| encodedValue = new ImmutableDoubleEncodedValue(double_literal29); |
| } |
| break; |
| case 7 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:278:5: char_literal |
| { |
| pushFollow(FOLLOW_char_literal_in_literal490); |
| char_literal30=char_literal(); |
| state._fsp--; |
| |
| encodedValue = new ImmutableCharEncodedValue(char_literal30); |
| } |
| break; |
| case 8 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:279:5: string_literal |
| { |
| pushFollow(FOLLOW_string_literal_in_literal498); |
| string_literal31=string_literal(); |
| state._fsp--; |
| |
| encodedValue = new ImmutableStringEncodedValue(string_literal31); |
| } |
| break; |
| case 9 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:280:5: bool_literal |
| { |
| pushFollow(FOLLOW_bool_literal_in_literal506); |
| bool_literal32=bool_literal(); |
| state._fsp--; |
| |
| encodedValue = ImmutableBooleanEncodedValue.forBoolean(bool_literal32); |
| } |
| break; |
| case 10 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:281:5: NULL_LITERAL |
| { |
| match(input,NULL_LITERAL,FOLLOW_NULL_LITERAL_in_literal514); |
| encodedValue = ImmutableNullEncodedValue.INSTANCE; |
| } |
| break; |
| case 11 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:282:5: type_descriptor |
| { |
| pushFollow(FOLLOW_type_descriptor_in_literal522); |
| type_descriptor33=type_descriptor(); |
| state._fsp--; |
| |
| encodedValue = new ImmutableTypeEncodedValue(type_descriptor33); |
| } |
| break; |
| case 12 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:283:5: array_literal |
| { |
| pushFollow(FOLLOW_array_literal_in_literal530); |
| array_literal34=array_literal(); |
| state._fsp--; |
| |
| encodedValue = new ImmutableArrayEncodedValue(array_literal34); |
| } |
| break; |
| case 13 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:284:5: subannotation |
| { |
| pushFollow(FOLLOW_subannotation_in_literal538); |
| subannotation35=subannotation(); |
| state._fsp--; |
| |
| encodedValue = new ImmutableAnnotationEncodedValue((subannotation35!=null?((smaliTreeWalker.subannotation_return)subannotation35).annotationType:null), (subannotation35!=null?((smaliTreeWalker.subannotation_return)subannotation35).elements:null)); |
| } |
| break; |
| case 14 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:285:5: field_literal |
| { |
| pushFollow(FOLLOW_field_literal_in_literal546); |
| field_literal36=field_literal(); |
| state._fsp--; |
| |
| encodedValue = new ImmutableFieldEncodedValue(field_literal36); |
| } |
| break; |
| case 15 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:286:5: method_literal |
| { |
| pushFollow(FOLLOW_method_literal_in_literal554); |
| method_literal37=method_literal(); |
| state._fsp--; |
| |
| encodedValue = new ImmutableMethodEncodedValue(method_literal37); |
| } |
| break; |
| case 16 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:287:5: enum_literal |
| { |
| pushFollow(FOLLOW_enum_literal_in_literal562); |
| enum_literal38=enum_literal(); |
| state._fsp--; |
| |
| encodedValue = new ImmutableEnumEncodedValue(enum_literal38); |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return encodedValue; |
| } |
| // $ANTLR end "literal" |
| |
| |
| |
| // $ANTLR start "fixed_64bit_literal_number" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:290:1: fixed_64bit_literal_number returns [Number value] : ( integer_literal | long_literal | short_literal | byte_literal | float_literal | double_literal | char_literal | bool_literal ); |
| public final Number fixed_64bit_literal_number() throws RecognitionException { |
| Number value = null; |
| |
| |
| int integer_literal39 =0; |
| long long_literal40 =0; |
| short short_literal41 =0; |
| byte byte_literal42 =0; |
| float float_literal43 =0.0f; |
| double double_literal44 =0.0; |
| char char_literal45 =0; |
| boolean bool_literal46 =false; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:291:3: ( integer_literal | long_literal | short_literal | byte_literal | float_literal | double_literal | char_literal | bool_literal ) |
| int alt10=8; |
| switch ( input.LA(1) ) { |
| case INTEGER_LITERAL: |
| { |
| alt10=1; |
| } |
| break; |
| case LONG_LITERAL: |
| { |
| alt10=2; |
| } |
| break; |
| case SHORT_LITERAL: |
| { |
| alt10=3; |
| } |
| break; |
| case BYTE_LITERAL: |
| { |
| alt10=4; |
| } |
| break; |
| case FLOAT_LITERAL: |
| { |
| alt10=5; |
| } |
| break; |
| case DOUBLE_LITERAL: |
| { |
| alt10=6; |
| } |
| break; |
| case CHAR_LITERAL: |
| { |
| alt10=7; |
| } |
| break; |
| case BOOL_LITERAL: |
| { |
| alt10=8; |
| } |
| break; |
| default: |
| NoViableAltException nvae = |
| new NoViableAltException("", 10, 0, input); |
| throw nvae; |
| } |
| switch (alt10) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:291:5: integer_literal |
| { |
| pushFollow(FOLLOW_integer_literal_in_fixed_64bit_literal_number578); |
| integer_literal39=integer_literal(); |
| state._fsp--; |
| |
| value = integer_literal39; |
| } |
| break; |
| case 2 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:292:5: long_literal |
| { |
| pushFollow(FOLLOW_long_literal_in_fixed_64bit_literal_number586); |
| long_literal40=long_literal(); |
| state._fsp--; |
| |
| value = long_literal40; |
| } |
| break; |
| case 3 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:293:5: short_literal |
| { |
| pushFollow(FOLLOW_short_literal_in_fixed_64bit_literal_number594); |
| short_literal41=short_literal(); |
| state._fsp--; |
| |
| value = short_literal41; |
| } |
| break; |
| case 4 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:294:5: byte_literal |
| { |
| pushFollow(FOLLOW_byte_literal_in_fixed_64bit_literal_number602); |
| byte_literal42=byte_literal(); |
| state._fsp--; |
| |
| value = byte_literal42; |
| } |
| break; |
| case 5 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:295:5: float_literal |
| { |
| pushFollow(FOLLOW_float_literal_in_fixed_64bit_literal_number610); |
| float_literal43=float_literal(); |
| state._fsp--; |
| |
| value = Float.floatToRawIntBits(float_literal43); |
| } |
| break; |
| case 6 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:296:5: double_literal |
| { |
| pushFollow(FOLLOW_double_literal_in_fixed_64bit_literal_number618); |
| double_literal44=double_literal(); |
| state._fsp--; |
| |
| value = Double.doubleToRawLongBits(double_literal44); |
| } |
| break; |
| case 7 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:297:5: char_literal |
| { |
| pushFollow(FOLLOW_char_literal_in_fixed_64bit_literal_number626); |
| char_literal45=char_literal(); |
| state._fsp--; |
| |
| value = (int)char_literal45; |
| } |
| break; |
| case 8 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:298:5: bool_literal |
| { |
| pushFollow(FOLLOW_bool_literal_in_fixed_64bit_literal_number634); |
| bool_literal46=bool_literal(); |
| state._fsp--; |
| |
| value = bool_literal46?1:0; |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return value; |
| } |
| // $ANTLR end "fixed_64bit_literal_number" |
| |
| |
| |
| // $ANTLR start "fixed_64bit_literal" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:300:1: fixed_64bit_literal returns [long value] : ( integer_literal | long_literal | short_literal | byte_literal | float_literal | double_literal | char_literal | bool_literal ); |
| public final long fixed_64bit_literal() throws RecognitionException { |
| long value = 0; |
| |
| |
| int integer_literal47 =0; |
| long long_literal48 =0; |
| short short_literal49 =0; |
| byte byte_literal50 =0; |
| float float_literal51 =0.0f; |
| double double_literal52 =0.0; |
| char char_literal53 =0; |
| boolean bool_literal54 =false; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:301:3: ( integer_literal | long_literal | short_literal | byte_literal | float_literal | double_literal | char_literal | bool_literal ) |
| int alt11=8; |
| switch ( input.LA(1) ) { |
| case INTEGER_LITERAL: |
| { |
| alt11=1; |
| } |
| break; |
| case LONG_LITERAL: |
| { |
| alt11=2; |
| } |
| break; |
| case SHORT_LITERAL: |
| { |
| alt11=3; |
| } |
| break; |
| case BYTE_LITERAL: |
| { |
| alt11=4; |
| } |
| break; |
| case FLOAT_LITERAL: |
| { |
| alt11=5; |
| } |
| break; |
| case DOUBLE_LITERAL: |
| { |
| alt11=6; |
| } |
| break; |
| case CHAR_LITERAL: |
| { |
| alt11=7; |
| } |
| break; |
| case BOOL_LITERAL: |
| { |
| alt11=8; |
| } |
| break; |
| default: |
| NoViableAltException nvae = |
| new NoViableAltException("", 11, 0, input); |
| throw nvae; |
| } |
| switch (alt11) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:301:5: integer_literal |
| { |
| pushFollow(FOLLOW_integer_literal_in_fixed_64bit_literal649); |
| integer_literal47=integer_literal(); |
| state._fsp--; |
| |
| value = integer_literal47; |
| } |
| break; |
| case 2 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:302:5: long_literal |
| { |
| pushFollow(FOLLOW_long_literal_in_fixed_64bit_literal657); |
| long_literal48=long_literal(); |
| state._fsp--; |
| |
| value = long_literal48; |
| } |
| break; |
| case 3 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:303:5: short_literal |
| { |
| pushFollow(FOLLOW_short_literal_in_fixed_64bit_literal665); |
| short_literal49=short_literal(); |
| state._fsp--; |
| |
| value = short_literal49; |
| } |
| break; |
| case 4 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:304:5: byte_literal |
| { |
| pushFollow(FOLLOW_byte_literal_in_fixed_64bit_literal673); |
| byte_literal50=byte_literal(); |
| state._fsp--; |
| |
| value = byte_literal50; |
| } |
| break; |
| case 5 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:305:5: float_literal |
| { |
| pushFollow(FOLLOW_float_literal_in_fixed_64bit_literal681); |
| float_literal51=float_literal(); |
| state._fsp--; |
| |
| value = Float.floatToRawIntBits(float_literal51); |
| } |
| break; |
| case 6 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:306:5: double_literal |
| { |
| pushFollow(FOLLOW_double_literal_in_fixed_64bit_literal689); |
| double_literal52=double_literal(); |
| state._fsp--; |
| |
| value = Double.doubleToRawLongBits(double_literal52); |
| } |
| break; |
| case 7 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:307:5: char_literal |
| { |
| pushFollow(FOLLOW_char_literal_in_fixed_64bit_literal697); |
| char_literal53=char_literal(); |
| state._fsp--; |
| |
| value = char_literal53; |
| } |
| break; |
| case 8 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:308:5: bool_literal |
| { |
| pushFollow(FOLLOW_bool_literal_in_fixed_64bit_literal705); |
| bool_literal54=bool_literal(); |
| state._fsp--; |
| |
| value = bool_literal54?1:0; |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return value; |
| } |
| // $ANTLR end "fixed_64bit_literal" |
| |
| |
| |
| // $ANTLR start "fixed_32bit_literal" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:312:1: fixed_32bit_literal returns [int value] : ( integer_literal | long_literal | short_literal | byte_literal | float_literal | char_literal | bool_literal ); |
| public final int fixed_32bit_literal() throws RecognitionException { |
| int value = 0; |
| |
| |
| int integer_literal55 =0; |
| long long_literal56 =0; |
| short short_literal57 =0; |
| byte byte_literal58 =0; |
| float float_literal59 =0.0f; |
| char char_literal60 =0; |
| boolean bool_literal61 =false; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:313:3: ( integer_literal | long_literal | short_literal | byte_literal | float_literal | char_literal | bool_literal ) |
| int alt12=7; |
| switch ( input.LA(1) ) { |
| case INTEGER_LITERAL: |
| { |
| alt12=1; |
| } |
| break; |
| case LONG_LITERAL: |
| { |
| alt12=2; |
| } |
| break; |
| case SHORT_LITERAL: |
| { |
| alt12=3; |
| } |
| break; |
| case BYTE_LITERAL: |
| { |
| alt12=4; |
| } |
| break; |
| case FLOAT_LITERAL: |
| { |
| alt12=5; |
| } |
| break; |
| case CHAR_LITERAL: |
| { |
| alt12=6; |
| } |
| break; |
| case BOOL_LITERAL: |
| { |
| alt12=7; |
| } |
| break; |
| default: |
| NoViableAltException nvae = |
| new NoViableAltException("", 12, 0, input); |
| throw nvae; |
| } |
| switch (alt12) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:313:5: integer_literal |
| { |
| pushFollow(FOLLOW_integer_literal_in_fixed_32bit_literal722); |
| integer_literal55=integer_literal(); |
| state._fsp--; |
| |
| value = integer_literal55; |
| } |
| break; |
| case 2 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:314:5: long_literal |
| { |
| pushFollow(FOLLOW_long_literal_in_fixed_32bit_literal730); |
| long_literal56=long_literal(); |
| state._fsp--; |
| |
| LiteralTools.checkInt(long_literal56); value = (int)long_literal56; |
| } |
| break; |
| case 3 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:315:5: short_literal |
| { |
| pushFollow(FOLLOW_short_literal_in_fixed_32bit_literal738); |
| short_literal57=short_literal(); |
| state._fsp--; |
| |
| value = short_literal57; |
| } |
| break; |
| case 4 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:316:5: byte_literal |
| { |
| pushFollow(FOLLOW_byte_literal_in_fixed_32bit_literal746); |
| byte_literal58=byte_literal(); |
| state._fsp--; |
| |
| value = byte_literal58; |
| } |
| break; |
| case 5 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:317:5: float_literal |
| { |
| pushFollow(FOLLOW_float_literal_in_fixed_32bit_literal754); |
| float_literal59=float_literal(); |
| state._fsp--; |
| |
| value = Float.floatToRawIntBits(float_literal59); |
| } |
| break; |
| case 6 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:318:5: char_literal |
| { |
| pushFollow(FOLLOW_char_literal_in_fixed_32bit_literal762); |
| char_literal60=char_literal(); |
| state._fsp--; |
| |
| value = char_literal60; |
| } |
| break; |
| case 7 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:319:5: bool_literal |
| { |
| pushFollow(FOLLOW_bool_literal_in_fixed_32bit_literal770); |
| bool_literal61=bool_literal(); |
| state._fsp--; |
| |
| value = bool_literal61?1:0; |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return value; |
| } |
| // $ANTLR end "fixed_32bit_literal" |
| |
| |
| |
| // $ANTLR start "array_elements" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:321:1: array_elements returns [List<Number> elements] : ^( I_ARRAY_ELEMENTS ( fixed_64bit_literal_number )* ) ; |
| public final List<Number> array_elements() throws RecognitionException { |
| List<Number> elements = null; |
| |
| |
| Number fixed_64bit_literal_number62 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:322:3: ( ^( I_ARRAY_ELEMENTS ( fixed_64bit_literal_number )* ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:322:5: ^( I_ARRAY_ELEMENTS ( fixed_64bit_literal_number )* ) |
| { |
| elements = Lists.newArrayList(); |
| match(input,I_ARRAY_ELEMENTS,FOLLOW_I_ARRAY_ELEMENTS_in_array_elements792); |
| if ( input.LA(1)==Token.DOWN ) { |
| match(input, Token.DOWN, null); |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:324:7: ( fixed_64bit_literal_number )* |
| loop13: |
| while (true) { |
| int alt13=2; |
| int LA13_0 = input.LA(1); |
| if ( ((LA13_0 >= BOOL_LITERAL && LA13_0 <= BYTE_LITERAL)||LA13_0==CHAR_LITERAL||LA13_0==DOUBLE_LITERAL||LA13_0==FLOAT_LITERAL||LA13_0==INTEGER_LITERAL||LA13_0==LONG_LITERAL||LA13_0==SHORT_LITERAL) ) { |
| alt13=1; |
| } |
| |
| switch (alt13) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:324:8: fixed_64bit_literal_number |
| { |
| pushFollow(FOLLOW_fixed_64bit_literal_number_in_array_elements801); |
| fixed_64bit_literal_number62=fixed_64bit_literal_number(); |
| state._fsp--; |
| |
| |
| elements.add(fixed_64bit_literal_number62); |
| |
| } |
| break; |
| |
| default : |
| break loop13; |
| } |
| } |
| |
| match(input, Token.UP, null); |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return elements; |
| } |
| // $ANTLR end "array_elements" |
| |
| |
| |
| // $ANTLR start "packed_switch_elements" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:329:1: packed_switch_elements returns [List<Label> elements] : ^( I_PACKED_SWITCH_ELEMENTS ( label_ref )* ) ; |
| public final List<Label> packed_switch_elements() throws RecognitionException { |
| List<Label> elements = null; |
| |
| |
| Label label_ref63 =null; |
| |
| elements = Lists.newArrayList(); |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:331:3: ( ^( I_PACKED_SWITCH_ELEMENTS ( label_ref )* ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:332:5: ^( I_PACKED_SWITCH_ELEMENTS ( label_ref )* ) |
| { |
| match(input,I_PACKED_SWITCH_ELEMENTS,FOLLOW_I_PACKED_SWITCH_ELEMENTS_in_packed_switch_elements837); |
| if ( input.LA(1)==Token.DOWN ) { |
| match(input, Token.DOWN, null); |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:333:7: ( label_ref )* |
| loop14: |
| while (true) { |
| int alt14=2; |
| int LA14_0 = input.LA(1); |
| if ( (LA14_0==SIMPLE_NAME) ) { |
| alt14=1; |
| } |
| |
| switch (alt14) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:333:8: label_ref |
| { |
| pushFollow(FOLLOW_label_ref_in_packed_switch_elements846); |
| label_ref63=label_ref(); |
| state._fsp--; |
| |
| elements.add(label_ref63); |
| } |
| break; |
| |
| default : |
| break loop14; |
| } |
| } |
| |
| match(input, Token.UP, null); |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return elements; |
| } |
| // $ANTLR end "packed_switch_elements" |
| |
| |
| |
| // $ANTLR start "sparse_switch_elements" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:336:1: sparse_switch_elements returns [List<SwitchLabelElement> elements] : ^( I_SPARSE_SWITCH_ELEMENTS ( fixed_32bit_literal label_ref )* ) ; |
| public final List<SwitchLabelElement> sparse_switch_elements() throws RecognitionException { |
| List<SwitchLabelElement> elements = null; |
| |
| |
| int fixed_32bit_literal64 =0; |
| Label label_ref65 =null; |
| |
| elements = Lists.newArrayList(); |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:338:3: ( ^( I_SPARSE_SWITCH_ELEMENTS ( fixed_32bit_literal label_ref )* ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:339:5: ^( I_SPARSE_SWITCH_ELEMENTS ( fixed_32bit_literal label_ref )* ) |
| { |
| match(input,I_SPARSE_SWITCH_ELEMENTS,FOLLOW_I_SPARSE_SWITCH_ELEMENTS_in_sparse_switch_elements881); |
| if ( input.LA(1)==Token.DOWN ) { |
| match(input, Token.DOWN, null); |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:340:8: ( fixed_32bit_literal label_ref )* |
| loop15: |
| while (true) { |
| int alt15=2; |
| int LA15_0 = input.LA(1); |
| if ( ((LA15_0 >= BOOL_LITERAL && LA15_0 <= BYTE_LITERAL)||LA15_0==CHAR_LITERAL||LA15_0==FLOAT_LITERAL||LA15_0==INTEGER_LITERAL||LA15_0==LONG_LITERAL||LA15_0==SHORT_LITERAL) ) { |
| alt15=1; |
| } |
| |
| switch (alt15) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:340:9: fixed_32bit_literal label_ref |
| { |
| pushFollow(FOLLOW_fixed_32bit_literal_in_sparse_switch_elements891); |
| fixed_32bit_literal64=fixed_32bit_literal(); |
| state._fsp--; |
| |
| pushFollow(FOLLOW_label_ref_in_sparse_switch_elements893); |
| label_ref65=label_ref(); |
| state._fsp--; |
| |
| |
| elements.add(new SwitchLabelElement(fixed_32bit_literal64, label_ref65)); |
| |
| } |
| break; |
| |
| default : |
| break loop15; |
| } |
| } |
| |
| match(input, Token.UP, null); |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return elements; |
| } |
| // $ANTLR end "sparse_switch_elements" |
| |
| |
| protected static class method_scope { |
| boolean isStatic; |
| int totalMethodRegisters; |
| int methodParameterRegisters; |
| MethodImplementationBuilder methodBuilder; |
| } |
| protected Stack<method_scope> method_stack = new Stack<method_scope>(); |
| |
| |
| // $ANTLR start "method" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:346:1: method returns [BuilderMethod ret] : ^( I_METHOD method_name_and_prototype access_list ( ( registers_directive ) |) ordered_method_items catches parameters[$method_name_and_prototype.parameters] annotations ) ; |
| public final BuilderMethod method() throws RecognitionException { |
| method_stack.push(new method_scope()); |
| BuilderMethod ret = null; |
| |
| |
| CommonTree I_METHOD70=null; |
| int access_list66 =0; |
| TreeRuleReturnScope method_name_and_prototype67 =null; |
| TreeRuleReturnScope registers_directive68 =null; |
| List<BuilderTryBlock> catches69 =null; |
| Set<Annotation> annotations71 =null; |
| |
| |
| method_stack.peek().totalMethodRegisters = 0; |
| method_stack.peek().methodParameterRegisters = 0; |
| int accessFlags = 0; |
| method_stack.peek().isStatic = false; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:361:3: ( ^( I_METHOD method_name_and_prototype access_list ( ( registers_directive ) |) ordered_method_items catches parameters[$method_name_and_prototype.parameters] annotations ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:362:5: ^( I_METHOD method_name_and_prototype access_list ( ( registers_directive ) |) ordered_method_items catches parameters[$method_name_and_prototype.parameters] annotations ) |
| { |
| I_METHOD70=(CommonTree)match(input,I_METHOD,FOLLOW_I_METHOD_in_method945); |
| match(input, Token.DOWN, null); |
| pushFollow(FOLLOW_method_name_and_prototype_in_method953); |
| method_name_and_prototype67=method_name_and_prototype(); |
| state._fsp--; |
| |
| pushFollow(FOLLOW_access_list_in_method961); |
| access_list66=access_list(); |
| state._fsp--; |
| |
| |
| accessFlags = access_list66; |
| method_stack.peek().isStatic = AccessFlags.STATIC.isSet(accessFlags); |
| method_stack.peek().methodParameterRegisters = |
| MethodUtil.getParameterRegisterCount((method_name_and_prototype67!=null?((smaliTreeWalker.method_name_and_prototype_return)method_name_and_prototype67).parameters:null), method_stack.peek().isStatic); |
| |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:371:7: ( ( registers_directive ) |) |
| int alt16=2; |
| int LA16_0 = input.LA(1); |
| if ( (LA16_0==I_LOCALS||LA16_0==I_REGISTERS) ) { |
| alt16=1; |
| } |
| else if ( (LA16_0==I_ORDERED_METHOD_ITEMS) ) { |
| alt16=2; |
| } |
| |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 16, 0, input); |
| throw nvae; |
| } |
| |
| switch (alt16) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:372:9: ( registers_directive ) |
| { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:372:9: ( registers_directive ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:372:10: registers_directive |
| { |
| pushFollow(FOLLOW_registers_directive_in_method988); |
| registers_directive68=registers_directive(); |
| state._fsp--; |
| |
| |
| if ((registers_directive68!=null?((smaliTreeWalker.registers_directive_return)registers_directive68).isLocalsDirective:false)) { |
| method_stack.peek().totalMethodRegisters = (registers_directive68!=null?((smaliTreeWalker.registers_directive_return)registers_directive68).registers:0) + method_stack.peek().methodParameterRegisters; |
| } else { |
| method_stack.peek().totalMethodRegisters = (registers_directive68!=null?((smaliTreeWalker.registers_directive_return)registers_directive68).registers:0); |
| } |
| |
| method_stack.peek().methodBuilder = new MethodImplementationBuilder(method_stack.peek().totalMethodRegisters); |
| |
| |
| } |
| |
| } |
| break; |
| case 2 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:385:9: |
| { |
| |
| method_stack.peek().methodBuilder = new MethodImplementationBuilder(0); |
| |
| } |
| break; |
| |
| } |
| |
| pushFollow(FOLLOW_ordered_method_items_in_method1045); |
| ordered_method_items(); |
| state._fsp--; |
| |
| pushFollow(FOLLOW_catches_in_method1053); |
| catches69=catches(); |
| state._fsp--; |
| |
| pushFollow(FOLLOW_parameters_in_method1061); |
| parameters((method_name_and_prototype67!=null?((smaliTreeWalker.method_name_and_prototype_return)method_name_and_prototype67).parameters:null)); |
| state._fsp--; |
| |
| pushFollow(FOLLOW_annotations_in_method1070); |
| annotations71=annotations(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| MethodImplementation methodImplementation = null; |
| List<BuilderTryBlock> tryBlocks = catches69; |
| |
| boolean isAbstract = false; |
| boolean isNative = false; |
| |
| if ((accessFlags & AccessFlags.ABSTRACT.getValue()) != 0) { |
| isAbstract = true; |
| } else if ((accessFlags & AccessFlags.NATIVE.getValue()) != 0) { |
| isNative = true; |
| } |
| |
| methodImplementation = method_stack.peek().methodBuilder.getMethodImplementation(); |
| |
| if (Iterables.isEmpty(methodImplementation.getInstructions())) { |
| if (!isAbstract && !isNative) { |
| throw new SemanticException(input, I_METHOD70, "A non-abstract/non-native method must have at least 1 instruction"); |
| } |
| |
| String methodType; |
| if (isAbstract) { |
| methodType = "an abstract"; |
| } else { |
| methodType = "a native"; |
| } |
| |
| if ((registers_directive68!=null?((CommonTree)registers_directive68.start):null) != null) { |
| if ((registers_directive68!=null?((smaliTreeWalker.registers_directive_return)registers_directive68).isLocalsDirective:false)) { |
| throw new SemanticException(input, (registers_directive68!=null?((CommonTree)registers_directive68.start):null), "A .locals directive is not valid in %s method", methodType); |
| } else { |
| throw new SemanticException(input, (registers_directive68!=null?((CommonTree)registers_directive68.start):null), "A .registers directive is not valid in %s method", methodType); |
| } |
| } |
| |
| if (methodImplementation.getTryBlocks().size() > 0) { |
| throw new SemanticException(input, I_METHOD70, "try/catch blocks cannot be present in %s method", methodType); |
| } |
| |
| if (!Iterables.isEmpty(methodImplementation.getDebugItems())) { |
| throw new SemanticException(input, I_METHOD70, "debug directives cannot be present in %s method", methodType); |
| } |
| |
| methodImplementation = null; |
| } else { |
| if (isAbstract) { |
| throw new SemanticException(input, I_METHOD70, "An abstract method cannot have any instructions"); |
| } |
| if (isNative) { |
| throw new SemanticException(input, I_METHOD70, "A native method cannot have any instructions"); |
| } |
| |
| if ((registers_directive68!=null?((CommonTree)registers_directive68.start):null) == null) { |
| throw new SemanticException(input, I_METHOD70, "A .registers or .locals directive must be present for a non-abstract/non-final method"); |
| } |
| |
| if (method_stack.peek().totalMethodRegisters < method_stack.peek().methodParameterRegisters) { |
| throw new SemanticException(input, (registers_directive68!=null?((CommonTree)registers_directive68.start):null), "This method requires at least " + |
| Integer.toString(method_stack.peek().methodParameterRegisters) + |
| " registers, for the method parameters"); |
| } |
| } |
| |
| ret = dexBuilder.internMethod( |
| classType, |
| (method_name_and_prototype67!=null?((smaliTreeWalker.method_name_and_prototype_return)method_name_and_prototype67).name:null), |
| (method_name_and_prototype67!=null?((smaliTreeWalker.method_name_and_prototype_return)method_name_and_prototype67).parameters:null), |
| (method_name_and_prototype67!=null?((smaliTreeWalker.method_name_and_prototype_return)method_name_and_prototype67).returnType:null), |
| accessFlags, |
| annotations71, |
| methodImplementation); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| method_stack.pop(); |
| } |
| return ret; |
| } |
| // $ANTLR end "method" |
| |
| |
| public static class method_prototype_return extends TreeRuleReturnScope { |
| public List<String> parameters; |
| public String returnType; |
| }; |
| |
| |
| // $ANTLR start "method_prototype" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:467:1: method_prototype returns [List<String> parameters, String returnType] : ^( I_METHOD_PROTOTYPE ^( I_METHOD_RETURN_TYPE type_descriptor ) method_type_list ) ; |
| public final smaliTreeWalker.method_prototype_return method_prototype() throws RecognitionException { |
| smaliTreeWalker.method_prototype_return retval = new smaliTreeWalker.method_prototype_return(); |
| retval.start = input.LT(1); |
| |
| String type_descriptor72 =null; |
| List<String> method_type_list73 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:468:3: ( ^( I_METHOD_PROTOTYPE ^( I_METHOD_RETURN_TYPE type_descriptor ) method_type_list ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:468:5: ^( I_METHOD_PROTOTYPE ^( I_METHOD_RETURN_TYPE type_descriptor ) method_type_list ) |
| { |
| match(input,I_METHOD_PROTOTYPE,FOLLOW_I_METHOD_PROTOTYPE_in_method_prototype1094); |
| match(input, Token.DOWN, null); |
| match(input,I_METHOD_RETURN_TYPE,FOLLOW_I_METHOD_RETURN_TYPE_in_method_prototype1097); |
| match(input, Token.DOWN, null); |
| pushFollow(FOLLOW_type_descriptor_in_method_prototype1099); |
| type_descriptor72=type_descriptor(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| pushFollow(FOLLOW_method_type_list_in_method_prototype1102); |
| method_type_list73=method_type_list(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| retval.returnType = type_descriptor72; |
| retval.parameters = method_type_list73; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return retval; |
| } |
| // $ANTLR end "method_prototype" |
| |
| |
| public static class method_name_and_prototype_return extends TreeRuleReturnScope { |
| public String name; |
| public List<SmaliMethodParameter> parameters; |
| public String returnType; |
| }; |
| |
| |
| // $ANTLR start "method_name_and_prototype" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:474:1: method_name_and_prototype returns [String name, List<SmaliMethodParameter> parameters, String returnType] : SIMPLE_NAME method_prototype ; |
| public final smaliTreeWalker.method_name_and_prototype_return method_name_and_prototype() throws RecognitionException { |
| smaliTreeWalker.method_name_and_prototype_return retval = new smaliTreeWalker.method_name_and_prototype_return(); |
| retval.start = input.LT(1); |
| |
| CommonTree SIMPLE_NAME74=null; |
| TreeRuleReturnScope method_prototype75 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:475:3: ( SIMPLE_NAME method_prototype ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:475:5: SIMPLE_NAME method_prototype |
| { |
| SIMPLE_NAME74=(CommonTree)match(input,SIMPLE_NAME,FOLLOW_SIMPLE_NAME_in_method_name_and_prototype1120); |
| pushFollow(FOLLOW_method_prototype_in_method_name_and_prototype1122); |
| method_prototype75=method_prototype(); |
| state._fsp--; |
| |
| |
| retval.name = (SIMPLE_NAME74!=null?SIMPLE_NAME74.getText():null); |
| retval.parameters = Lists.newArrayList(); |
| |
| int paramRegister = 0; |
| for (String type: (method_prototype75!=null?((smaliTreeWalker.method_prototype_return)method_prototype75).parameters:null)) { |
| retval.parameters.add(new SmaliMethodParameter(paramRegister++, type)); |
| char c = type.charAt(0); |
| if (c == 'D' || c == 'J') { |
| paramRegister++; |
| } |
| } |
| retval.returnType = (method_prototype75!=null?((smaliTreeWalker.method_prototype_return)method_prototype75).returnType:null); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return retval; |
| } |
| // $ANTLR end "method_name_and_prototype" |
| |
| |
| |
| // $ANTLR start "method_type_list" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:491:1: method_type_list returns [List<String> types] : ( nonvoid_type_descriptor )* ; |
| public final List<String> method_type_list() throws RecognitionException { |
| List<String> types = null; |
| |
| |
| TreeRuleReturnScope nonvoid_type_descriptor76 =null; |
| |
| |
| types = Lists.newArrayList(); |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:496:3: ( ( nonvoid_type_descriptor )* ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:496:5: ( nonvoid_type_descriptor )* |
| { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:496:5: ( nonvoid_type_descriptor )* |
| loop17: |
| while (true) { |
| int alt17=2; |
| int LA17_0 = input.LA(1); |
| if ( (LA17_0==ARRAY_DESCRIPTOR||LA17_0==CLASS_DESCRIPTOR||LA17_0==PRIMITIVE_TYPE) ) { |
| alt17=1; |
| } |
| |
| switch (alt17) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:497:7: nonvoid_type_descriptor |
| { |
| pushFollow(FOLLOW_nonvoid_type_descriptor_in_method_type_list1156); |
| nonvoid_type_descriptor76=nonvoid_type_descriptor(); |
| state._fsp--; |
| |
| |
| types.add((nonvoid_type_descriptor76!=null?((smaliTreeWalker.nonvoid_type_descriptor_return)nonvoid_type_descriptor76).type:null)); |
| |
| } |
| break; |
| |
| default : |
| break loop17; |
| } |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return types; |
| } |
| // $ANTLR end "method_type_list" |
| |
| |
| |
| // $ANTLR start "method_reference" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:504:1: method_reference returns [ImmutableMethodReference methodReference] : ( reference_type_descriptor )? SIMPLE_NAME method_prototype ; |
| public final ImmutableMethodReference method_reference() throws RecognitionException { |
| ImmutableMethodReference methodReference = null; |
| |
| |
| CommonTree SIMPLE_NAME78=null; |
| TreeRuleReturnScope reference_type_descriptor77 =null; |
| TreeRuleReturnScope method_prototype79 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:505:3: ( ( reference_type_descriptor )? SIMPLE_NAME method_prototype ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:505:5: ( reference_type_descriptor )? SIMPLE_NAME method_prototype |
| { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:505:5: ( reference_type_descriptor )? |
| int alt18=2; |
| int LA18_0 = input.LA(1); |
| if ( (LA18_0==ARRAY_DESCRIPTOR||LA18_0==CLASS_DESCRIPTOR) ) { |
| alt18=1; |
| } |
| switch (alt18) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:505:5: reference_type_descriptor |
| { |
| pushFollow(FOLLOW_reference_type_descriptor_in_method_reference1185); |
| reference_type_descriptor77=reference_type_descriptor(); |
| state._fsp--; |
| |
| } |
| break; |
| |
| } |
| |
| SIMPLE_NAME78=(CommonTree)match(input,SIMPLE_NAME,FOLLOW_SIMPLE_NAME_in_method_reference1188); |
| pushFollow(FOLLOW_method_prototype_in_method_reference1190); |
| method_prototype79=method_prototype(); |
| state._fsp--; |
| |
| |
| String type; |
| if ((reference_type_descriptor77!=null?((smaliTreeWalker.reference_type_descriptor_return)reference_type_descriptor77).type:null) == null) { |
| type = classType; |
| } else { |
| type = (reference_type_descriptor77!=null?((smaliTreeWalker.reference_type_descriptor_return)reference_type_descriptor77).type:null); |
| } |
| methodReference = new ImmutableMethodReference(type, (SIMPLE_NAME78!=null?SIMPLE_NAME78.getText():null), |
| (method_prototype79!=null?((smaliTreeWalker.method_prototype_return)method_prototype79).parameters:null), (method_prototype79!=null?((smaliTreeWalker.method_prototype_return)method_prototype79).returnType:null)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return methodReference; |
| } |
| // $ANTLR end "method_reference" |
| |
| |
| |
| // $ANTLR start "field_reference" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:517:1: field_reference returns [ImmutableFieldReference fieldReference] : ( reference_type_descriptor )? SIMPLE_NAME nonvoid_type_descriptor ; |
| public final ImmutableFieldReference field_reference() throws RecognitionException { |
| ImmutableFieldReference fieldReference = null; |
| |
| |
| CommonTree SIMPLE_NAME81=null; |
| TreeRuleReturnScope reference_type_descriptor80 =null; |
| TreeRuleReturnScope nonvoid_type_descriptor82 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:518:3: ( ( reference_type_descriptor )? SIMPLE_NAME nonvoid_type_descriptor ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:518:5: ( reference_type_descriptor )? SIMPLE_NAME nonvoid_type_descriptor |
| { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:518:5: ( reference_type_descriptor )? |
| int alt19=2; |
| int LA19_0 = input.LA(1); |
| if ( (LA19_0==ARRAY_DESCRIPTOR||LA19_0==CLASS_DESCRIPTOR) ) { |
| alt19=1; |
| } |
| switch (alt19) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:518:5: reference_type_descriptor |
| { |
| pushFollow(FOLLOW_reference_type_descriptor_in_field_reference1207); |
| reference_type_descriptor80=reference_type_descriptor(); |
| state._fsp--; |
| |
| } |
| break; |
| |
| } |
| |
| SIMPLE_NAME81=(CommonTree)match(input,SIMPLE_NAME,FOLLOW_SIMPLE_NAME_in_field_reference1210); |
| pushFollow(FOLLOW_nonvoid_type_descriptor_in_field_reference1212); |
| nonvoid_type_descriptor82=nonvoid_type_descriptor(); |
| state._fsp--; |
| |
| |
| String type; |
| if ((reference_type_descriptor80!=null?((smaliTreeWalker.reference_type_descriptor_return)reference_type_descriptor80).type:null) == null) { |
| type = classType; |
| } else { |
| type = (reference_type_descriptor80!=null?((smaliTreeWalker.reference_type_descriptor_return)reference_type_descriptor80).type:null); |
| } |
| fieldReference = new ImmutableFieldReference(type, (SIMPLE_NAME81!=null?SIMPLE_NAME81.getText():null), |
| (nonvoid_type_descriptor82!=null?((smaliTreeWalker.nonvoid_type_descriptor_return)nonvoid_type_descriptor82).type:null)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return fieldReference; |
| } |
| // $ANTLR end "field_reference" |
| |
| |
| public static class registers_directive_return extends TreeRuleReturnScope { |
| public boolean isLocalsDirective; |
| public int registers; |
| }; |
| |
| |
| // $ANTLR start "registers_directive" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:530:1: registers_directive returns [boolean isLocalsDirective, int registers] : ^( ( I_REGISTERS | I_LOCALS ) short_integral_literal ) ; |
| public final smaliTreeWalker.registers_directive_return registers_directive() throws RecognitionException { |
| smaliTreeWalker.registers_directive_return retval = new smaliTreeWalker.registers_directive_return(); |
| retval.start = input.LT(1); |
| |
| short short_integral_literal83 =0; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:531:3: ( ^( ( I_REGISTERS | I_LOCALS ) short_integral_literal ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:531:5: ^( ( I_REGISTERS | I_LOCALS ) short_integral_literal ) |
| { |
| retval.registers = 0; |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:532:7: ( I_REGISTERS | I_LOCALS ) |
| int alt20=2; |
| int LA20_0 = input.LA(1); |
| if ( (LA20_0==I_REGISTERS) ) { |
| alt20=1; |
| } |
| else if ( (LA20_0==I_LOCALS) ) { |
| alt20=2; |
| } |
| |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 20, 0, input); |
| throw nvae; |
| } |
| |
| switch (alt20) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:532:9: I_REGISTERS |
| { |
| match(input,I_REGISTERS,FOLLOW_I_REGISTERS_in_registers_directive1238); |
| retval.isLocalsDirective = false; |
| } |
| break; |
| case 2 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:533:9: I_LOCALS |
| { |
| match(input,I_LOCALS,FOLLOW_I_LOCALS_in_registers_directive1250); |
| retval.isLocalsDirective = true; |
| } |
| break; |
| |
| } |
| |
| match(input, Token.DOWN, null); |
| pushFollow(FOLLOW_short_integral_literal_in_registers_directive1268); |
| short_integral_literal83=short_integral_literal(); |
| state._fsp--; |
| |
| retval.registers = short_integral_literal83; |
| match(input, Token.UP, null); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return retval; |
| } |
| // $ANTLR end "registers_directive" |
| |
| |
| |
| // $ANTLR start "label_def" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:538:1: label_def : ^( I_LABEL SIMPLE_NAME ) ; |
| public final void label_def() throws RecognitionException { |
| CommonTree SIMPLE_NAME84=null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:539:3: ( ^( I_LABEL SIMPLE_NAME ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:539:5: ^( I_LABEL SIMPLE_NAME ) |
| { |
| match(input,I_LABEL,FOLLOW_I_LABEL_in_label_def1288); |
| match(input, Token.DOWN, null); |
| SIMPLE_NAME84=(CommonTree)match(input,SIMPLE_NAME,FOLLOW_SIMPLE_NAME_in_label_def1290); |
| match(input, Token.UP, null); |
| |
| |
| method_stack.peek().methodBuilder.addLabel((SIMPLE_NAME84!=null?SIMPLE_NAME84.getText():null)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "label_def" |
| |
| |
| |
| // $ANTLR start "catches" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:544:1: catches returns [List<BuilderTryBlock> tryBlocks] : ^( I_CATCHES ( catch_directive )* ( catchall_directive )* ) ; |
| public final List<BuilderTryBlock> catches() throws RecognitionException { |
| List<BuilderTryBlock> tryBlocks = null; |
| |
| |
| tryBlocks = Lists.newArrayList(); |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:546:3: ( ^( I_CATCHES ( catch_directive )* ( catchall_directive )* ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:546:5: ^( I_CATCHES ( catch_directive )* ( catchall_directive )* ) |
| { |
| match(input,I_CATCHES,FOLLOW_I_CATCHES_in_catches1316); |
| if ( input.LA(1)==Token.DOWN ) { |
| match(input, Token.DOWN, null); |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:546:17: ( catch_directive )* |
| loop21: |
| while (true) { |
| int alt21=2; |
| int LA21_0 = input.LA(1); |
| if ( (LA21_0==I_CATCH) ) { |
| alt21=1; |
| } |
| |
| switch (alt21) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:546:17: catch_directive |
| { |
| pushFollow(FOLLOW_catch_directive_in_catches1318); |
| catch_directive(); |
| state._fsp--; |
| |
| } |
| break; |
| |
| default : |
| break loop21; |
| } |
| } |
| |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:546:34: ( catchall_directive )* |
| loop22: |
| while (true) { |
| int alt22=2; |
| int LA22_0 = input.LA(1); |
| if ( (LA22_0==I_CATCHALL) ) { |
| alt22=1; |
| } |
| |
| switch (alt22) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:546:34: catchall_directive |
| { |
| pushFollow(FOLLOW_catchall_directive_in_catches1321); |
| catchall_directive(); |
| state._fsp--; |
| |
| } |
| break; |
| |
| default : |
| break loop22; |
| } |
| } |
| |
| match(input, Token.UP, null); |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return tryBlocks; |
| } |
| // $ANTLR end "catches" |
| |
| |
| |
| // $ANTLR start "catch_directive" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:548:1: catch_directive : ^( I_CATCH nonvoid_type_descriptor from= label_ref to= label_ref using= label_ref ) ; |
| public final void catch_directive() throws RecognitionException { |
| Label from =null; |
| Label to =null; |
| Label using =null; |
| TreeRuleReturnScope nonvoid_type_descriptor85 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:549:3: ( ^( I_CATCH nonvoid_type_descriptor from= label_ref to= label_ref using= label_ref ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:549:5: ^( I_CATCH nonvoid_type_descriptor from= label_ref to= label_ref using= label_ref ) |
| { |
| match(input,I_CATCH,FOLLOW_I_CATCH_in_catch_directive1334); |
| match(input, Token.DOWN, null); |
| pushFollow(FOLLOW_nonvoid_type_descriptor_in_catch_directive1336); |
| nonvoid_type_descriptor85=nonvoid_type_descriptor(); |
| state._fsp--; |
| |
| pushFollow(FOLLOW_label_ref_in_catch_directive1340); |
| from=label_ref(); |
| state._fsp--; |
| |
| pushFollow(FOLLOW_label_ref_in_catch_directive1344); |
| to=label_ref(); |
| state._fsp--; |
| |
| pushFollow(FOLLOW_label_ref_in_catch_directive1348); |
| using=label_ref(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| method_stack.peek().methodBuilder.addCatch(dexBuilder.internTypeReference((nonvoid_type_descriptor85!=null?((smaliTreeWalker.nonvoid_type_descriptor_return)nonvoid_type_descriptor85).type:null)), |
| from, to, using); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "catch_directive" |
| |
| |
| |
| // $ANTLR start "catchall_directive" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:555:1: catchall_directive : ^( I_CATCHALL from= label_ref to= label_ref using= label_ref ) ; |
| public final void catchall_directive() throws RecognitionException { |
| Label from =null; |
| Label to =null; |
| Label using =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:556:3: ( ^( I_CATCHALL from= label_ref to= label_ref using= label_ref ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:556:5: ^( I_CATCHALL from= label_ref to= label_ref using= label_ref ) |
| { |
| match(input,I_CATCHALL,FOLLOW_I_CATCHALL_in_catchall_directive1364); |
| match(input, Token.DOWN, null); |
| pushFollow(FOLLOW_label_ref_in_catchall_directive1368); |
| from=label_ref(); |
| state._fsp--; |
| |
| pushFollow(FOLLOW_label_ref_in_catchall_directive1372); |
| to=label_ref(); |
| state._fsp--; |
| |
| pushFollow(FOLLOW_label_ref_in_catchall_directive1376); |
| using=label_ref(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| method_stack.peek().methodBuilder.addCatch(from, to, using); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "catchall_directive" |
| |
| |
| |
| // $ANTLR start "parameters" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:561:1: parameters[List<SmaliMethodParameter> parameters] : ^( I_PARAMETERS ( parameter[parameters] )* ) ; |
| public final void parameters(List<SmaliMethodParameter> parameters) throws RecognitionException { |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:562:3: ( ^( I_PARAMETERS ( parameter[parameters] )* ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:562:5: ^( I_PARAMETERS ( parameter[parameters] )* ) |
| { |
| match(input,I_PARAMETERS,FOLLOW_I_PARAMETERS_in_parameters1393); |
| if ( input.LA(1)==Token.DOWN ) { |
| match(input, Token.DOWN, null); |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:562:20: ( parameter[parameters] )* |
| loop23: |
| while (true) { |
| int alt23=2; |
| int LA23_0 = input.LA(1); |
| if ( (LA23_0==I_PARAMETER) ) { |
| alt23=1; |
| } |
| |
| switch (alt23) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:562:21: parameter[parameters] |
| { |
| pushFollow(FOLLOW_parameter_in_parameters1396); |
| parameter(parameters); |
| state._fsp--; |
| |
| } |
| break; |
| |
| default : |
| break loop23; |
| } |
| } |
| |
| match(input, Token.UP, null); |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "parameters" |
| |
| |
| |
| // $ANTLR start "parameter" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:564:1: parameter[List<SmaliMethodParameter> parameters] : ^( I_PARAMETER REGISTER ( string_literal )? annotations ) ; |
| public final void parameter(List<SmaliMethodParameter> parameters) throws RecognitionException { |
| CommonTree REGISTER86=null; |
| CommonTree I_PARAMETER87=null; |
| String string_literal88 =null; |
| Set<Annotation> annotations89 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:565:3: ( ^( I_PARAMETER REGISTER ( string_literal )? annotations ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:565:5: ^( I_PARAMETER REGISTER ( string_literal )? annotations ) |
| { |
| I_PARAMETER87=(CommonTree)match(input,I_PARAMETER,FOLLOW_I_PARAMETER_in_parameter1412); |
| match(input, Token.DOWN, null); |
| REGISTER86=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_parameter1414); |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:565:28: ( string_literal )? |
| int alt24=2; |
| int LA24_0 = input.LA(1); |
| if ( (LA24_0==STRING_LITERAL) ) { |
| alt24=1; |
| } |
| switch (alt24) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:565:28: string_literal |
| { |
| pushFollow(FOLLOW_string_literal_in_parameter1416); |
| string_literal88=string_literal(); |
| state._fsp--; |
| |
| } |
| break; |
| |
| } |
| |
| pushFollow(FOLLOW_annotations_in_parameter1419); |
| annotations89=annotations(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| final int registerNumber = parseRegister_short((REGISTER86!=null?REGISTER86.getText():null)); |
| int totalMethodRegisters = method_stack.peek().totalMethodRegisters; |
| int methodParameterRegisters = method_stack.peek().methodParameterRegisters; |
| |
| if (registerNumber >= totalMethodRegisters) { |
| throw new SemanticException(input, I_PARAMETER87, "Register %s is larger than the maximum register v%d " + |
| "for this method", (REGISTER86!=null?REGISTER86.getText():null), totalMethodRegisters-1); |
| } |
| final int indexGuess = registerNumber - (totalMethodRegisters - methodParameterRegisters) - (method_stack.peek().isStatic?0:1); |
| |
| if (indexGuess < 0) { |
| throw new SemanticException(input, I_PARAMETER87, "Register %s is not a parameter register.", |
| (REGISTER86!=null?REGISTER86.getText():null)); |
| } |
| |
| int parameterIndex = LinearSearch.linearSearch(parameters, SmaliMethodParameter.COMPARATOR, |
| new WithRegister() { public int getRegister() { return indexGuess; } }, |
| indexGuess); |
| |
| if (parameterIndex < 0) { |
| throw new SemanticException(input, I_PARAMETER87, "Register %s is the second half of a wide parameter.", |
| (REGISTER86!=null?REGISTER86.getText():null)); |
| } |
| |
| SmaliMethodParameter methodParameter = parameters.get(parameterIndex); |
| methodParameter.name = string_literal88; |
| if (annotations89 != null && annotations89.size() > 0) { |
| methodParameter.annotations = annotations89; |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "parameter" |
| |
| |
| |
| // $ANTLR start "debug_directive" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:598:1: debug_directive : ( line | local | end_local | restart_local | prologue | epilogue | source ); |
| public final void debug_directive() throws RecognitionException { |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:599:3: ( line | local | end_local | restart_local | prologue | epilogue | source ) |
| int alt25=7; |
| switch ( input.LA(1) ) { |
| case I_LINE: |
| { |
| alt25=1; |
| } |
| break; |
| case I_LOCAL: |
| { |
| alt25=2; |
| } |
| break; |
| case I_END_LOCAL: |
| { |
| alt25=3; |
| } |
| break; |
| case I_RESTART_LOCAL: |
| { |
| alt25=4; |
| } |
| break; |
| case I_PROLOGUE: |
| { |
| alt25=5; |
| } |
| break; |
| case I_EPILOGUE: |
| { |
| alt25=6; |
| } |
| break; |
| case I_SOURCE: |
| { |
| alt25=7; |
| } |
| break; |
| default: |
| NoViableAltException nvae = |
| new NoViableAltException("", 25, 0, input); |
| throw nvae; |
| } |
| switch (alt25) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:599:5: line |
| { |
| pushFollow(FOLLOW_line_in_debug_directive1436); |
| line(); |
| state._fsp--; |
| |
| } |
| break; |
| case 2 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:600:5: local |
| { |
| pushFollow(FOLLOW_local_in_debug_directive1442); |
| local(); |
| state._fsp--; |
| |
| } |
| break; |
| case 3 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:601:5: end_local |
| { |
| pushFollow(FOLLOW_end_local_in_debug_directive1448); |
| end_local(); |
| state._fsp--; |
| |
| } |
| break; |
| case 4 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:602:5: restart_local |
| { |
| pushFollow(FOLLOW_restart_local_in_debug_directive1454); |
| restart_local(); |
| state._fsp--; |
| |
| } |
| break; |
| case 5 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:603:5: prologue |
| { |
| pushFollow(FOLLOW_prologue_in_debug_directive1460); |
| prologue(); |
| state._fsp--; |
| |
| } |
| break; |
| case 6 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:604:5: epilogue |
| { |
| pushFollow(FOLLOW_epilogue_in_debug_directive1466); |
| epilogue(); |
| state._fsp--; |
| |
| } |
| break; |
| case 7 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:605:5: source |
| { |
| pushFollow(FOLLOW_source_in_debug_directive1472); |
| source(); |
| state._fsp--; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "debug_directive" |
| |
| |
| |
| // $ANTLR start "line" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:607:1: line : ^( I_LINE integral_literal ) ; |
| public final void line() throws RecognitionException { |
| int integral_literal90 =0; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:608:3: ( ^( I_LINE integral_literal ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:608:5: ^( I_LINE integral_literal ) |
| { |
| match(input,I_LINE,FOLLOW_I_LINE_in_line1483); |
| match(input, Token.DOWN, null); |
| pushFollow(FOLLOW_integral_literal_in_line1485); |
| integral_literal90=integral_literal(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| method_stack.peek().methodBuilder.addLineNumber(integral_literal90); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "line" |
| |
| |
| |
| // $ANTLR start "local" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:613:1: local : ^( I_LOCAL REGISTER ( ( NULL_LITERAL |name= string_literal ) ( nonvoid_type_descriptor )? (signature= string_literal )? )? ) ; |
| public final void local() throws RecognitionException { |
| CommonTree REGISTER91=null; |
| String name =null; |
| String signature =null; |
| TreeRuleReturnScope nonvoid_type_descriptor92 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:614:3: ( ^( I_LOCAL REGISTER ( ( NULL_LITERAL |name= string_literal ) ( nonvoid_type_descriptor )? (signature= string_literal )? )? ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:614:5: ^( I_LOCAL REGISTER ( ( NULL_LITERAL |name= string_literal ) ( nonvoid_type_descriptor )? (signature= string_literal )? )? ) |
| { |
| match(input,I_LOCAL,FOLLOW_I_LOCAL_in_local1503); |
| match(input, Token.DOWN, null); |
| REGISTER91=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_local1505); |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:614:24: ( ( NULL_LITERAL |name= string_literal ) ( nonvoid_type_descriptor )? (signature= string_literal )? )? |
| int alt29=2; |
| int LA29_0 = input.LA(1); |
| if ( (LA29_0==NULL_LITERAL||LA29_0==STRING_LITERAL) ) { |
| alt29=1; |
| } |
| switch (alt29) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:614:25: ( NULL_LITERAL |name= string_literal ) ( nonvoid_type_descriptor )? (signature= string_literal )? |
| { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:614:25: ( NULL_LITERAL |name= string_literal ) |
| int alt26=2; |
| int LA26_0 = input.LA(1); |
| if ( (LA26_0==NULL_LITERAL) ) { |
| alt26=1; |
| } |
| else if ( (LA26_0==STRING_LITERAL) ) { |
| alt26=2; |
| } |
| |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 26, 0, input); |
| throw nvae; |
| } |
| |
| switch (alt26) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:614:26: NULL_LITERAL |
| { |
| match(input,NULL_LITERAL,FOLLOW_NULL_LITERAL_in_local1509); |
| } |
| break; |
| case 2 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:614:41: name= string_literal |
| { |
| pushFollow(FOLLOW_string_literal_in_local1515); |
| name=string_literal(); |
| state._fsp--; |
| |
| } |
| break; |
| |
| } |
| |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:614:62: ( nonvoid_type_descriptor )? |
| int alt27=2; |
| int LA27_0 = input.LA(1); |
| if ( (LA27_0==ARRAY_DESCRIPTOR||LA27_0==CLASS_DESCRIPTOR||LA27_0==PRIMITIVE_TYPE) ) { |
| alt27=1; |
| } |
| switch (alt27) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:614:62: nonvoid_type_descriptor |
| { |
| pushFollow(FOLLOW_nonvoid_type_descriptor_in_local1518); |
| nonvoid_type_descriptor92=nonvoid_type_descriptor(); |
| state._fsp--; |
| |
| } |
| break; |
| |
| } |
| |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:614:96: (signature= string_literal )? |
| int alt28=2; |
| int LA28_0 = input.LA(1); |
| if ( (LA28_0==STRING_LITERAL) ) { |
| alt28=1; |
| } |
| switch (alt28) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:614:96: signature= string_literal |
| { |
| pushFollow(FOLLOW_string_literal_in_local1523); |
| signature=string_literal(); |
| state._fsp--; |
| |
| } |
| break; |
| |
| } |
| |
| } |
| break; |
| |
| } |
| |
| match(input, Token.UP, null); |
| |
| |
| int registerNumber = parseRegister_short((REGISTER91!=null?REGISTER91.getText():null)); |
| method_stack.peek().methodBuilder.addStartLocal(registerNumber, |
| dexBuilder.internNullableStringReference(name), |
| dexBuilder.internNullableTypeReference((nonvoid_type_descriptor92!=null?((smaliTreeWalker.nonvoid_type_descriptor_return)nonvoid_type_descriptor92).type:null)), |
| dexBuilder.internNullableStringReference(signature)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "local" |
| |
| |
| |
| // $ANTLR start "end_local" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:623:1: end_local : ^( I_END_LOCAL REGISTER ) ; |
| public final void end_local() throws RecognitionException { |
| CommonTree REGISTER93=null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:624:3: ( ^( I_END_LOCAL REGISTER ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:624:5: ^( I_END_LOCAL REGISTER ) |
| { |
| match(input,I_END_LOCAL,FOLLOW_I_END_LOCAL_in_end_local1544); |
| match(input, Token.DOWN, null); |
| REGISTER93=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_end_local1546); |
| match(input, Token.UP, null); |
| |
| |
| int registerNumber = parseRegister_short((REGISTER93!=null?REGISTER93.getText():null)); |
| method_stack.peek().methodBuilder.addEndLocal(registerNumber); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "end_local" |
| |
| |
| |
| // $ANTLR start "restart_local" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:630:1: restart_local : ^( I_RESTART_LOCAL REGISTER ) ; |
| public final void restart_local() throws RecognitionException { |
| CommonTree REGISTER94=null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:631:3: ( ^( I_RESTART_LOCAL REGISTER ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:631:5: ^( I_RESTART_LOCAL REGISTER ) |
| { |
| match(input,I_RESTART_LOCAL,FOLLOW_I_RESTART_LOCAL_in_restart_local1564); |
| match(input, Token.DOWN, null); |
| REGISTER94=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_restart_local1566); |
| match(input, Token.UP, null); |
| |
| |
| int registerNumber = parseRegister_short((REGISTER94!=null?REGISTER94.getText():null)); |
| method_stack.peek().methodBuilder.addRestartLocal(registerNumber); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "restart_local" |
| |
| |
| |
| // $ANTLR start "prologue" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:637:1: prologue : I_PROLOGUE ; |
| public final void prologue() throws RecognitionException { |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:638:3: ( I_PROLOGUE ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:638:5: I_PROLOGUE |
| { |
| match(input,I_PROLOGUE,FOLLOW_I_PROLOGUE_in_prologue1583); |
| |
| method_stack.peek().methodBuilder.addPrologue(); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "prologue" |
| |
| |
| |
| // $ANTLR start "epilogue" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:643:1: epilogue : I_EPILOGUE ; |
| public final void epilogue() throws RecognitionException { |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:644:3: ( I_EPILOGUE ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:644:5: I_EPILOGUE |
| { |
| match(input,I_EPILOGUE,FOLLOW_I_EPILOGUE_in_epilogue1599); |
| |
| method_stack.peek().methodBuilder.addEpilogue(); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "epilogue" |
| |
| |
| |
| // $ANTLR start "source" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:649:1: source : ^( I_SOURCE ( string_literal )? ) ; |
| public final void source() throws RecognitionException { |
| String string_literal95 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:650:3: ( ^( I_SOURCE ( string_literal )? ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:650:5: ^( I_SOURCE ( string_literal )? ) |
| { |
| match(input,I_SOURCE,FOLLOW_I_SOURCE_in_source1616); |
| if ( input.LA(1)==Token.DOWN ) { |
| match(input, Token.DOWN, null); |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:650:16: ( string_literal )? |
| int alt30=2; |
| int LA30_0 = input.LA(1); |
| if ( (LA30_0==STRING_LITERAL) ) { |
| alt30=1; |
| } |
| switch (alt30) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:650:16: string_literal |
| { |
| pushFollow(FOLLOW_string_literal_in_source1618); |
| string_literal95=string_literal(); |
| state._fsp--; |
| |
| } |
| break; |
| |
| } |
| |
| match(input, Token.UP, null); |
| } |
| |
| |
| method_stack.peek().methodBuilder.addSetSourceFile(dexBuilder.internNullableStringReference(string_literal95)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "source" |
| |
| |
| |
| // $ANTLR start "ordered_method_items" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:655:1: ordered_method_items : ^( I_ORDERED_METHOD_ITEMS ( label_def | instruction | debug_directive )* ) ; |
| public final void ordered_method_items() throws RecognitionException { |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:656:3: ( ^( I_ORDERED_METHOD_ITEMS ( label_def | instruction | debug_directive )* ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:656:5: ^( I_ORDERED_METHOD_ITEMS ( label_def | instruction | debug_directive )* ) |
| { |
| match(input,I_ORDERED_METHOD_ITEMS,FOLLOW_I_ORDERED_METHOD_ITEMS_in_ordered_method_items1637); |
| if ( input.LA(1)==Token.DOWN ) { |
| match(input, Token.DOWN, null); |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:656:30: ( label_def | instruction | debug_directive )* |
| loop31: |
| while (true) { |
| int alt31=4; |
| switch ( input.LA(1) ) { |
| case I_LABEL: |
| { |
| alt31=1; |
| } |
| break; |
| case I_STATEMENT_ARRAY_DATA: |
| case I_STATEMENT_FORMAT10t: |
| case I_STATEMENT_FORMAT10x: |
| case I_STATEMENT_FORMAT11n: |
| case I_STATEMENT_FORMAT11x: |
| case I_STATEMENT_FORMAT12x: |
| case I_STATEMENT_FORMAT20bc: |
| case I_STATEMENT_FORMAT20t: |
| case I_STATEMENT_FORMAT21c_FIELD: |
| case I_STATEMENT_FORMAT21c_STRING: |
| case I_STATEMENT_FORMAT21c_TYPE: |
| case I_STATEMENT_FORMAT21ih: |
| case I_STATEMENT_FORMAT21lh: |
| case I_STATEMENT_FORMAT21s: |
| case I_STATEMENT_FORMAT21t: |
| case I_STATEMENT_FORMAT22b: |
| case I_STATEMENT_FORMAT22c_FIELD: |
| case I_STATEMENT_FORMAT22c_TYPE: |
| case I_STATEMENT_FORMAT22s: |
| case I_STATEMENT_FORMAT22t: |
| case I_STATEMENT_FORMAT22x: |
| case I_STATEMENT_FORMAT23x: |
| case I_STATEMENT_FORMAT30t: |
| case I_STATEMENT_FORMAT31c: |
| case I_STATEMENT_FORMAT31i: |
| case I_STATEMENT_FORMAT31t: |
| case I_STATEMENT_FORMAT32x: |
| case I_STATEMENT_FORMAT35c_METHOD: |
| case I_STATEMENT_FORMAT35c_TYPE: |
| case I_STATEMENT_FORMAT3rc_METHOD: |
| case I_STATEMENT_FORMAT3rc_TYPE: |
| case I_STATEMENT_FORMAT51l: |
| case I_STATEMENT_PACKED_SWITCH: |
| case I_STATEMENT_SPARSE_SWITCH: |
| { |
| alt31=2; |
| } |
| break; |
| case I_END_LOCAL: |
| case I_EPILOGUE: |
| case I_LINE: |
| case I_LOCAL: |
| case I_PROLOGUE: |
| case I_RESTART_LOCAL: |
| case I_SOURCE: |
| { |
| alt31=3; |
| } |
| break; |
| } |
| switch (alt31) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:656:31: label_def |
| { |
| pushFollow(FOLLOW_label_def_in_ordered_method_items1640); |
| label_def(); |
| state._fsp--; |
| |
| } |
| break; |
| case 2 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:656:43: instruction |
| { |
| pushFollow(FOLLOW_instruction_in_ordered_method_items1644); |
| instruction(); |
| state._fsp--; |
| |
| } |
| break; |
| case 3 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:656:57: debug_directive |
| { |
| pushFollow(FOLLOW_debug_directive_in_ordered_method_items1648); |
| debug_directive(); |
| state._fsp--; |
| |
| } |
| break; |
| |
| default : |
| break loop31; |
| } |
| } |
| |
| match(input, Token.UP, null); |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "ordered_method_items" |
| |
| |
| |
| // $ANTLR start "label_ref" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:658:1: label_ref returns [Label label] : SIMPLE_NAME ; |
| public final Label label_ref() throws RecognitionException { |
| Label label = null; |
| |
| |
| CommonTree SIMPLE_NAME96=null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:659:3: ( SIMPLE_NAME ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:659:5: SIMPLE_NAME |
| { |
| SIMPLE_NAME96=(CommonTree)match(input,SIMPLE_NAME,FOLLOW_SIMPLE_NAME_in_label_ref1664); |
| label = method_stack.peek().methodBuilder.getLabel((SIMPLE_NAME96!=null?SIMPLE_NAME96.getText():null)); |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return label; |
| } |
| // $ANTLR end "label_ref" |
| |
| |
| public static class register_list_return extends TreeRuleReturnScope { |
| public byte[] registers; |
| public byte registerCount; |
| }; |
| |
| |
| // $ANTLR start "register_list" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:661:1: register_list returns [byte[] registers, byte registerCount] : ^( I_REGISTER_LIST ( REGISTER )* ) ; |
| public final smaliTreeWalker.register_list_return register_list() throws RecognitionException { |
| smaliTreeWalker.register_list_return retval = new smaliTreeWalker.register_list_return(); |
| retval.start = input.LT(1); |
| |
| CommonTree I_REGISTER_LIST97=null; |
| CommonTree REGISTER98=null; |
| |
| |
| retval.registers = new byte[5]; |
| retval.registerCount = 0; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:667:3: ( ^( I_REGISTER_LIST ( REGISTER )* ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:667:5: ^( I_REGISTER_LIST ( REGISTER )* ) |
| { |
| I_REGISTER_LIST97=(CommonTree)match(input,I_REGISTER_LIST,FOLLOW_I_REGISTER_LIST_in_register_list1689); |
| if ( input.LA(1)==Token.DOWN ) { |
| match(input, Token.DOWN, null); |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:668:7: ( REGISTER )* |
| loop32: |
| while (true) { |
| int alt32=2; |
| int LA32_0 = input.LA(1); |
| if ( (LA32_0==REGISTER) ) { |
| alt32=1; |
| } |
| |
| switch (alt32) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:668:8: REGISTER |
| { |
| REGISTER98=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_register_list1698); |
| |
| if (retval.registerCount == 5) { |
| throw new SemanticException(input, I_REGISTER_LIST97, "A list of registers can only have a maximum of 5 " + |
| "registers. Use the <op>/range alternate opcode instead."); |
| } |
| retval.registers[retval.registerCount++] = parseRegister_nibble((REGISTER98!=null?REGISTER98.getText():null)); |
| |
| } |
| break; |
| |
| default : |
| break loop32; |
| } |
| } |
| |
| match(input, Token.UP, null); |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return retval; |
| } |
| // $ANTLR end "register_list" |
| |
| |
| public static class register_range_return extends TreeRuleReturnScope { |
| public int startRegister; |
| public int endRegister; |
| }; |
| |
| |
| // $ANTLR start "register_range" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:677:1: register_range returns [int startRegister, int endRegister] : ^( I_REGISTER_RANGE (startReg= REGISTER (endReg= REGISTER )? )? ) ; |
| public final smaliTreeWalker.register_range_return register_range() throws RecognitionException { |
| smaliTreeWalker.register_range_return retval = new smaliTreeWalker.register_range_return(); |
| retval.start = input.LT(1); |
| |
| CommonTree startReg=null; |
| CommonTree endReg=null; |
| CommonTree I_REGISTER_RANGE99=null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:678:3: ( ^( I_REGISTER_RANGE (startReg= REGISTER (endReg= REGISTER )? )? ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:678:5: ^( I_REGISTER_RANGE (startReg= REGISTER (endReg= REGISTER )? )? ) |
| { |
| I_REGISTER_RANGE99=(CommonTree)match(input,I_REGISTER_RANGE,FOLLOW_I_REGISTER_RANGE_in_register_range1723); |
| if ( input.LA(1)==Token.DOWN ) { |
| match(input, Token.DOWN, null); |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:678:24: (startReg= REGISTER (endReg= REGISTER )? )? |
| int alt34=2; |
| int LA34_0 = input.LA(1); |
| if ( (LA34_0==REGISTER) ) { |
| alt34=1; |
| } |
| switch (alt34) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:678:25: startReg= REGISTER (endReg= REGISTER )? |
| { |
| startReg=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_register_range1728); |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:678:49: (endReg= REGISTER )? |
| int alt33=2; |
| int LA33_0 = input.LA(1); |
| if ( (LA33_0==REGISTER) ) { |
| alt33=1; |
| } |
| switch (alt33) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:678:49: endReg= REGISTER |
| { |
| endReg=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_register_range1732); |
| } |
| break; |
| |
| } |
| |
| } |
| break; |
| |
| } |
| |
| match(input, Token.UP, null); |
| } |
| |
| |
| if (startReg == null) { |
| retval.startRegister = 0; |
| retval.endRegister = -1; |
| } else { |
| retval.startRegister = parseRegister_short((startReg!=null?startReg.getText():null)); |
| if (endReg == null) { |
| retval.endRegister = retval.startRegister; |
| } else { |
| retval.endRegister = parseRegister_short((endReg!=null?endReg.getText():null)); |
| } |
| |
| int registerCount = retval.endRegister-retval.startRegister+1; |
| if (registerCount < 1) { |
| throw new SemanticException(input, I_REGISTER_RANGE99, "A register range must have the lower register listed first"); |
| } |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return retval; |
| } |
| // $ANTLR end "register_range" |
| |
| |
| |
| // $ANTLR start "verification_error_reference" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:698:1: verification_error_reference returns [ImmutableReference reference] : ( CLASS_DESCRIPTOR | field_reference | method_reference ); |
| public final ImmutableReference verification_error_reference() throws RecognitionException { |
| ImmutableReference reference = null; |
| |
| |
| CommonTree CLASS_DESCRIPTOR100=null; |
| ImmutableFieldReference field_reference101 =null; |
| ImmutableMethodReference method_reference102 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:699:3: ( CLASS_DESCRIPTOR | field_reference | method_reference ) |
| int alt35=3; |
| switch ( input.LA(1) ) { |
| case CLASS_DESCRIPTOR: |
| { |
| int LA35_1 = input.LA(2); |
| if ( (LA35_1==UP) ) { |
| alt35=1; |
| } |
| else if ( (LA35_1==SIMPLE_NAME) ) { |
| int LA35_3 = input.LA(3); |
| if ( (LA35_3==ARRAY_DESCRIPTOR||LA35_3==CLASS_DESCRIPTOR||LA35_3==PRIMITIVE_TYPE) ) { |
| alt35=2; |
| } |
| else if ( (LA35_3==I_METHOD_PROTOTYPE) ) { |
| alt35=3; |
| } |
| |
| else { |
| int nvaeMark = input.mark(); |
| try { |
| for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) { |
| input.consume(); |
| } |
| NoViableAltException nvae = |
| new NoViableAltException("", 35, 3, input); |
| throw nvae; |
| } finally { |
| input.rewind(nvaeMark); |
| } |
| } |
| |
| } |
| |
| else { |
| int nvaeMark = input.mark(); |
| try { |
| input.consume(); |
| NoViableAltException nvae = |
| new NoViableAltException("", 35, 1, input); |
| throw nvae; |
| } finally { |
| input.rewind(nvaeMark); |
| } |
| } |
| |
| } |
| break; |
| case ARRAY_DESCRIPTOR: |
| { |
| int LA35_2 = input.LA(2); |
| if ( (LA35_2==SIMPLE_NAME) ) { |
| int LA35_3 = input.LA(3); |
| if ( (LA35_3==ARRAY_DESCRIPTOR||LA35_3==CLASS_DESCRIPTOR||LA35_3==PRIMITIVE_TYPE) ) { |
| alt35=2; |
| } |
| else if ( (LA35_3==I_METHOD_PROTOTYPE) ) { |
| alt35=3; |
| } |
| |
| else { |
| int nvaeMark = input.mark(); |
| try { |
| for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) { |
| input.consume(); |
| } |
| NoViableAltException nvae = |
| new NoViableAltException("", 35, 3, input); |
| throw nvae; |
| } finally { |
| input.rewind(nvaeMark); |
| } |
| } |
| |
| } |
| |
| else { |
| int nvaeMark = input.mark(); |
| try { |
| input.consume(); |
| NoViableAltException nvae = |
| new NoViableAltException("", 35, 2, input); |
| throw nvae; |
| } finally { |
| input.rewind(nvaeMark); |
| } |
| } |
| |
| } |
| break; |
| case SIMPLE_NAME: |
| { |
| int LA35_3 = input.LA(2); |
| if ( (LA35_3==ARRAY_DESCRIPTOR||LA35_3==CLASS_DESCRIPTOR||LA35_3==PRIMITIVE_TYPE) ) { |
| alt35=2; |
| } |
| else if ( (LA35_3==I_METHOD_PROTOTYPE) ) { |
| alt35=3; |
| } |
| |
| else { |
| int nvaeMark = input.mark(); |
| try { |
| input.consume(); |
| NoViableAltException nvae = |
| new NoViableAltException("", 35, 3, input); |
| throw nvae; |
| } finally { |
| input.rewind(nvaeMark); |
| } |
| } |
| |
| } |
| break; |
| default: |
| NoViableAltException nvae = |
| new NoViableAltException("", 35, 0, input); |
| throw nvae; |
| } |
| switch (alt35) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:699:5: CLASS_DESCRIPTOR |
| { |
| CLASS_DESCRIPTOR100=(CommonTree)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_verification_error_reference1755); |
| |
| reference = new ImmutableTypeReference((CLASS_DESCRIPTOR100!=null?CLASS_DESCRIPTOR100.getText():null)); |
| |
| } |
| break; |
| case 2 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:703:5: field_reference |
| { |
| pushFollow(FOLLOW_field_reference_in_verification_error_reference1765); |
| field_reference101=field_reference(); |
| state._fsp--; |
| |
| |
| reference = field_reference101; |
| |
| } |
| break; |
| case 3 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:707:5: method_reference |
| { |
| pushFollow(FOLLOW_method_reference_in_verification_error_reference1775); |
| method_reference102=method_reference(); |
| state._fsp--; |
| |
| |
| reference = method_reference102; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return reference; |
| } |
| // $ANTLR end "verification_error_reference" |
| |
| |
| |
| // $ANTLR start "verification_error_type" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:712:1: verification_error_type returns [int verificationError] : VERIFICATION_ERROR_TYPE ; |
| public final int verification_error_type() throws RecognitionException { |
| int verificationError = 0; |
| |
| |
| CommonTree VERIFICATION_ERROR_TYPE103=null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:713:3: ( VERIFICATION_ERROR_TYPE ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:713:5: VERIFICATION_ERROR_TYPE |
| { |
| VERIFICATION_ERROR_TYPE103=(CommonTree)match(input,VERIFICATION_ERROR_TYPE,FOLLOW_VERIFICATION_ERROR_TYPE_in_verification_error_type1792); |
| |
| verificationError = VerificationError.getVerificationError((VERIFICATION_ERROR_TYPE103!=null?VERIFICATION_ERROR_TYPE103.getText():null)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return verificationError; |
| } |
| // $ANTLR end "verification_error_type" |
| |
| |
| public static class instruction_return extends TreeRuleReturnScope { |
| }; |
| |
| |
| // $ANTLR start "instruction" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:718:1: instruction : ( insn_format10t | insn_format10x | insn_format11n | insn_format11x | insn_format12x | insn_format20bc | insn_format20t | insn_format21c_field | insn_format21c_string | insn_format21c_type | insn_format21ih | insn_format21lh | insn_format21s | insn_format21t | insn_format22b | insn_format22c_field | insn_format22c_type | insn_format22s | insn_format22t | insn_format22x | insn_format23x | insn_format30t | insn_format31c | insn_format31i | insn_format31t | insn_format32x | insn_format35c_method | insn_format35c_type | insn_format3rc_method | insn_format3rc_type | insn_format51l_type | insn_array_data_directive | insn_packed_switch_directive | insn_sparse_switch_directive ); |
| public final smaliTreeWalker.instruction_return instruction() throws RecognitionException { |
| smaliTreeWalker.instruction_return retval = new smaliTreeWalker.instruction_return(); |
| retval.start = input.LT(1); |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:719:3: ( insn_format10t | insn_format10x | insn_format11n | insn_format11x | insn_format12x | insn_format20bc | insn_format20t | insn_format21c_field | insn_format21c_string | insn_format21c_type | insn_format21ih | insn_format21lh | insn_format21s | insn_format21t | insn_format22b | insn_format22c_field | insn_format22c_type | insn_format22s | insn_format22t | insn_format22x | insn_format23x | insn_format30t | insn_format31c | insn_format31i | insn_format31t | insn_format32x | insn_format35c_method | insn_format35c_type | insn_format3rc_method | insn_format3rc_type | insn_format51l_type | insn_array_data_directive | insn_packed_switch_directive | insn_sparse_switch_directive ) |
| int alt36=34; |
| switch ( input.LA(1) ) { |
| case I_STATEMENT_FORMAT10t: |
| { |
| alt36=1; |
| } |
| break; |
| case I_STATEMENT_FORMAT10x: |
| { |
| alt36=2; |
| } |
| break; |
| case I_STATEMENT_FORMAT11n: |
| { |
| alt36=3; |
| } |
| break; |
| case I_STATEMENT_FORMAT11x: |
| { |
| alt36=4; |
| } |
| break; |
| case I_STATEMENT_FORMAT12x: |
| { |
| alt36=5; |
| } |
| break; |
| case I_STATEMENT_FORMAT20bc: |
| { |
| alt36=6; |
| } |
| break; |
| case I_STATEMENT_FORMAT20t: |
| { |
| alt36=7; |
| } |
| break; |
| case I_STATEMENT_FORMAT21c_FIELD: |
| { |
| alt36=8; |
| } |
| break; |
| case I_STATEMENT_FORMAT21c_STRING: |
| { |
| alt36=9; |
| } |
| break; |
| case I_STATEMENT_FORMAT21c_TYPE: |
| { |
| alt36=10; |
| } |
| break; |
| case I_STATEMENT_FORMAT21ih: |
| { |
| alt36=11; |
| } |
| break; |
| case I_STATEMENT_FORMAT21lh: |
| { |
| alt36=12; |
| } |
| break; |
| case I_STATEMENT_FORMAT21s: |
| { |
| alt36=13; |
| } |
| break; |
| case I_STATEMENT_FORMAT21t: |
| { |
| alt36=14; |
| } |
| break; |
| case I_STATEMENT_FORMAT22b: |
| { |
| alt36=15; |
| } |
| break; |
| case I_STATEMENT_FORMAT22c_FIELD: |
| { |
| alt36=16; |
| } |
| break; |
| case I_STATEMENT_FORMAT22c_TYPE: |
| { |
| alt36=17; |
| } |
| break; |
| case I_STATEMENT_FORMAT22s: |
| { |
| alt36=18; |
| } |
| break; |
| case I_STATEMENT_FORMAT22t: |
| { |
| alt36=19; |
| } |
| break; |
| case I_STATEMENT_FORMAT22x: |
| { |
| alt36=20; |
| } |
| break; |
| case I_STATEMENT_FORMAT23x: |
| { |
| alt36=21; |
| } |
| break; |
| case I_STATEMENT_FORMAT30t: |
| { |
| alt36=22; |
| } |
| break; |
| case I_STATEMENT_FORMAT31c: |
| { |
| alt36=23; |
| } |
| break; |
| case I_STATEMENT_FORMAT31i: |
| { |
| alt36=24; |
| } |
| break; |
| case I_STATEMENT_FORMAT31t: |
| { |
| alt36=25; |
| } |
| break; |
| case I_STATEMENT_FORMAT32x: |
| { |
| alt36=26; |
| } |
| break; |
| case I_STATEMENT_FORMAT35c_METHOD: |
| { |
| alt36=27; |
| } |
| break; |
| case I_STATEMENT_FORMAT35c_TYPE: |
| { |
| alt36=28; |
| } |
| break; |
| case I_STATEMENT_FORMAT3rc_METHOD: |
| { |
| alt36=29; |
| } |
| break; |
| case I_STATEMENT_FORMAT3rc_TYPE: |
| { |
| alt36=30; |
| } |
| break; |
| case I_STATEMENT_FORMAT51l: |
| { |
| alt36=31; |
| } |
| break; |
| case I_STATEMENT_ARRAY_DATA: |
| { |
| alt36=32; |
| } |
| break; |
| case I_STATEMENT_PACKED_SWITCH: |
| { |
| alt36=33; |
| } |
| break; |
| case I_STATEMENT_SPARSE_SWITCH: |
| { |
| alt36=34; |
| } |
| break; |
| default: |
| NoViableAltException nvae = |
| new NoViableAltException("", 36, 0, input); |
| throw nvae; |
| } |
| switch (alt36) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:719:5: insn_format10t |
| { |
| pushFollow(FOLLOW_insn_format10t_in_instruction1806); |
| insn_format10t(); |
| state._fsp--; |
| |
| } |
| break; |
| case 2 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:720:5: insn_format10x |
| { |
| pushFollow(FOLLOW_insn_format10x_in_instruction1812); |
| insn_format10x(); |
| state._fsp--; |
| |
| } |
| break; |
| case 3 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:721:5: insn_format11n |
| { |
| pushFollow(FOLLOW_insn_format11n_in_instruction1818); |
| insn_format11n(); |
| state._fsp--; |
| |
| } |
| break; |
| case 4 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:722:5: insn_format11x |
| { |
| pushFollow(FOLLOW_insn_format11x_in_instruction1824); |
| insn_format11x(); |
| state._fsp--; |
| |
| } |
| break; |
| case 5 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:723:5: insn_format12x |
| { |
| pushFollow(FOLLOW_insn_format12x_in_instruction1830); |
| insn_format12x(); |
| state._fsp--; |
| |
| } |
| break; |
| case 6 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:724:5: insn_format20bc |
| { |
| pushFollow(FOLLOW_insn_format20bc_in_instruction1836); |
| insn_format20bc(); |
| state._fsp--; |
| |
| } |
| break; |
| case 7 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:725:5: insn_format20t |
| { |
| pushFollow(FOLLOW_insn_format20t_in_instruction1842); |
| insn_format20t(); |
| state._fsp--; |
| |
| } |
| break; |
| case 8 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:726:5: insn_format21c_field |
| { |
| pushFollow(FOLLOW_insn_format21c_field_in_instruction1848); |
| insn_format21c_field(); |
| state._fsp--; |
| |
| } |
| break; |
| case 9 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:727:5: insn_format21c_string |
| { |
| pushFollow(FOLLOW_insn_format21c_string_in_instruction1854); |
| insn_format21c_string(); |
| state._fsp--; |
| |
| } |
| break; |
| case 10 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:728:5: insn_format21c_type |
| { |
| pushFollow(FOLLOW_insn_format21c_type_in_instruction1860); |
| insn_format21c_type(); |
| state._fsp--; |
| |
| } |
| break; |
| case 11 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:729:5: insn_format21ih |
| { |
| pushFollow(FOLLOW_insn_format21ih_in_instruction1866); |
| insn_format21ih(); |
| state._fsp--; |
| |
| } |
| break; |
| case 12 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:730:5: insn_format21lh |
| { |
| pushFollow(FOLLOW_insn_format21lh_in_instruction1872); |
| insn_format21lh(); |
| state._fsp--; |
| |
| } |
| break; |
| case 13 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:731:5: insn_format21s |
| { |
| pushFollow(FOLLOW_insn_format21s_in_instruction1878); |
| insn_format21s(); |
| state._fsp--; |
| |
| } |
| break; |
| case 14 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:732:5: insn_format21t |
| { |
| pushFollow(FOLLOW_insn_format21t_in_instruction1884); |
| insn_format21t(); |
| state._fsp--; |
| |
| } |
| break; |
| case 15 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:733:5: insn_format22b |
| { |
| pushFollow(FOLLOW_insn_format22b_in_instruction1890); |
| insn_format22b(); |
| state._fsp--; |
| |
| } |
| break; |
| case 16 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:734:5: insn_format22c_field |
| { |
| pushFollow(FOLLOW_insn_format22c_field_in_instruction1896); |
| insn_format22c_field(); |
| state._fsp--; |
| |
| } |
| break; |
| case 17 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:735:5: insn_format22c_type |
| { |
| pushFollow(FOLLOW_insn_format22c_type_in_instruction1902); |
| insn_format22c_type(); |
| state._fsp--; |
| |
| } |
| break; |
| case 18 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:736:5: insn_format22s |
| { |
| pushFollow(FOLLOW_insn_format22s_in_instruction1908); |
| insn_format22s(); |
| state._fsp--; |
| |
| } |
| break; |
| case 19 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:737:5: insn_format22t |
| { |
| pushFollow(FOLLOW_insn_format22t_in_instruction1914); |
| insn_format22t(); |
| state._fsp--; |
| |
| } |
| break; |
| case 20 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:738:5: insn_format22x |
| { |
| pushFollow(FOLLOW_insn_format22x_in_instruction1920); |
| insn_format22x(); |
| state._fsp--; |
| |
| } |
| break; |
| case 21 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:739:5: insn_format23x |
| { |
| pushFollow(FOLLOW_insn_format23x_in_instruction1926); |
| insn_format23x(); |
| state._fsp--; |
| |
| } |
| break; |
| case 22 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:740:5: insn_format30t |
| { |
| pushFollow(FOLLOW_insn_format30t_in_instruction1932); |
| insn_format30t(); |
| state._fsp--; |
| |
| } |
| break; |
| case 23 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:741:5: insn_format31c |
| { |
| pushFollow(FOLLOW_insn_format31c_in_instruction1938); |
| insn_format31c(); |
| state._fsp--; |
| |
| } |
| break; |
| case 24 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:742:5: insn_format31i |
| { |
| pushFollow(FOLLOW_insn_format31i_in_instruction1944); |
| insn_format31i(); |
| state._fsp--; |
| |
| } |
| break; |
| case 25 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:743:5: insn_format31t |
| { |
| pushFollow(FOLLOW_insn_format31t_in_instruction1950); |
| insn_format31t(); |
| state._fsp--; |
| |
| } |
| break; |
| case 26 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:744:5: insn_format32x |
| { |
| pushFollow(FOLLOW_insn_format32x_in_instruction1956); |
| insn_format32x(); |
| state._fsp--; |
| |
| } |
| break; |
| case 27 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:745:5: insn_format35c_method |
| { |
| pushFollow(FOLLOW_insn_format35c_method_in_instruction1962); |
| insn_format35c_method(); |
| state._fsp--; |
| |
| } |
| break; |
| case 28 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:746:5: insn_format35c_type |
| { |
| pushFollow(FOLLOW_insn_format35c_type_in_instruction1968); |
| insn_format35c_type(); |
| state._fsp--; |
| |
| } |
| break; |
| case 29 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:747:5: insn_format3rc_method |
| { |
| pushFollow(FOLLOW_insn_format3rc_method_in_instruction1974); |
| insn_format3rc_method(); |
| state._fsp--; |
| |
| } |
| break; |
| case 30 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:748:5: insn_format3rc_type |
| { |
| pushFollow(FOLLOW_insn_format3rc_type_in_instruction1980); |
| insn_format3rc_type(); |
| state._fsp--; |
| |
| } |
| break; |
| case 31 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:749:5: insn_format51l_type |
| { |
| pushFollow(FOLLOW_insn_format51l_type_in_instruction1986); |
| insn_format51l_type(); |
| state._fsp--; |
| |
| } |
| break; |
| case 32 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:750:5: insn_array_data_directive |
| { |
| pushFollow(FOLLOW_insn_array_data_directive_in_instruction1992); |
| insn_array_data_directive(); |
| state._fsp--; |
| |
| } |
| break; |
| case 33 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:751:5: insn_packed_switch_directive |
| { |
| pushFollow(FOLLOW_insn_packed_switch_directive_in_instruction1998); |
| insn_packed_switch_directive(); |
| state._fsp--; |
| |
| } |
| break; |
| case 34 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:752:5: insn_sparse_switch_directive |
| { |
| pushFollow(FOLLOW_insn_sparse_switch_directive_in_instruction2004); |
| insn_sparse_switch_directive(); |
| state._fsp--; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (Exception ex) { |
| |
| reportError(new SemanticException(input, ((CommonTree)retval.start), ex.getMessage())); |
| recover(input, null); |
| |
| } |
| |
| finally { |
| // do for sure before leaving |
| } |
| return retval; |
| } |
| // $ANTLR end "instruction" |
| |
| |
| |
| // $ANTLR start "insn_format10t" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:758:1: insn_format10t : ^( I_STATEMENT_FORMAT10t INSTRUCTION_FORMAT10t label_ref ) ; |
| public final void insn_format10t() throws RecognitionException { |
| CommonTree INSTRUCTION_FORMAT10t104=null; |
| Label label_ref105 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:759:3: ( ^( I_STATEMENT_FORMAT10t INSTRUCTION_FORMAT10t label_ref ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:760:5: ^( I_STATEMENT_FORMAT10t INSTRUCTION_FORMAT10t label_ref ) |
| { |
| match(input,I_STATEMENT_FORMAT10t,FOLLOW_I_STATEMENT_FORMAT10t_in_insn_format10t2028); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT10t104=(CommonTree)match(input,INSTRUCTION_FORMAT10t,FOLLOW_INSTRUCTION_FORMAT10t_in_insn_format10t2030); |
| pushFollow(FOLLOW_label_ref_in_insn_format10t2032); |
| label_ref105=label_ref(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT10t104!=null?INSTRUCTION_FORMAT10t104.getText():null)); |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction10t(opcode, label_ref105)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format10t" |
| |
| |
| |
| // $ANTLR start "insn_format10x" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:766:1: insn_format10x : ^( I_STATEMENT_FORMAT10x INSTRUCTION_FORMAT10x ) ; |
| public final void insn_format10x() throws RecognitionException { |
| CommonTree INSTRUCTION_FORMAT10x106=null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:767:3: ( ^( I_STATEMENT_FORMAT10x INSTRUCTION_FORMAT10x ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:768:5: ^( I_STATEMENT_FORMAT10x INSTRUCTION_FORMAT10x ) |
| { |
| match(input,I_STATEMENT_FORMAT10x,FOLLOW_I_STATEMENT_FORMAT10x_in_insn_format10x2055); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT10x106=(CommonTree)match(input,INSTRUCTION_FORMAT10x,FOLLOW_INSTRUCTION_FORMAT10x_in_insn_format10x2057); |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT10x106!=null?INSTRUCTION_FORMAT10x106.getText():null)); |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction10x(opcode)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format10x" |
| |
| |
| |
| // $ANTLR start "insn_format11n" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:774:1: insn_format11n : ^( I_STATEMENT_FORMAT11n INSTRUCTION_FORMAT11n REGISTER short_integral_literal ) ; |
| public final void insn_format11n() throws RecognitionException { |
| CommonTree INSTRUCTION_FORMAT11n107=null; |
| CommonTree REGISTER108=null; |
| short short_integral_literal109 =0; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:775:3: ( ^( I_STATEMENT_FORMAT11n INSTRUCTION_FORMAT11n REGISTER short_integral_literal ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:776:5: ^( I_STATEMENT_FORMAT11n INSTRUCTION_FORMAT11n REGISTER short_integral_literal ) |
| { |
| match(input,I_STATEMENT_FORMAT11n,FOLLOW_I_STATEMENT_FORMAT11n_in_insn_format11n2080); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT11n107=(CommonTree)match(input,INSTRUCTION_FORMAT11n,FOLLOW_INSTRUCTION_FORMAT11n_in_insn_format11n2082); |
| REGISTER108=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format11n2084); |
| pushFollow(FOLLOW_short_integral_literal_in_insn_format11n2086); |
| short_integral_literal109=short_integral_literal(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT11n107!=null?INSTRUCTION_FORMAT11n107.getText():null)); |
| byte regA = parseRegister_nibble((REGISTER108!=null?REGISTER108.getText():null)); |
| |
| short litB = short_integral_literal109; |
| LiteralTools.checkNibble(litB); |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction11n(opcode, regA, litB)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format11n" |
| |
| |
| |
| // $ANTLR start "insn_format11x" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:787:1: insn_format11x : ^( I_STATEMENT_FORMAT11x INSTRUCTION_FORMAT11x REGISTER ) ; |
| public final void insn_format11x() throws RecognitionException { |
| CommonTree INSTRUCTION_FORMAT11x110=null; |
| CommonTree REGISTER111=null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:788:3: ( ^( I_STATEMENT_FORMAT11x INSTRUCTION_FORMAT11x REGISTER ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:789:5: ^( I_STATEMENT_FORMAT11x INSTRUCTION_FORMAT11x REGISTER ) |
| { |
| match(input,I_STATEMENT_FORMAT11x,FOLLOW_I_STATEMENT_FORMAT11x_in_insn_format11x2109); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT11x110=(CommonTree)match(input,INSTRUCTION_FORMAT11x,FOLLOW_INSTRUCTION_FORMAT11x_in_insn_format11x2111); |
| REGISTER111=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format11x2113); |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT11x110!=null?INSTRUCTION_FORMAT11x110.getText():null)); |
| short regA = parseRegister_byte((REGISTER111!=null?REGISTER111.getText():null)); |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction11x(opcode, regA)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format11x" |
| |
| |
| |
| // $ANTLR start "insn_format12x" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:797:1: insn_format12x : ^( I_STATEMENT_FORMAT12x INSTRUCTION_FORMAT12x registerA= REGISTER registerB= REGISTER ) ; |
| public final void insn_format12x() throws RecognitionException { |
| CommonTree registerA=null; |
| CommonTree registerB=null; |
| CommonTree INSTRUCTION_FORMAT12x112=null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:798:3: ( ^( I_STATEMENT_FORMAT12x INSTRUCTION_FORMAT12x registerA= REGISTER registerB= REGISTER ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:799:5: ^( I_STATEMENT_FORMAT12x INSTRUCTION_FORMAT12x registerA= REGISTER registerB= REGISTER ) |
| { |
| match(input,I_STATEMENT_FORMAT12x,FOLLOW_I_STATEMENT_FORMAT12x_in_insn_format12x2136); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT12x112=(CommonTree)match(input,INSTRUCTION_FORMAT12x,FOLLOW_INSTRUCTION_FORMAT12x_in_insn_format12x2138); |
| registerA=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format12x2142); |
| registerB=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format12x2146); |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT12x112!=null?INSTRUCTION_FORMAT12x112.getText():null)); |
| byte regA = parseRegister_nibble((registerA!=null?registerA.getText():null)); |
| byte regB = parseRegister_nibble((registerB!=null?registerB.getText():null)); |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction12x(opcode, regA, regB)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format12x" |
| |
| |
| |
| // $ANTLR start "insn_format20bc" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:808:1: insn_format20bc : ^( I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc verification_error_type verification_error_reference ) ; |
| public final void insn_format20bc() throws RecognitionException { |
| CommonTree INSTRUCTION_FORMAT20bc113=null; |
| int verification_error_type114 =0; |
| ImmutableReference verification_error_reference115 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:809:3: ( ^( I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc verification_error_type verification_error_reference ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:810:5: ^( I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc verification_error_type verification_error_reference ) |
| { |
| match(input,I_STATEMENT_FORMAT20bc,FOLLOW_I_STATEMENT_FORMAT20bc_in_insn_format20bc2169); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT20bc113=(CommonTree)match(input,INSTRUCTION_FORMAT20bc,FOLLOW_INSTRUCTION_FORMAT20bc_in_insn_format20bc2171); |
| pushFollow(FOLLOW_verification_error_type_in_insn_format20bc2173); |
| verification_error_type114=verification_error_type(); |
| state._fsp--; |
| |
| pushFollow(FOLLOW_verification_error_reference_in_insn_format20bc2175); |
| verification_error_reference115=verification_error_reference(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT20bc113!=null?INSTRUCTION_FORMAT20bc113.getText():null)); |
| |
| int verificationError = verification_error_type114; |
| ImmutableReference referencedItem = verification_error_reference115; |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction20bc(opcode, verificationError, |
| dexBuilder.internReference(referencedItem))); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format20bc" |
| |
| |
| |
| // $ANTLR start "insn_format20t" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:821:1: insn_format20t : ^( I_STATEMENT_FORMAT20t INSTRUCTION_FORMAT20t label_ref ) ; |
| public final void insn_format20t() throws RecognitionException { |
| CommonTree INSTRUCTION_FORMAT20t116=null; |
| Label label_ref117 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:822:3: ( ^( I_STATEMENT_FORMAT20t INSTRUCTION_FORMAT20t label_ref ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:823:5: ^( I_STATEMENT_FORMAT20t INSTRUCTION_FORMAT20t label_ref ) |
| { |
| match(input,I_STATEMENT_FORMAT20t,FOLLOW_I_STATEMENT_FORMAT20t_in_insn_format20t2198); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT20t116=(CommonTree)match(input,INSTRUCTION_FORMAT20t,FOLLOW_INSTRUCTION_FORMAT20t_in_insn_format20t2200); |
| pushFollow(FOLLOW_label_ref_in_insn_format20t2202); |
| label_ref117=label_ref(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT20t116!=null?INSTRUCTION_FORMAT20t116.getText():null)); |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction20t(opcode, label_ref117)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format20t" |
| |
| |
| |
| // $ANTLR start "insn_format21c_field" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:829:1: insn_format21c_field : ^( I_STATEMENT_FORMAT21c_FIELD inst= ( INSTRUCTION_FORMAT21c_FIELD | INSTRUCTION_FORMAT21c_FIELD_ODEX ) REGISTER field_reference ) ; |
| public final void insn_format21c_field() throws RecognitionException { |
| CommonTree inst=null; |
| CommonTree REGISTER118=null; |
| ImmutableFieldReference field_reference119 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:830:3: ( ^( I_STATEMENT_FORMAT21c_FIELD inst= ( INSTRUCTION_FORMAT21c_FIELD | INSTRUCTION_FORMAT21c_FIELD_ODEX ) REGISTER field_reference ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:831:5: ^( I_STATEMENT_FORMAT21c_FIELD inst= ( INSTRUCTION_FORMAT21c_FIELD | INSTRUCTION_FORMAT21c_FIELD_ODEX ) REGISTER field_reference ) |
| { |
| match(input,I_STATEMENT_FORMAT21c_FIELD,FOLLOW_I_STATEMENT_FORMAT21c_FIELD_in_insn_format21c_field2225); |
| match(input, Token.DOWN, null); |
| inst=(CommonTree)input.LT(1); |
| if ( (input.LA(1) >= INSTRUCTION_FORMAT21c_FIELD && input.LA(1) <= INSTRUCTION_FORMAT21c_FIELD_ODEX) ) { |
| input.consume(); |
| state.errorRecovery=false; |
| } |
| else { |
| MismatchedSetException mse = new MismatchedSetException(null,input); |
| throw mse; |
| } |
| REGISTER118=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_field2237); |
| pushFollow(FOLLOW_field_reference_in_insn_format21c_field2239); |
| field_reference119=field_reference(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((inst!=null?inst.getText():null)); |
| short regA = parseRegister_byte((REGISTER118!=null?REGISTER118.getText():null)); |
| |
| ImmutableFieldReference fieldReference = field_reference119; |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction21c(opcode, regA, |
| dexBuilder.internFieldReference(fieldReference))); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format21c_field" |
| |
| |
| |
| // $ANTLR start "insn_format21c_string" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:842:1: insn_format21c_string : ^( I_STATEMENT_FORMAT21c_STRING INSTRUCTION_FORMAT21c_STRING REGISTER string_literal ) ; |
| public final void insn_format21c_string() throws RecognitionException { |
| CommonTree INSTRUCTION_FORMAT21c_STRING120=null; |
| CommonTree REGISTER121=null; |
| String string_literal122 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:843:3: ( ^( I_STATEMENT_FORMAT21c_STRING INSTRUCTION_FORMAT21c_STRING REGISTER string_literal ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:844:5: ^( I_STATEMENT_FORMAT21c_STRING INSTRUCTION_FORMAT21c_STRING REGISTER string_literal ) |
| { |
| match(input,I_STATEMENT_FORMAT21c_STRING,FOLLOW_I_STATEMENT_FORMAT21c_STRING_in_insn_format21c_string2262); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT21c_STRING120=(CommonTree)match(input,INSTRUCTION_FORMAT21c_STRING,FOLLOW_INSTRUCTION_FORMAT21c_STRING_in_insn_format21c_string2264); |
| REGISTER121=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_string2266); |
| pushFollow(FOLLOW_string_literal_in_insn_format21c_string2268); |
| string_literal122=string_literal(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT21c_STRING120!=null?INSTRUCTION_FORMAT21c_STRING120.getText():null)); |
| short regA = parseRegister_byte((REGISTER121!=null?REGISTER121.getText():null)); |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction21c(opcode, regA, |
| dexBuilder.internStringReference(string_literal122))); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format21c_string" |
| |
| |
| |
| // $ANTLR start "insn_format21c_type" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:853:1: insn_format21c_type : ^( I_STATEMENT_FORMAT21c_TYPE INSTRUCTION_FORMAT21c_TYPE REGISTER nonvoid_type_descriptor ) ; |
| public final void insn_format21c_type() throws RecognitionException { |
| CommonTree INSTRUCTION_FORMAT21c_TYPE123=null; |
| CommonTree REGISTER124=null; |
| TreeRuleReturnScope nonvoid_type_descriptor125 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:854:3: ( ^( I_STATEMENT_FORMAT21c_TYPE INSTRUCTION_FORMAT21c_TYPE REGISTER nonvoid_type_descriptor ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:855:5: ^( I_STATEMENT_FORMAT21c_TYPE INSTRUCTION_FORMAT21c_TYPE REGISTER nonvoid_type_descriptor ) |
| { |
| match(input,I_STATEMENT_FORMAT21c_TYPE,FOLLOW_I_STATEMENT_FORMAT21c_TYPE_in_insn_format21c_type2291); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT21c_TYPE123=(CommonTree)match(input,INSTRUCTION_FORMAT21c_TYPE,FOLLOW_INSTRUCTION_FORMAT21c_TYPE_in_insn_format21c_type2293); |
| REGISTER124=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_type2295); |
| pushFollow(FOLLOW_nonvoid_type_descriptor_in_insn_format21c_type2297); |
| nonvoid_type_descriptor125=nonvoid_type_descriptor(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT21c_TYPE123!=null?INSTRUCTION_FORMAT21c_TYPE123.getText():null)); |
| short regA = parseRegister_byte((REGISTER124!=null?REGISTER124.getText():null)); |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction21c(opcode, regA, |
| dexBuilder.internTypeReference((nonvoid_type_descriptor125!=null?((smaliTreeWalker.nonvoid_type_descriptor_return)nonvoid_type_descriptor125).type:null)))); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format21c_type" |
| |
| |
| |
| // $ANTLR start "insn_format21ih" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:864:1: insn_format21ih : ^( I_STATEMENT_FORMAT21ih INSTRUCTION_FORMAT21ih REGISTER fixed_32bit_literal ) ; |
| public final void insn_format21ih() throws RecognitionException { |
| CommonTree INSTRUCTION_FORMAT21ih126=null; |
| CommonTree REGISTER127=null; |
| int fixed_32bit_literal128 =0; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:865:3: ( ^( I_STATEMENT_FORMAT21ih INSTRUCTION_FORMAT21ih REGISTER fixed_32bit_literal ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:866:5: ^( I_STATEMENT_FORMAT21ih INSTRUCTION_FORMAT21ih REGISTER fixed_32bit_literal ) |
| { |
| match(input,I_STATEMENT_FORMAT21ih,FOLLOW_I_STATEMENT_FORMAT21ih_in_insn_format21ih2320); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT21ih126=(CommonTree)match(input,INSTRUCTION_FORMAT21ih,FOLLOW_INSTRUCTION_FORMAT21ih_in_insn_format21ih2322); |
| REGISTER127=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21ih2324); |
| pushFollow(FOLLOW_fixed_32bit_literal_in_insn_format21ih2326); |
| fixed_32bit_literal128=fixed_32bit_literal(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT21ih126!=null?INSTRUCTION_FORMAT21ih126.getText():null)); |
| short regA = parseRegister_byte((REGISTER127!=null?REGISTER127.getText():null)); |
| |
| int litB = fixed_32bit_literal128; |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction21ih(opcode, regA, litB)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format21ih" |
| |
| |
| |
| // $ANTLR start "insn_format21lh" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:876:1: insn_format21lh : ^( I_STATEMENT_FORMAT21lh INSTRUCTION_FORMAT21lh REGISTER fixed_64bit_literal ) ; |
| public final void insn_format21lh() throws RecognitionException { |
| CommonTree INSTRUCTION_FORMAT21lh129=null; |
| CommonTree REGISTER130=null; |
| long fixed_64bit_literal131 =0; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:877:3: ( ^( I_STATEMENT_FORMAT21lh INSTRUCTION_FORMAT21lh REGISTER fixed_64bit_literal ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:878:5: ^( I_STATEMENT_FORMAT21lh INSTRUCTION_FORMAT21lh REGISTER fixed_64bit_literal ) |
| { |
| match(input,I_STATEMENT_FORMAT21lh,FOLLOW_I_STATEMENT_FORMAT21lh_in_insn_format21lh2349); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT21lh129=(CommonTree)match(input,INSTRUCTION_FORMAT21lh,FOLLOW_INSTRUCTION_FORMAT21lh_in_insn_format21lh2351); |
| REGISTER130=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21lh2353); |
| pushFollow(FOLLOW_fixed_64bit_literal_in_insn_format21lh2355); |
| fixed_64bit_literal131=fixed_64bit_literal(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT21lh129!=null?INSTRUCTION_FORMAT21lh129.getText():null)); |
| short regA = parseRegister_byte((REGISTER130!=null?REGISTER130.getText():null)); |
| |
| long litB = fixed_64bit_literal131; |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction21lh(opcode, regA, litB)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format21lh" |
| |
| |
| |
| // $ANTLR start "insn_format21s" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:888:1: insn_format21s : ^( I_STATEMENT_FORMAT21s INSTRUCTION_FORMAT21s REGISTER short_integral_literal ) ; |
| public final void insn_format21s() throws RecognitionException { |
| CommonTree INSTRUCTION_FORMAT21s132=null; |
| CommonTree REGISTER133=null; |
| short short_integral_literal134 =0; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:889:3: ( ^( I_STATEMENT_FORMAT21s INSTRUCTION_FORMAT21s REGISTER short_integral_literal ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:890:5: ^( I_STATEMENT_FORMAT21s INSTRUCTION_FORMAT21s REGISTER short_integral_literal ) |
| { |
| match(input,I_STATEMENT_FORMAT21s,FOLLOW_I_STATEMENT_FORMAT21s_in_insn_format21s2378); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT21s132=(CommonTree)match(input,INSTRUCTION_FORMAT21s,FOLLOW_INSTRUCTION_FORMAT21s_in_insn_format21s2380); |
| REGISTER133=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21s2382); |
| pushFollow(FOLLOW_short_integral_literal_in_insn_format21s2384); |
| short_integral_literal134=short_integral_literal(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT21s132!=null?INSTRUCTION_FORMAT21s132.getText():null)); |
| short regA = parseRegister_byte((REGISTER133!=null?REGISTER133.getText():null)); |
| |
| short litB = short_integral_literal134; |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction21s(opcode, regA, litB)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format21s" |
| |
| |
| |
| // $ANTLR start "insn_format21t" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:900:1: insn_format21t : ^( I_STATEMENT_FORMAT21t INSTRUCTION_FORMAT21t REGISTER label_ref ) ; |
| public final void insn_format21t() throws RecognitionException { |
| CommonTree INSTRUCTION_FORMAT21t135=null; |
| CommonTree REGISTER136=null; |
| Label label_ref137 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:901:3: ( ^( I_STATEMENT_FORMAT21t INSTRUCTION_FORMAT21t REGISTER label_ref ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:902:5: ^( I_STATEMENT_FORMAT21t INSTRUCTION_FORMAT21t REGISTER label_ref ) |
| { |
| match(input,I_STATEMENT_FORMAT21t,FOLLOW_I_STATEMENT_FORMAT21t_in_insn_format21t2407); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT21t135=(CommonTree)match(input,INSTRUCTION_FORMAT21t,FOLLOW_INSTRUCTION_FORMAT21t_in_insn_format21t2409); |
| REGISTER136=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21t2411); |
| pushFollow(FOLLOW_label_ref_in_insn_format21t2413); |
| label_ref137=label_ref(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT21t135!=null?INSTRUCTION_FORMAT21t135.getText():null)); |
| short regA = parseRegister_byte((REGISTER136!=null?REGISTER136.getText():null)); |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction21t(opcode, regA, label_ref137)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format21t" |
| |
| |
| |
| // $ANTLR start "insn_format22b" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:910:1: insn_format22b : ^( I_STATEMENT_FORMAT22b INSTRUCTION_FORMAT22b registerA= REGISTER registerB= REGISTER short_integral_literal ) ; |
| public final void insn_format22b() throws RecognitionException { |
| CommonTree registerA=null; |
| CommonTree registerB=null; |
| CommonTree INSTRUCTION_FORMAT22b138=null; |
| short short_integral_literal139 =0; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:911:3: ( ^( I_STATEMENT_FORMAT22b INSTRUCTION_FORMAT22b registerA= REGISTER registerB= REGISTER short_integral_literal ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:912:5: ^( I_STATEMENT_FORMAT22b INSTRUCTION_FORMAT22b registerA= REGISTER registerB= REGISTER short_integral_literal ) |
| { |
| match(input,I_STATEMENT_FORMAT22b,FOLLOW_I_STATEMENT_FORMAT22b_in_insn_format22b2436); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT22b138=(CommonTree)match(input,INSTRUCTION_FORMAT22b,FOLLOW_INSTRUCTION_FORMAT22b_in_insn_format22b2438); |
| registerA=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22b2442); |
| registerB=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22b2446); |
| pushFollow(FOLLOW_short_integral_literal_in_insn_format22b2448); |
| short_integral_literal139=short_integral_literal(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT22b138!=null?INSTRUCTION_FORMAT22b138.getText():null)); |
| short regA = parseRegister_byte((registerA!=null?registerA.getText():null)); |
| short regB = parseRegister_byte((registerB!=null?registerB.getText():null)); |
| |
| short litC = short_integral_literal139; |
| LiteralTools.checkByte(litC); |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction22b(opcode, regA, regB, litC)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format22b" |
| |
| |
| |
| // $ANTLR start "insn_format22c_field" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:924:1: insn_format22c_field : ^( I_STATEMENT_FORMAT22c_FIELD inst= ( INSTRUCTION_FORMAT22c_FIELD | INSTRUCTION_FORMAT22c_FIELD_ODEX ) registerA= REGISTER registerB= REGISTER field_reference ) ; |
| public final void insn_format22c_field() throws RecognitionException { |
| CommonTree inst=null; |
| CommonTree registerA=null; |
| CommonTree registerB=null; |
| ImmutableFieldReference field_reference140 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:925:3: ( ^( I_STATEMENT_FORMAT22c_FIELD inst= ( INSTRUCTION_FORMAT22c_FIELD | INSTRUCTION_FORMAT22c_FIELD_ODEX ) registerA= REGISTER registerB= REGISTER field_reference ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:926:5: ^( I_STATEMENT_FORMAT22c_FIELD inst= ( INSTRUCTION_FORMAT22c_FIELD | INSTRUCTION_FORMAT22c_FIELD_ODEX ) registerA= REGISTER registerB= REGISTER field_reference ) |
| { |
| match(input,I_STATEMENT_FORMAT22c_FIELD,FOLLOW_I_STATEMENT_FORMAT22c_FIELD_in_insn_format22c_field2471); |
| match(input, Token.DOWN, null); |
| inst=(CommonTree)input.LT(1); |
| if ( (input.LA(1) >= INSTRUCTION_FORMAT22c_FIELD && input.LA(1) <= INSTRUCTION_FORMAT22c_FIELD_ODEX) ) { |
| input.consume(); |
| state.errorRecovery=false; |
| } |
| else { |
| MismatchedSetException mse = new MismatchedSetException(null,input); |
| throw mse; |
| } |
| registerA=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_field2485); |
| registerB=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_field2489); |
| pushFollow(FOLLOW_field_reference_in_insn_format22c_field2491); |
| field_reference140=field_reference(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((inst!=null?inst.getText():null)); |
| byte regA = parseRegister_nibble((registerA!=null?registerA.getText():null)); |
| byte regB = parseRegister_nibble((registerB!=null?registerB.getText():null)); |
| |
| ImmutableFieldReference fieldReference = field_reference140; |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction22c(opcode, regA, regB, |
| dexBuilder.internFieldReference(fieldReference))); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format22c_field" |
| |
| |
| |
| // $ANTLR start "insn_format22c_type" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:938:1: insn_format22c_type : ^( I_STATEMENT_FORMAT22c_TYPE INSTRUCTION_FORMAT22c_TYPE registerA= REGISTER registerB= REGISTER nonvoid_type_descriptor ) ; |
| public final void insn_format22c_type() throws RecognitionException { |
| CommonTree registerA=null; |
| CommonTree registerB=null; |
| CommonTree INSTRUCTION_FORMAT22c_TYPE141=null; |
| TreeRuleReturnScope nonvoid_type_descriptor142 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:939:3: ( ^( I_STATEMENT_FORMAT22c_TYPE INSTRUCTION_FORMAT22c_TYPE registerA= REGISTER registerB= REGISTER nonvoid_type_descriptor ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:940:5: ^( I_STATEMENT_FORMAT22c_TYPE INSTRUCTION_FORMAT22c_TYPE registerA= REGISTER registerB= REGISTER nonvoid_type_descriptor ) |
| { |
| match(input,I_STATEMENT_FORMAT22c_TYPE,FOLLOW_I_STATEMENT_FORMAT22c_TYPE_in_insn_format22c_type2514); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT22c_TYPE141=(CommonTree)match(input,INSTRUCTION_FORMAT22c_TYPE,FOLLOW_INSTRUCTION_FORMAT22c_TYPE_in_insn_format22c_type2516); |
| registerA=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_type2520); |
| registerB=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_type2524); |
| pushFollow(FOLLOW_nonvoid_type_descriptor_in_insn_format22c_type2526); |
| nonvoid_type_descriptor142=nonvoid_type_descriptor(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT22c_TYPE141!=null?INSTRUCTION_FORMAT22c_TYPE141.getText():null)); |
| byte regA = parseRegister_nibble((registerA!=null?registerA.getText():null)); |
| byte regB = parseRegister_nibble((registerB!=null?registerB.getText():null)); |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction22c(opcode, regA, regB, |
| dexBuilder.internTypeReference((nonvoid_type_descriptor142!=null?((smaliTreeWalker.nonvoid_type_descriptor_return)nonvoid_type_descriptor142).type:null)))); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format22c_type" |
| |
| |
| |
| // $ANTLR start "insn_format22s" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:950:1: insn_format22s : ^( I_STATEMENT_FORMAT22s INSTRUCTION_FORMAT22s registerA= REGISTER registerB= REGISTER short_integral_literal ) ; |
| public final void insn_format22s() throws RecognitionException { |
| CommonTree registerA=null; |
| CommonTree registerB=null; |
| CommonTree INSTRUCTION_FORMAT22s143=null; |
| short short_integral_literal144 =0; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:951:3: ( ^( I_STATEMENT_FORMAT22s INSTRUCTION_FORMAT22s registerA= REGISTER registerB= REGISTER short_integral_literal ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:952:5: ^( I_STATEMENT_FORMAT22s INSTRUCTION_FORMAT22s registerA= REGISTER registerB= REGISTER short_integral_literal ) |
| { |
| match(input,I_STATEMENT_FORMAT22s,FOLLOW_I_STATEMENT_FORMAT22s_in_insn_format22s2549); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT22s143=(CommonTree)match(input,INSTRUCTION_FORMAT22s,FOLLOW_INSTRUCTION_FORMAT22s_in_insn_format22s2551); |
| registerA=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22s2555); |
| registerB=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22s2559); |
| pushFollow(FOLLOW_short_integral_literal_in_insn_format22s2561); |
| short_integral_literal144=short_integral_literal(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT22s143!=null?INSTRUCTION_FORMAT22s143.getText():null)); |
| byte regA = parseRegister_nibble((registerA!=null?registerA.getText():null)); |
| byte regB = parseRegister_nibble((registerB!=null?registerB.getText():null)); |
| |
| short litC = short_integral_literal144; |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction22s(opcode, regA, regB, litC)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format22s" |
| |
| |
| |
| // $ANTLR start "insn_format22t" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:963:1: insn_format22t : ^( I_STATEMENT_FORMAT22t INSTRUCTION_FORMAT22t registerA= REGISTER registerB= REGISTER label_ref ) ; |
| public final void insn_format22t() throws RecognitionException { |
| CommonTree registerA=null; |
| CommonTree registerB=null; |
| CommonTree INSTRUCTION_FORMAT22t145=null; |
| Label label_ref146 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:964:3: ( ^( I_STATEMENT_FORMAT22t INSTRUCTION_FORMAT22t registerA= REGISTER registerB= REGISTER label_ref ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:965:5: ^( I_STATEMENT_FORMAT22t INSTRUCTION_FORMAT22t registerA= REGISTER registerB= REGISTER label_ref ) |
| { |
| match(input,I_STATEMENT_FORMAT22t,FOLLOW_I_STATEMENT_FORMAT22t_in_insn_format22t2584); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT22t145=(CommonTree)match(input,INSTRUCTION_FORMAT22t,FOLLOW_INSTRUCTION_FORMAT22t_in_insn_format22t2586); |
| registerA=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22t2590); |
| registerB=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22t2594); |
| pushFollow(FOLLOW_label_ref_in_insn_format22t2596); |
| label_ref146=label_ref(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT22t145!=null?INSTRUCTION_FORMAT22t145.getText():null)); |
| byte regA = parseRegister_nibble((registerA!=null?registerA.getText():null)); |
| byte regB = parseRegister_nibble((registerB!=null?registerB.getText():null)); |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction22t(opcode, regA, regB, label_ref146)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format22t" |
| |
| |
| |
| // $ANTLR start "insn_format22x" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:974:1: insn_format22x : ^( I_STATEMENT_FORMAT22x INSTRUCTION_FORMAT22x registerA= REGISTER registerB= REGISTER ) ; |
| public final void insn_format22x() throws RecognitionException { |
| CommonTree registerA=null; |
| CommonTree registerB=null; |
| CommonTree INSTRUCTION_FORMAT22x147=null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:975:3: ( ^( I_STATEMENT_FORMAT22x INSTRUCTION_FORMAT22x registerA= REGISTER registerB= REGISTER ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:976:5: ^( I_STATEMENT_FORMAT22x INSTRUCTION_FORMAT22x registerA= REGISTER registerB= REGISTER ) |
| { |
| match(input,I_STATEMENT_FORMAT22x,FOLLOW_I_STATEMENT_FORMAT22x_in_insn_format22x2619); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT22x147=(CommonTree)match(input,INSTRUCTION_FORMAT22x,FOLLOW_INSTRUCTION_FORMAT22x_in_insn_format22x2621); |
| registerA=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22x2625); |
| registerB=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22x2629); |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT22x147!=null?INSTRUCTION_FORMAT22x147.getText():null)); |
| short regA = parseRegister_byte((registerA!=null?registerA.getText():null)); |
| int regB = parseRegister_short((registerB!=null?registerB.getText():null)); |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction22x(opcode, regA, regB)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format22x" |
| |
| |
| |
| // $ANTLR start "insn_format23x" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:985:1: insn_format23x : ^( I_STATEMENT_FORMAT23x INSTRUCTION_FORMAT23x registerA= REGISTER registerB= REGISTER registerC= REGISTER ) ; |
| public final void insn_format23x() throws RecognitionException { |
| CommonTree registerA=null; |
| CommonTree registerB=null; |
| CommonTree registerC=null; |
| CommonTree INSTRUCTION_FORMAT23x148=null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:986:3: ( ^( I_STATEMENT_FORMAT23x INSTRUCTION_FORMAT23x registerA= REGISTER registerB= REGISTER registerC= REGISTER ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:987:5: ^( I_STATEMENT_FORMAT23x INSTRUCTION_FORMAT23x registerA= REGISTER registerB= REGISTER registerC= REGISTER ) |
| { |
| match(input,I_STATEMENT_FORMAT23x,FOLLOW_I_STATEMENT_FORMAT23x_in_insn_format23x2652); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT23x148=(CommonTree)match(input,INSTRUCTION_FORMAT23x,FOLLOW_INSTRUCTION_FORMAT23x_in_insn_format23x2654); |
| registerA=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format23x2658); |
| registerB=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format23x2662); |
| registerC=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format23x2666); |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT23x148!=null?INSTRUCTION_FORMAT23x148.getText():null)); |
| short regA = parseRegister_byte((registerA!=null?registerA.getText():null)); |
| short regB = parseRegister_byte((registerB!=null?registerB.getText():null)); |
| short regC = parseRegister_byte((registerC!=null?registerC.getText():null)); |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction23x(opcode, regA, regB, regC)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format23x" |
| |
| |
| |
| // $ANTLR start "insn_format30t" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:997:1: insn_format30t : ^( I_STATEMENT_FORMAT30t INSTRUCTION_FORMAT30t label_ref ) ; |
| public final void insn_format30t() throws RecognitionException { |
| CommonTree INSTRUCTION_FORMAT30t149=null; |
| Label label_ref150 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:998:3: ( ^( I_STATEMENT_FORMAT30t INSTRUCTION_FORMAT30t label_ref ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:999:5: ^( I_STATEMENT_FORMAT30t INSTRUCTION_FORMAT30t label_ref ) |
| { |
| match(input,I_STATEMENT_FORMAT30t,FOLLOW_I_STATEMENT_FORMAT30t_in_insn_format30t2689); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT30t149=(CommonTree)match(input,INSTRUCTION_FORMAT30t,FOLLOW_INSTRUCTION_FORMAT30t_in_insn_format30t2691); |
| pushFollow(FOLLOW_label_ref_in_insn_format30t2693); |
| label_ref150=label_ref(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT30t149!=null?INSTRUCTION_FORMAT30t149.getText():null)); |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction30t(opcode, label_ref150)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format30t" |
| |
| |
| |
| // $ANTLR start "insn_format31c" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1006:1: insn_format31c : ^( I_STATEMENT_FORMAT31c INSTRUCTION_FORMAT31c REGISTER string_literal ) ; |
| public final void insn_format31c() throws RecognitionException { |
| CommonTree INSTRUCTION_FORMAT31c151=null; |
| CommonTree REGISTER152=null; |
| String string_literal153 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1007:3: ( ^( I_STATEMENT_FORMAT31c INSTRUCTION_FORMAT31c REGISTER string_literal ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1008:5: ^( I_STATEMENT_FORMAT31c INSTRUCTION_FORMAT31c REGISTER string_literal ) |
| { |
| match(input,I_STATEMENT_FORMAT31c,FOLLOW_I_STATEMENT_FORMAT31c_in_insn_format31c2716); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT31c151=(CommonTree)match(input,INSTRUCTION_FORMAT31c,FOLLOW_INSTRUCTION_FORMAT31c_in_insn_format31c2718); |
| REGISTER152=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format31c2720); |
| pushFollow(FOLLOW_string_literal_in_insn_format31c2722); |
| string_literal153=string_literal(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT31c151!=null?INSTRUCTION_FORMAT31c151.getText():null)); |
| short regA = parseRegister_byte((REGISTER152!=null?REGISTER152.getText():null)); |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction31c(opcode, regA, |
| dexBuilder.internStringReference(string_literal153))); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format31c" |
| |
| |
| |
| // $ANTLR start "insn_format31i" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1017:1: insn_format31i : ^( I_STATEMENT_FORMAT31i INSTRUCTION_FORMAT31i REGISTER fixed_32bit_literal ) ; |
| public final void insn_format31i() throws RecognitionException { |
| CommonTree INSTRUCTION_FORMAT31i154=null; |
| CommonTree REGISTER155=null; |
| int fixed_32bit_literal156 =0; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1018:3: ( ^( I_STATEMENT_FORMAT31i INSTRUCTION_FORMAT31i REGISTER fixed_32bit_literal ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1019:5: ^( I_STATEMENT_FORMAT31i INSTRUCTION_FORMAT31i REGISTER fixed_32bit_literal ) |
| { |
| match(input,I_STATEMENT_FORMAT31i,FOLLOW_I_STATEMENT_FORMAT31i_in_insn_format31i2745); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT31i154=(CommonTree)match(input,INSTRUCTION_FORMAT31i,FOLLOW_INSTRUCTION_FORMAT31i_in_insn_format31i2747); |
| REGISTER155=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format31i2749); |
| pushFollow(FOLLOW_fixed_32bit_literal_in_insn_format31i2751); |
| fixed_32bit_literal156=fixed_32bit_literal(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT31i154!=null?INSTRUCTION_FORMAT31i154.getText():null)); |
| short regA = parseRegister_byte((REGISTER155!=null?REGISTER155.getText():null)); |
| |
| int litB = fixed_32bit_literal156; |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction31i(opcode, regA, litB)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format31i" |
| |
| |
| |
| // $ANTLR start "insn_format31t" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1029:1: insn_format31t : ^( I_STATEMENT_FORMAT31t INSTRUCTION_FORMAT31t REGISTER label_ref ) ; |
| public final void insn_format31t() throws RecognitionException { |
| CommonTree INSTRUCTION_FORMAT31t157=null; |
| CommonTree REGISTER158=null; |
| Label label_ref159 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1030:3: ( ^( I_STATEMENT_FORMAT31t INSTRUCTION_FORMAT31t REGISTER label_ref ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1031:5: ^( I_STATEMENT_FORMAT31t INSTRUCTION_FORMAT31t REGISTER label_ref ) |
| { |
| match(input,I_STATEMENT_FORMAT31t,FOLLOW_I_STATEMENT_FORMAT31t_in_insn_format31t2774); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT31t157=(CommonTree)match(input,INSTRUCTION_FORMAT31t,FOLLOW_INSTRUCTION_FORMAT31t_in_insn_format31t2776); |
| REGISTER158=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format31t2778); |
| pushFollow(FOLLOW_label_ref_in_insn_format31t2780); |
| label_ref159=label_ref(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT31t157!=null?INSTRUCTION_FORMAT31t157.getText():null)); |
| |
| short regA = parseRegister_byte((REGISTER158!=null?REGISTER158.getText():null)); |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction31t(opcode, regA, label_ref159)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format31t" |
| |
| |
| |
| // $ANTLR start "insn_format32x" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1040:1: insn_format32x : ^( I_STATEMENT_FORMAT32x INSTRUCTION_FORMAT32x registerA= REGISTER registerB= REGISTER ) ; |
| public final void insn_format32x() throws RecognitionException { |
| CommonTree registerA=null; |
| CommonTree registerB=null; |
| CommonTree INSTRUCTION_FORMAT32x160=null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1041:3: ( ^( I_STATEMENT_FORMAT32x INSTRUCTION_FORMAT32x registerA= REGISTER registerB= REGISTER ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1042:5: ^( I_STATEMENT_FORMAT32x INSTRUCTION_FORMAT32x registerA= REGISTER registerB= REGISTER ) |
| { |
| match(input,I_STATEMENT_FORMAT32x,FOLLOW_I_STATEMENT_FORMAT32x_in_insn_format32x2803); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT32x160=(CommonTree)match(input,INSTRUCTION_FORMAT32x,FOLLOW_INSTRUCTION_FORMAT32x_in_insn_format32x2805); |
| registerA=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format32x2809); |
| registerB=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format32x2813); |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT32x160!=null?INSTRUCTION_FORMAT32x160.getText():null)); |
| int regA = parseRegister_short((registerA!=null?registerA.getText():null)); |
| int regB = parseRegister_short((registerB!=null?registerB.getText():null)); |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction32x(opcode, regA, regB)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format32x" |
| |
| |
| |
| // $ANTLR start "insn_format35c_method" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1051:1: insn_format35c_method : ^( I_STATEMENT_FORMAT35c_METHOD INSTRUCTION_FORMAT35c_METHOD register_list method_reference ) ; |
| public final void insn_format35c_method() throws RecognitionException { |
| CommonTree INSTRUCTION_FORMAT35c_METHOD161=null; |
| TreeRuleReturnScope register_list162 =null; |
| ImmutableMethodReference method_reference163 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1052:3: ( ^( I_STATEMENT_FORMAT35c_METHOD INSTRUCTION_FORMAT35c_METHOD register_list method_reference ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1053:5: ^( I_STATEMENT_FORMAT35c_METHOD INSTRUCTION_FORMAT35c_METHOD register_list method_reference ) |
| { |
| match(input,I_STATEMENT_FORMAT35c_METHOD,FOLLOW_I_STATEMENT_FORMAT35c_METHOD_in_insn_format35c_method2836); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT35c_METHOD161=(CommonTree)match(input,INSTRUCTION_FORMAT35c_METHOD,FOLLOW_INSTRUCTION_FORMAT35c_METHOD_in_insn_format35c_method2838); |
| pushFollow(FOLLOW_register_list_in_insn_format35c_method2840); |
| register_list162=register_list(); |
| state._fsp--; |
| |
| pushFollow(FOLLOW_method_reference_in_insn_format35c_method2842); |
| method_reference163=method_reference(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT35c_METHOD161!=null?INSTRUCTION_FORMAT35c_METHOD161.getText():null)); |
| |
| //this depends on the fact that register_list returns a byte[5] |
| byte[] registers = (register_list162!=null?((smaliTreeWalker.register_list_return)register_list162).registers:null); |
| byte registerCount = (register_list162!=null?((smaliTreeWalker.register_list_return)register_list162).registerCount:0); |
| |
| ImmutableMethodReference methodReference = method_reference163; |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction35c(opcode, registerCount, registers[0], registers[1], |
| registers[2], registers[3], registers[4], dexBuilder.internMethodReference(methodReference))); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format35c_method" |
| |
| |
| |
| // $ANTLR start "insn_format35c_type" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1067:1: insn_format35c_type : ^( I_STATEMENT_FORMAT35c_TYPE INSTRUCTION_FORMAT35c_TYPE register_list nonvoid_type_descriptor ) ; |
| public final void insn_format35c_type() throws RecognitionException { |
| CommonTree INSTRUCTION_FORMAT35c_TYPE164=null; |
| TreeRuleReturnScope register_list165 =null; |
| TreeRuleReturnScope nonvoid_type_descriptor166 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1068:3: ( ^( I_STATEMENT_FORMAT35c_TYPE INSTRUCTION_FORMAT35c_TYPE register_list nonvoid_type_descriptor ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1069:5: ^( I_STATEMENT_FORMAT35c_TYPE INSTRUCTION_FORMAT35c_TYPE register_list nonvoid_type_descriptor ) |
| { |
| match(input,I_STATEMENT_FORMAT35c_TYPE,FOLLOW_I_STATEMENT_FORMAT35c_TYPE_in_insn_format35c_type2865); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT35c_TYPE164=(CommonTree)match(input,INSTRUCTION_FORMAT35c_TYPE,FOLLOW_INSTRUCTION_FORMAT35c_TYPE_in_insn_format35c_type2867); |
| pushFollow(FOLLOW_register_list_in_insn_format35c_type2869); |
| register_list165=register_list(); |
| state._fsp--; |
| |
| pushFollow(FOLLOW_nonvoid_type_descriptor_in_insn_format35c_type2871); |
| nonvoid_type_descriptor166=nonvoid_type_descriptor(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT35c_TYPE164!=null?INSTRUCTION_FORMAT35c_TYPE164.getText():null)); |
| |
| //this depends on the fact that register_list returns a byte[5] |
| byte[] registers = (register_list165!=null?((smaliTreeWalker.register_list_return)register_list165).registers:null); |
| byte registerCount = (register_list165!=null?((smaliTreeWalker.register_list_return)register_list165).registerCount:0); |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction35c(opcode, registerCount, registers[0], registers[1], |
| registers[2], registers[3], registers[4], dexBuilder.internTypeReference((nonvoid_type_descriptor166!=null?((smaliTreeWalker.nonvoid_type_descriptor_return)nonvoid_type_descriptor166).type:null)))); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format35c_type" |
| |
| |
| |
| // $ANTLR start "insn_format3rc_method" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1081:1: insn_format3rc_method : ^( I_STATEMENT_FORMAT3rc_METHOD INSTRUCTION_FORMAT3rc_METHOD register_range method_reference ) ; |
| public final void insn_format3rc_method() throws RecognitionException { |
| CommonTree INSTRUCTION_FORMAT3rc_METHOD167=null; |
| TreeRuleReturnScope register_range168 =null; |
| ImmutableMethodReference method_reference169 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1082:3: ( ^( I_STATEMENT_FORMAT3rc_METHOD INSTRUCTION_FORMAT3rc_METHOD register_range method_reference ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1083:5: ^( I_STATEMENT_FORMAT3rc_METHOD INSTRUCTION_FORMAT3rc_METHOD register_range method_reference ) |
| { |
| match(input,I_STATEMENT_FORMAT3rc_METHOD,FOLLOW_I_STATEMENT_FORMAT3rc_METHOD_in_insn_format3rc_method2894); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT3rc_METHOD167=(CommonTree)match(input,INSTRUCTION_FORMAT3rc_METHOD,FOLLOW_INSTRUCTION_FORMAT3rc_METHOD_in_insn_format3rc_method2896); |
| pushFollow(FOLLOW_register_range_in_insn_format3rc_method2898); |
| register_range168=register_range(); |
| state._fsp--; |
| |
| pushFollow(FOLLOW_method_reference_in_insn_format3rc_method2900); |
| method_reference169=method_reference(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT3rc_METHOD167!=null?INSTRUCTION_FORMAT3rc_METHOD167.getText():null)); |
| int startRegister = (register_range168!=null?((smaliTreeWalker.register_range_return)register_range168).startRegister:0); |
| int endRegister = (register_range168!=null?((smaliTreeWalker.register_range_return)register_range168).endRegister:0); |
| |
| int registerCount = endRegister-startRegister+1; |
| |
| ImmutableMethodReference methodReference = method_reference169; |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction3rc(opcode, startRegister, registerCount, |
| dexBuilder.internMethodReference(methodReference))); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format3rc_method" |
| |
| |
| |
| // $ANTLR start "insn_format3rc_type" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1097:1: insn_format3rc_type : ^( I_STATEMENT_FORMAT3rc_TYPE INSTRUCTION_FORMAT3rc_TYPE register_range nonvoid_type_descriptor ) ; |
| public final void insn_format3rc_type() throws RecognitionException { |
| CommonTree INSTRUCTION_FORMAT3rc_TYPE170=null; |
| TreeRuleReturnScope register_range171 =null; |
| TreeRuleReturnScope nonvoid_type_descriptor172 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1098:3: ( ^( I_STATEMENT_FORMAT3rc_TYPE INSTRUCTION_FORMAT3rc_TYPE register_range nonvoid_type_descriptor ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1099:5: ^( I_STATEMENT_FORMAT3rc_TYPE INSTRUCTION_FORMAT3rc_TYPE register_range nonvoid_type_descriptor ) |
| { |
| match(input,I_STATEMENT_FORMAT3rc_TYPE,FOLLOW_I_STATEMENT_FORMAT3rc_TYPE_in_insn_format3rc_type2923); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT3rc_TYPE170=(CommonTree)match(input,INSTRUCTION_FORMAT3rc_TYPE,FOLLOW_INSTRUCTION_FORMAT3rc_TYPE_in_insn_format3rc_type2925); |
| pushFollow(FOLLOW_register_range_in_insn_format3rc_type2927); |
| register_range171=register_range(); |
| state._fsp--; |
| |
| pushFollow(FOLLOW_nonvoid_type_descriptor_in_insn_format3rc_type2929); |
| nonvoid_type_descriptor172=nonvoid_type_descriptor(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT3rc_TYPE170!=null?INSTRUCTION_FORMAT3rc_TYPE170.getText():null)); |
| int startRegister = (register_range171!=null?((smaliTreeWalker.register_range_return)register_range171).startRegister:0); |
| int endRegister = (register_range171!=null?((smaliTreeWalker.register_range_return)register_range171).endRegister:0); |
| |
| int registerCount = endRegister-startRegister+1; |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction3rc(opcode, startRegister, registerCount, |
| dexBuilder.internTypeReference((nonvoid_type_descriptor172!=null?((smaliTreeWalker.nonvoid_type_descriptor_return)nonvoid_type_descriptor172).type:null)))); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format3rc_type" |
| |
| |
| |
| // $ANTLR start "insn_format51l_type" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1111:1: insn_format51l_type : ^( I_STATEMENT_FORMAT51l INSTRUCTION_FORMAT51l REGISTER fixed_64bit_literal ) ; |
| public final void insn_format51l_type() throws RecognitionException { |
| CommonTree INSTRUCTION_FORMAT51l173=null; |
| CommonTree REGISTER174=null; |
| long fixed_64bit_literal175 =0; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1112:3: ( ^( I_STATEMENT_FORMAT51l INSTRUCTION_FORMAT51l REGISTER fixed_64bit_literal ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1113:5: ^( I_STATEMENT_FORMAT51l INSTRUCTION_FORMAT51l REGISTER fixed_64bit_literal ) |
| { |
| match(input,I_STATEMENT_FORMAT51l,FOLLOW_I_STATEMENT_FORMAT51l_in_insn_format51l_type2952); |
| match(input, Token.DOWN, null); |
| INSTRUCTION_FORMAT51l173=(CommonTree)match(input,INSTRUCTION_FORMAT51l,FOLLOW_INSTRUCTION_FORMAT51l_in_insn_format51l_type2954); |
| REGISTER174=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format51l_type2956); |
| pushFollow(FOLLOW_fixed_64bit_literal_in_insn_format51l_type2958); |
| fixed_64bit_literal175=fixed_64bit_literal(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT51l173!=null?INSTRUCTION_FORMAT51l173.getText():null)); |
| short regA = parseRegister_byte((REGISTER174!=null?REGISTER174.getText():null)); |
| |
| long litB = fixed_64bit_literal175; |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction51l(opcode, regA, litB)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_format51l_type" |
| |
| |
| |
| // $ANTLR start "insn_array_data_directive" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1123:1: insn_array_data_directive : ^( I_STATEMENT_ARRAY_DATA ^( I_ARRAY_ELEMENT_SIZE short_integral_literal ) array_elements ) ; |
| public final void insn_array_data_directive() throws RecognitionException { |
| short short_integral_literal176 =0; |
| List<Number> array_elements177 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1124:3: ( ^( I_STATEMENT_ARRAY_DATA ^( I_ARRAY_ELEMENT_SIZE short_integral_literal ) array_elements ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1125:5: ^( I_STATEMENT_ARRAY_DATA ^( I_ARRAY_ELEMENT_SIZE short_integral_literal ) array_elements ) |
| { |
| match(input,I_STATEMENT_ARRAY_DATA,FOLLOW_I_STATEMENT_ARRAY_DATA_in_insn_array_data_directive2981); |
| match(input, Token.DOWN, null); |
| match(input,I_ARRAY_ELEMENT_SIZE,FOLLOW_I_ARRAY_ELEMENT_SIZE_in_insn_array_data_directive2984); |
| match(input, Token.DOWN, null); |
| pushFollow(FOLLOW_short_integral_literal_in_insn_array_data_directive2986); |
| short_integral_literal176=short_integral_literal(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| pushFollow(FOLLOW_array_elements_in_insn_array_data_directive2989); |
| array_elements177=array_elements(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| int elementWidth = short_integral_literal176; |
| List<Number> elements = array_elements177; |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderArrayPayload(elementWidth, array_elements177)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_array_data_directive" |
| |
| |
| |
| // $ANTLR start "insn_packed_switch_directive" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1133:1: insn_packed_switch_directive : ^( I_STATEMENT_PACKED_SWITCH ^( I_PACKED_SWITCH_START_KEY fixed_32bit_literal ) packed_switch_elements ) ; |
| public final void insn_packed_switch_directive() throws RecognitionException { |
| int fixed_32bit_literal178 =0; |
| List<Label> packed_switch_elements179 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1134:3: ( ^( I_STATEMENT_PACKED_SWITCH ^( I_PACKED_SWITCH_START_KEY fixed_32bit_literal ) packed_switch_elements ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1135:5: ^( I_STATEMENT_PACKED_SWITCH ^( I_PACKED_SWITCH_START_KEY fixed_32bit_literal ) packed_switch_elements ) |
| { |
| match(input,I_STATEMENT_PACKED_SWITCH,FOLLOW_I_STATEMENT_PACKED_SWITCH_in_insn_packed_switch_directive3011); |
| match(input, Token.DOWN, null); |
| match(input,I_PACKED_SWITCH_START_KEY,FOLLOW_I_PACKED_SWITCH_START_KEY_in_insn_packed_switch_directive3014); |
| match(input, Token.DOWN, null); |
| pushFollow(FOLLOW_fixed_32bit_literal_in_insn_packed_switch_directive3016); |
| fixed_32bit_literal178=fixed_32bit_literal(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| pushFollow(FOLLOW_packed_switch_elements_in_insn_packed_switch_directive3019); |
| packed_switch_elements179=packed_switch_elements(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| int startKey = fixed_32bit_literal178; |
| method_stack.peek().methodBuilder.addInstruction(new BuilderPackedSwitchPayload(startKey, |
| packed_switch_elements179)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_packed_switch_directive" |
| |
| |
| |
| // $ANTLR start "insn_sparse_switch_directive" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1142:1: insn_sparse_switch_directive : ^( I_STATEMENT_SPARSE_SWITCH sparse_switch_elements ) ; |
| public final void insn_sparse_switch_directive() throws RecognitionException { |
| List<SwitchLabelElement> sparse_switch_elements180 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1143:3: ( ^( I_STATEMENT_SPARSE_SWITCH sparse_switch_elements ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1144:5: ^( I_STATEMENT_SPARSE_SWITCH sparse_switch_elements ) |
| { |
| match(input,I_STATEMENT_SPARSE_SWITCH,FOLLOW_I_STATEMENT_SPARSE_SWITCH_in_insn_sparse_switch_directive3043); |
| match(input, Token.DOWN, null); |
| pushFollow(FOLLOW_sparse_switch_elements_in_insn_sparse_switch_directive3045); |
| sparse_switch_elements180=sparse_switch_elements(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| method_stack.peek().methodBuilder.addInstruction(new BuilderSparseSwitchPayload(sparse_switch_elements180)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| } |
| // $ANTLR end "insn_sparse_switch_directive" |
| |
| |
| public static class nonvoid_type_descriptor_return extends TreeRuleReturnScope { |
| public String type; |
| }; |
| |
| |
| // $ANTLR start "nonvoid_type_descriptor" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1149:1: nonvoid_type_descriptor returns [String type] : ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR | ARRAY_DESCRIPTOR ) ; |
| public final smaliTreeWalker.nonvoid_type_descriptor_return nonvoid_type_descriptor() throws RecognitionException { |
| smaliTreeWalker.nonvoid_type_descriptor_return retval = new smaliTreeWalker.nonvoid_type_descriptor_return(); |
| retval.start = input.LT(1); |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1150:3: ( ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR | ARRAY_DESCRIPTOR ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1150:5: ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR | ARRAY_DESCRIPTOR ) |
| { |
| if ( input.LA(1)==ARRAY_DESCRIPTOR||input.LA(1)==CLASS_DESCRIPTOR||input.LA(1)==PRIMITIVE_TYPE ) { |
| input.consume(); |
| state.errorRecovery=false; |
| } |
| else { |
| MismatchedSetException mse = new MismatchedSetException(null,input); |
| throw mse; |
| } |
| |
| retval.type = ((CommonTree)retval.start).getText(); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return retval; |
| } |
| // $ANTLR end "nonvoid_type_descriptor" |
| |
| |
| public static class reference_type_descriptor_return extends TreeRuleReturnScope { |
| public String type; |
| }; |
| |
| |
| // $ANTLR start "reference_type_descriptor" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1157:1: reference_type_descriptor returns [String type] : ( CLASS_DESCRIPTOR | ARRAY_DESCRIPTOR ) ; |
| public final smaliTreeWalker.reference_type_descriptor_return reference_type_descriptor() throws RecognitionException { |
| smaliTreeWalker.reference_type_descriptor_return retval = new smaliTreeWalker.reference_type_descriptor_return(); |
| retval.start = input.LT(1); |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1158:3: ( ( CLASS_DESCRIPTOR | ARRAY_DESCRIPTOR ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1158:5: ( CLASS_DESCRIPTOR | ARRAY_DESCRIPTOR ) |
| { |
| if ( input.LA(1)==ARRAY_DESCRIPTOR||input.LA(1)==CLASS_DESCRIPTOR ) { |
| input.consume(); |
| state.errorRecovery=false; |
| } |
| else { |
| MismatchedSetException mse = new MismatchedSetException(null,input); |
| throw mse; |
| } |
| |
| retval.type = ((CommonTree)retval.start).getText(); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return retval; |
| } |
| // $ANTLR end "reference_type_descriptor" |
| |
| |
| |
| // $ANTLR start "type_descriptor" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1164:1: type_descriptor returns [String type] : ( VOID_TYPE | nonvoid_type_descriptor ); |
| public final String type_descriptor() throws RecognitionException { |
| String type = null; |
| |
| |
| TreeRuleReturnScope nonvoid_type_descriptor181 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1165:3: ( VOID_TYPE | nonvoid_type_descriptor ) |
| int alt37=2; |
| int LA37_0 = input.LA(1); |
| if ( (LA37_0==VOID_TYPE) ) { |
| alt37=1; |
| } |
| else if ( (LA37_0==ARRAY_DESCRIPTOR||LA37_0==CLASS_DESCRIPTOR||LA37_0==PRIMITIVE_TYPE) ) { |
| alt37=2; |
| } |
| |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 37, 0, input); |
| throw nvae; |
| } |
| |
| switch (alt37) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1165:5: VOID_TYPE |
| { |
| match(input,VOID_TYPE,FOLLOW_VOID_TYPE_in_type_descriptor3124); |
| type = "V"; |
| } |
| break; |
| case 2 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1166:5: nonvoid_type_descriptor |
| { |
| pushFollow(FOLLOW_nonvoid_type_descriptor_in_type_descriptor3132); |
| nonvoid_type_descriptor181=nonvoid_type_descriptor(); |
| state._fsp--; |
| |
| type = (nonvoid_type_descriptor181!=null?((smaliTreeWalker.nonvoid_type_descriptor_return)nonvoid_type_descriptor181).type:null); |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return type; |
| } |
| // $ANTLR end "type_descriptor" |
| |
| |
| |
| // $ANTLR start "short_integral_literal" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1169:1: short_integral_literal returns [short value] : ( long_literal | integer_literal | short_literal | char_literal | byte_literal ); |
| public final short short_integral_literal() throws RecognitionException { |
| short value = 0; |
| |
| |
| long long_literal182 =0; |
| int integer_literal183 =0; |
| short short_literal184 =0; |
| char char_literal185 =0; |
| byte byte_literal186 =0; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1170:3: ( long_literal | integer_literal | short_literal | char_literal | byte_literal ) |
| int alt38=5; |
| switch ( input.LA(1) ) { |
| case LONG_LITERAL: |
| { |
| alt38=1; |
| } |
| break; |
| case INTEGER_LITERAL: |
| { |
| alt38=2; |
| } |
| break; |
| case SHORT_LITERAL: |
| { |
| alt38=3; |
| } |
| break; |
| case CHAR_LITERAL: |
| { |
| alt38=4; |
| } |
| break; |
| case BYTE_LITERAL: |
| { |
| alt38=5; |
| } |
| break; |
| default: |
| NoViableAltException nvae = |
| new NoViableAltException("", 38, 0, input); |
| throw nvae; |
| } |
| switch (alt38) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1170:5: long_literal |
| { |
| pushFollow(FOLLOW_long_literal_in_short_integral_literal3150); |
| long_literal182=long_literal(); |
| state._fsp--; |
| |
| |
| LiteralTools.checkShort(long_literal182); |
| value = (short)long_literal182; |
| |
| } |
| break; |
| case 2 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1175:5: integer_literal |
| { |
| pushFollow(FOLLOW_integer_literal_in_short_integral_literal3162); |
| integer_literal183=integer_literal(); |
| state._fsp--; |
| |
| |
| LiteralTools.checkShort(integer_literal183); |
| value = (short)integer_literal183; |
| |
| } |
| break; |
| case 3 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1180:5: short_literal |
| { |
| pushFollow(FOLLOW_short_literal_in_short_integral_literal3174); |
| short_literal184=short_literal(); |
| state._fsp--; |
| |
| value = short_literal184; |
| } |
| break; |
| case 4 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1181:5: char_literal |
| { |
| pushFollow(FOLLOW_char_literal_in_short_integral_literal3182); |
| char_literal185=char_literal(); |
| state._fsp--; |
| |
| value = (short)char_literal185; |
| } |
| break; |
| case 5 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1182:5: byte_literal |
| { |
| pushFollow(FOLLOW_byte_literal_in_short_integral_literal3190); |
| byte_literal186=byte_literal(); |
| state._fsp--; |
| |
| value = byte_literal186; |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return value; |
| } |
| // $ANTLR end "short_integral_literal" |
| |
| |
| |
| // $ANTLR start "integral_literal" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1184:1: integral_literal returns [int value] : ( long_literal | integer_literal | short_literal | byte_literal ); |
| public final int integral_literal() throws RecognitionException { |
| int value = 0; |
| |
| |
| long long_literal187 =0; |
| int integer_literal188 =0; |
| short short_literal189 =0; |
| byte byte_literal190 =0; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1185:3: ( long_literal | integer_literal | short_literal | byte_literal ) |
| int alt39=4; |
| switch ( input.LA(1) ) { |
| case LONG_LITERAL: |
| { |
| alt39=1; |
| } |
| break; |
| case INTEGER_LITERAL: |
| { |
| alt39=2; |
| } |
| break; |
| case SHORT_LITERAL: |
| { |
| alt39=3; |
| } |
| break; |
| case BYTE_LITERAL: |
| { |
| alt39=4; |
| } |
| break; |
| default: |
| NoViableAltException nvae = |
| new NoViableAltException("", 39, 0, input); |
| throw nvae; |
| } |
| switch (alt39) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1185:5: long_literal |
| { |
| pushFollow(FOLLOW_long_literal_in_integral_literal3205); |
| long_literal187=long_literal(); |
| state._fsp--; |
| |
| |
| LiteralTools.checkInt(long_literal187); |
| value = (int)long_literal187; |
| |
| } |
| break; |
| case 2 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1190:5: integer_literal |
| { |
| pushFollow(FOLLOW_integer_literal_in_integral_literal3217); |
| integer_literal188=integer_literal(); |
| state._fsp--; |
| |
| value = integer_literal188; |
| } |
| break; |
| case 3 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1191:5: short_literal |
| { |
| pushFollow(FOLLOW_short_literal_in_integral_literal3225); |
| short_literal189=short_literal(); |
| state._fsp--; |
| |
| value = short_literal189; |
| } |
| break; |
| case 4 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1192:5: byte_literal |
| { |
| pushFollow(FOLLOW_byte_literal_in_integral_literal3233); |
| byte_literal190=byte_literal(); |
| state._fsp--; |
| |
| value = byte_literal190; |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return value; |
| } |
| // $ANTLR end "integral_literal" |
| |
| |
| |
| // $ANTLR start "integer_literal" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1195:1: integer_literal returns [int value] : INTEGER_LITERAL ; |
| public final int integer_literal() throws RecognitionException { |
| int value = 0; |
| |
| |
| CommonTree INTEGER_LITERAL191=null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1196:3: ( INTEGER_LITERAL ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1196:5: INTEGER_LITERAL |
| { |
| INTEGER_LITERAL191=(CommonTree)match(input,INTEGER_LITERAL,FOLLOW_INTEGER_LITERAL_in_integer_literal3249); |
| value = LiteralTools.parseInt((INTEGER_LITERAL191!=null?INTEGER_LITERAL191.getText():null)); |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return value; |
| } |
| // $ANTLR end "integer_literal" |
| |
| |
| |
| // $ANTLR start "long_literal" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1198:1: long_literal returns [long value] : LONG_LITERAL ; |
| public final long long_literal() throws RecognitionException { |
| long value = 0; |
| |
| |
| CommonTree LONG_LITERAL192=null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1199:3: ( LONG_LITERAL ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1199:5: LONG_LITERAL |
| { |
| LONG_LITERAL192=(CommonTree)match(input,LONG_LITERAL,FOLLOW_LONG_LITERAL_in_long_literal3264); |
| value = LiteralTools.parseLong((LONG_LITERAL192!=null?LONG_LITERAL192.getText():null)); |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return value; |
| } |
| // $ANTLR end "long_literal" |
| |
| |
| |
| // $ANTLR start "short_literal" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1201:1: short_literal returns [short value] : SHORT_LITERAL ; |
| public final short short_literal() throws RecognitionException { |
| short value = 0; |
| |
| |
| CommonTree SHORT_LITERAL193=null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1202:3: ( SHORT_LITERAL ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1202:5: SHORT_LITERAL |
| { |
| SHORT_LITERAL193=(CommonTree)match(input,SHORT_LITERAL,FOLLOW_SHORT_LITERAL_in_short_literal3279); |
| value = LiteralTools.parseShort((SHORT_LITERAL193!=null?SHORT_LITERAL193.getText():null)); |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return value; |
| } |
| // $ANTLR end "short_literal" |
| |
| |
| |
| // $ANTLR start "byte_literal" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1204:1: byte_literal returns [byte value] : BYTE_LITERAL ; |
| public final byte byte_literal() throws RecognitionException { |
| byte value = 0; |
| |
| |
| CommonTree BYTE_LITERAL194=null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1205:3: ( BYTE_LITERAL ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1205:5: BYTE_LITERAL |
| { |
| BYTE_LITERAL194=(CommonTree)match(input,BYTE_LITERAL,FOLLOW_BYTE_LITERAL_in_byte_literal3294); |
| value = LiteralTools.parseByte((BYTE_LITERAL194!=null?BYTE_LITERAL194.getText():null)); |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return value; |
| } |
| // $ANTLR end "byte_literal" |
| |
| |
| |
| // $ANTLR start "float_literal" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1207:1: float_literal returns [float value] : FLOAT_LITERAL ; |
| public final float float_literal() throws RecognitionException { |
| float value = 0.0f; |
| |
| |
| CommonTree FLOAT_LITERAL195=null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1208:3: ( FLOAT_LITERAL ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1208:5: FLOAT_LITERAL |
| { |
| FLOAT_LITERAL195=(CommonTree)match(input,FLOAT_LITERAL,FOLLOW_FLOAT_LITERAL_in_float_literal3309); |
| value = LiteralTools.parseFloat((FLOAT_LITERAL195!=null?FLOAT_LITERAL195.getText():null)); |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return value; |
| } |
| // $ANTLR end "float_literal" |
| |
| |
| |
| // $ANTLR start "double_literal" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1210:1: double_literal returns [double value] : DOUBLE_LITERAL ; |
| public final double double_literal() throws RecognitionException { |
| double value = 0.0; |
| |
| |
| CommonTree DOUBLE_LITERAL196=null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1211:3: ( DOUBLE_LITERAL ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1211:5: DOUBLE_LITERAL |
| { |
| DOUBLE_LITERAL196=(CommonTree)match(input,DOUBLE_LITERAL,FOLLOW_DOUBLE_LITERAL_in_double_literal3324); |
| value = LiteralTools.parseDouble((DOUBLE_LITERAL196!=null?DOUBLE_LITERAL196.getText():null)); |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return value; |
| } |
| // $ANTLR end "double_literal" |
| |
| |
| |
| // $ANTLR start "char_literal" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1213:1: char_literal returns [char value] : CHAR_LITERAL ; |
| public final char char_literal() throws RecognitionException { |
| char value = 0; |
| |
| |
| CommonTree CHAR_LITERAL197=null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1214:3: ( CHAR_LITERAL ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1214:5: CHAR_LITERAL |
| { |
| CHAR_LITERAL197=(CommonTree)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_char_literal3339); |
| value = (CHAR_LITERAL197!=null?CHAR_LITERAL197.getText():null).charAt(1); |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return value; |
| } |
| // $ANTLR end "char_literal" |
| |
| |
| |
| // $ANTLR start "string_literal" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1216:1: string_literal returns [String value] : STRING_LITERAL ; |
| public final String string_literal() throws RecognitionException { |
| String value = null; |
| |
| |
| CommonTree STRING_LITERAL198=null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1217:3: ( STRING_LITERAL ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1217:5: STRING_LITERAL |
| { |
| STRING_LITERAL198=(CommonTree)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_string_literal3354); |
| |
| value = (STRING_LITERAL198!=null?STRING_LITERAL198.getText():null); |
| value = value.substring(1,value.length()-1); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return value; |
| } |
| // $ANTLR end "string_literal" |
| |
| |
| |
| // $ANTLR start "bool_literal" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1223:1: bool_literal returns [boolean value] : BOOL_LITERAL ; |
| public final boolean bool_literal() throws RecognitionException { |
| boolean value = false; |
| |
| |
| CommonTree BOOL_LITERAL199=null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1224:3: ( BOOL_LITERAL ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1224:5: BOOL_LITERAL |
| { |
| BOOL_LITERAL199=(CommonTree)match(input,BOOL_LITERAL,FOLLOW_BOOL_LITERAL_in_bool_literal3373); |
| value = Boolean.parseBoolean((BOOL_LITERAL199!=null?BOOL_LITERAL199.getText():null)); |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return value; |
| } |
| // $ANTLR end "bool_literal" |
| |
| |
| |
| // $ANTLR start "array_literal" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1226:1: array_literal returns [List<EncodedValue> elements] : ^( I_ENCODED_ARRAY ( literal )* ) ; |
| public final List<EncodedValue> array_literal() throws RecognitionException { |
| List<EncodedValue> elements = null; |
| |
| |
| EncodedValue literal200 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1227:3: ( ^( I_ENCODED_ARRAY ( literal )* ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1227:5: ^( I_ENCODED_ARRAY ( literal )* ) |
| { |
| elements = Lists.newArrayList(); |
| match(input,I_ENCODED_ARRAY,FOLLOW_I_ENCODED_ARRAY_in_array_literal3395); |
| if ( input.LA(1)==Token.DOWN ) { |
| match(input, Token.DOWN, null); |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1228:23: ( literal )* |
| loop40: |
| while (true) { |
| int alt40=2; |
| int LA40_0 = input.LA(1); |
| if ( (LA40_0==ARRAY_DESCRIPTOR||(LA40_0 >= BOOL_LITERAL && LA40_0 <= BYTE_LITERAL)||(LA40_0 >= CHAR_LITERAL && LA40_0 <= CLASS_DESCRIPTOR)||LA40_0==DOUBLE_LITERAL||LA40_0==FLOAT_LITERAL||LA40_0==INTEGER_LITERAL||(LA40_0 >= I_ENCODED_ARRAY && LA40_0 <= I_ENCODED_METHOD)||LA40_0==I_SUBANNOTATION||LA40_0==LONG_LITERAL||LA40_0==NULL_LITERAL||LA40_0==PRIMITIVE_TYPE||LA40_0==SHORT_LITERAL||LA40_0==STRING_LITERAL||LA40_0==VOID_TYPE) ) { |
| alt40=1; |
| } |
| |
| switch (alt40) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1228:24: literal |
| { |
| pushFollow(FOLLOW_literal_in_array_literal3398); |
| literal200=literal(); |
| state._fsp--; |
| |
| elements.add(literal200); |
| } |
| break; |
| |
| default : |
| break loop40; |
| } |
| } |
| |
| match(input, Token.UP, null); |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return elements; |
| } |
| // $ANTLR end "array_literal" |
| |
| |
| |
| // $ANTLR start "annotations" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1230:1: annotations returns [Set<Annotation> annotations] : ^( I_ANNOTATIONS ( annotation )* ) ; |
| public final Set<Annotation> annotations() throws RecognitionException { |
| Set<Annotation> annotations = null; |
| |
| |
| Annotation annotation201 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1231:3: ( ^( I_ANNOTATIONS ( annotation )* ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1231:5: ^( I_ANNOTATIONS ( annotation )* ) |
| { |
| HashMap<String, Annotation> annotationMap = Maps.newHashMap(); |
| match(input,I_ANNOTATIONS,FOLLOW_I_ANNOTATIONS_in_annotations3423); |
| if ( input.LA(1)==Token.DOWN ) { |
| match(input, Token.DOWN, null); |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1232:21: ( annotation )* |
| loop41: |
| while (true) { |
| int alt41=2; |
| int LA41_0 = input.LA(1); |
| if ( (LA41_0==I_ANNOTATION) ) { |
| alt41=1; |
| } |
| |
| switch (alt41) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1232:22: annotation |
| { |
| pushFollow(FOLLOW_annotation_in_annotations3426); |
| annotation201=annotation(); |
| state._fsp--; |
| |
| |
| Annotation anno = annotation201; |
| Annotation old = annotationMap.put(anno.getType(), anno); |
| if (old != null) { |
| throw new SemanticException(input, "Multiple annotations of type %s", anno.getType()); |
| } |
| |
| } |
| break; |
| |
| default : |
| break loop41; |
| } |
| } |
| |
| match(input, Token.UP, null); |
| } |
| |
| |
| if (annotationMap.size() > 0) { |
| annotations = ImmutableSet.copyOf(annotationMap.values()); |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return annotations; |
| } |
| // $ANTLR end "annotations" |
| |
| |
| |
| // $ANTLR start "annotation" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1246:1: annotation returns [Annotation annotation] : ^( I_ANNOTATION ANNOTATION_VISIBILITY subannotation ) ; |
| public final Annotation annotation() throws RecognitionException { |
| Annotation annotation = null; |
| |
| |
| CommonTree ANNOTATION_VISIBILITY202=null; |
| TreeRuleReturnScope subannotation203 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1247:3: ( ^( I_ANNOTATION ANNOTATION_VISIBILITY subannotation ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1247:5: ^( I_ANNOTATION ANNOTATION_VISIBILITY subannotation ) |
| { |
| match(input,I_ANNOTATION,FOLLOW_I_ANNOTATION_in_annotation3455); |
| match(input, Token.DOWN, null); |
| ANNOTATION_VISIBILITY202=(CommonTree)match(input,ANNOTATION_VISIBILITY,FOLLOW_ANNOTATION_VISIBILITY_in_annotation3457); |
| pushFollow(FOLLOW_subannotation_in_annotation3459); |
| subannotation203=subannotation(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| int visibility = AnnotationVisibility.getVisibility((ANNOTATION_VISIBILITY202!=null?ANNOTATION_VISIBILITY202.getText():null)); |
| annotation = new ImmutableAnnotation(visibility, (subannotation203!=null?((smaliTreeWalker.subannotation_return)subannotation203).annotationType:null), (subannotation203!=null?((smaliTreeWalker.subannotation_return)subannotation203).elements:null)); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return annotation; |
| } |
| // $ANTLR end "annotation" |
| |
| |
| |
| // $ANTLR start "annotation_element" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1253:1: annotation_element returns [AnnotationElement element] : ^( I_ANNOTATION_ELEMENT SIMPLE_NAME literal ) ; |
| public final AnnotationElement annotation_element() throws RecognitionException { |
| AnnotationElement element = null; |
| |
| |
| CommonTree SIMPLE_NAME204=null; |
| EncodedValue literal205 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1254:3: ( ^( I_ANNOTATION_ELEMENT SIMPLE_NAME literal ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1254:5: ^( I_ANNOTATION_ELEMENT SIMPLE_NAME literal ) |
| { |
| match(input,I_ANNOTATION_ELEMENT,FOLLOW_I_ANNOTATION_ELEMENT_in_annotation_element3480); |
| match(input, Token.DOWN, null); |
| SIMPLE_NAME204=(CommonTree)match(input,SIMPLE_NAME,FOLLOW_SIMPLE_NAME_in_annotation_element3482); |
| pushFollow(FOLLOW_literal_in_annotation_element3484); |
| literal205=literal(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| element = new ImmutableAnnotationElement((SIMPLE_NAME204!=null?SIMPLE_NAME204.getText():null), literal205); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return element; |
| } |
| // $ANTLR end "annotation_element" |
| |
| |
| public static class subannotation_return extends TreeRuleReturnScope { |
| public String annotationType; |
| public List<AnnotationElement> elements; |
| }; |
| |
| |
| // $ANTLR start "subannotation" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1259:1: subannotation returns [String annotationType, List<AnnotationElement> elements] : ^( I_SUBANNOTATION CLASS_DESCRIPTOR ( annotation_element )* ) ; |
| public final smaliTreeWalker.subannotation_return subannotation() throws RecognitionException { |
| smaliTreeWalker.subannotation_return retval = new smaliTreeWalker.subannotation_return(); |
| retval.start = input.LT(1); |
| |
| CommonTree CLASS_DESCRIPTOR207=null; |
| AnnotationElement annotation_element206 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1260:3: ( ^( I_SUBANNOTATION CLASS_DESCRIPTOR ( annotation_element )* ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1260:5: ^( I_SUBANNOTATION CLASS_DESCRIPTOR ( annotation_element )* ) |
| { |
| ArrayList<AnnotationElement> elements = Lists.newArrayList(); |
| match(input,I_SUBANNOTATION,FOLLOW_I_SUBANNOTATION_in_subannotation3511); |
| match(input, Token.DOWN, null); |
| CLASS_DESCRIPTOR207=(CommonTree)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_subannotation3521); |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1263:9: ( annotation_element )* |
| loop42: |
| while (true) { |
| int alt42=2; |
| int LA42_0 = input.LA(1); |
| if ( (LA42_0==I_ANNOTATION_ELEMENT) ) { |
| alt42=1; |
| } |
| |
| switch (alt42) { |
| case 1 : |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1263:10: annotation_element |
| { |
| pushFollow(FOLLOW_annotation_element_in_subannotation3532); |
| annotation_element206=annotation_element(); |
| state._fsp--; |
| |
| |
| elements.add(annotation_element206); |
| |
| } |
| break; |
| |
| default : |
| break loop42; |
| } |
| } |
| |
| match(input, Token.UP, null); |
| |
| |
| retval.annotationType = (CLASS_DESCRIPTOR207!=null?CLASS_DESCRIPTOR207.getText():null); |
| retval.elements = elements; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return retval; |
| } |
| // $ANTLR end "subannotation" |
| |
| |
| |
| // $ANTLR start "field_literal" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1273:1: field_literal returns [FieldReference value] : ^( I_ENCODED_FIELD field_reference ) ; |
| public final FieldReference field_literal() throws RecognitionException { |
| FieldReference value = null; |
| |
| |
| ImmutableFieldReference field_reference208 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1274:3: ( ^( I_ENCODED_FIELD field_reference ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1274:5: ^( I_ENCODED_FIELD field_reference ) |
| { |
| match(input,I_ENCODED_FIELD,FOLLOW_I_ENCODED_FIELD_in_field_literal3571); |
| match(input, Token.DOWN, null); |
| pushFollow(FOLLOW_field_reference_in_field_literal3573); |
| field_reference208=field_reference(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| value = field_reference208; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return value; |
| } |
| // $ANTLR end "field_literal" |
| |
| |
| |
| // $ANTLR start "method_literal" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1279:1: method_literal returns [MethodReference value] : ^( I_ENCODED_METHOD method_reference ) ; |
| public final MethodReference method_literal() throws RecognitionException { |
| MethodReference value = null; |
| |
| |
| ImmutableMethodReference method_reference209 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1280:3: ( ^( I_ENCODED_METHOD method_reference ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1280:5: ^( I_ENCODED_METHOD method_reference ) |
| { |
| match(input,I_ENCODED_METHOD,FOLLOW_I_ENCODED_METHOD_in_method_literal3594); |
| match(input, Token.DOWN, null); |
| pushFollow(FOLLOW_method_reference_in_method_literal3596); |
| method_reference209=method_reference(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| value = method_reference209; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return value; |
| } |
| // $ANTLR end "method_literal" |
| |
| |
| |
| // $ANTLR start "enum_literal" |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1285:1: enum_literal returns [FieldReference value] : ^( I_ENCODED_ENUM field_reference ) ; |
| public final FieldReference enum_literal() throws RecognitionException { |
| FieldReference value = null; |
| |
| |
| ImmutableFieldReference field_reference210 =null; |
| |
| try { |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1286:3: ( ^( I_ENCODED_ENUM field_reference ) ) |
| // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliTreeWalker.g:1286:5: ^( I_ENCODED_ENUM field_reference ) |
| { |
| match(input,I_ENCODED_ENUM,FOLLOW_I_ENCODED_ENUM_in_enum_literal3617); |
| match(input, Token.DOWN, null); |
| pushFollow(FOLLOW_field_reference_in_enum_literal3619); |
| field_reference210=field_reference(); |
| state._fsp--; |
| |
| match(input, Token.UP, null); |
| |
| |
| value = field_reference210; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| // do for sure before leaving |
| } |
| return value; |
| } |
| // $ANTLR end "enum_literal" |
| |
| // Delegated rules |
| |
| |
| |
| public static final BitSet FOLLOW_I_CLASS_DEF_in_smali_file52 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_header_in_smali_file54 = new BitSet(new long[]{0x0000000000000000L,0x0004000000000000L}); |
| public static final BitSet FOLLOW_methods_in_smali_file56 = new BitSet(new long[]{0x0000000000000000L,0x0000020000000000L}); |
| public static final BitSet FOLLOW_fields_in_smali_file58 = new BitSet(new long[]{0x0000000000000000L,0x0000000004000000L}); |
| public static final BitSet FOLLOW_annotations_in_smali_file60 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_class_spec_in_header85 = new BitSet(new long[]{0x0000000000000000L,0x0000100000000000L,0x0000002000000001L}); |
| public static final BitSet FOLLOW_super_spec_in_header87 = new BitSet(new long[]{0x0000000000000000L,0x0000100000000000L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_implements_list_in_header90 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_source_spec_in_header92 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_class_spec110 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); |
| public static final BitSet FOLLOW_access_list_in_class_spec112 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_I_SUPER_in_super_spec130 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_super_spec132 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_IMPLEMENTS_in_implements_spec152 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_implements_spec154 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_implements_spec_in_implements_list184 = new BitSet(new long[]{0x0000000000000002L,0x0000100000000000L}); |
| public static final BitSet FOLLOW_I_SOURCE_in_source_spec213 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_string_literal_in_source_spec215 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_ACCESS_LIST_in_access_list248 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_ACCESS_SPEC_in_access_list266 = new BitSet(new long[]{0x0000000000000018L}); |
| public static final BitSet FOLLOW_I_FIELDS_in_fields308 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_field_in_fields317 = new BitSet(new long[]{0x0000000000000008L,0x0000010000000000L}); |
| public static final BitSet FOLLOW_I_METHODS_in_methods349 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_method_in_methods358 = new BitSet(new long[]{0x0000000000000008L,0x0002000000000000L}); |
| public static final BitSet FOLLOW_I_FIELD_in_field383 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_SIMPLE_NAME_in_field385 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); |
| public static final BitSet FOLLOW_access_list_in_field387 = new BitSet(new long[]{0x0000000000000000L,0x0000080000000000L}); |
| public static final BitSet FOLLOW_I_FIELD_TYPE_in_field390 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_nonvoid_type_descriptor_in_field392 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_field_initial_value_in_field395 = new BitSet(new long[]{0x0000000000000008L,0x0000000004000000L}); |
| public static final BitSet FOLLOW_annotations_in_field397 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_FIELD_INITIAL_VALUE_in_field_initial_value418 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_literal_in_field_initial_value420 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_integer_literal_in_literal442 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_long_literal_in_literal450 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_short_literal_in_literal458 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_byte_literal_in_literal466 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_float_literal_in_literal474 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_double_literal_in_literal482 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_char_literal_in_literal490 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_string_literal_in_literal498 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_bool_literal_in_literal506 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_NULL_LITERAL_in_literal514 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_type_descriptor_in_literal522 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_array_literal_in_literal530 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_subannotation_in_literal538 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_field_literal_in_literal546 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_method_literal_in_literal554 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_enum_literal_in_literal562 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_integer_literal_in_fixed_64bit_literal_number578 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_long_literal_in_fixed_64bit_literal_number586 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_short_literal_in_fixed_64bit_literal_number594 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_byte_literal_in_fixed_64bit_literal_number602 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_float_literal_in_fixed_64bit_literal_number610 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_double_literal_in_fixed_64bit_literal_number618 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_char_literal_in_fixed_64bit_literal_number626 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_bool_literal_in_fixed_64bit_literal_number634 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_integer_literal_in_fixed_64bit_literal649 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_long_literal_in_fixed_64bit_literal657 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_short_literal_in_fixed_64bit_literal665 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_byte_literal_in_fixed_64bit_literal673 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_float_literal_in_fixed_64bit_literal681 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_double_literal_in_fixed_64bit_literal689 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_char_literal_in_fixed_64bit_literal697 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_bool_literal_in_fixed_64bit_literal705 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_integer_literal_in_fixed_32bit_literal722 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_long_literal_in_fixed_32bit_literal730 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_short_literal_in_fixed_32bit_literal738 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_byte_literal_in_fixed_32bit_literal746 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_float_literal_in_fixed_32bit_literal754 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_char_literal_in_fixed_32bit_literal762 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_bool_literal_in_fixed_32bit_literal770 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_I_ARRAY_ELEMENTS_in_array_elements792 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_fixed_64bit_literal_number_in_array_elements801 = new BitSet(new long[]{0x0000004000404C08L,0x0000000000400000L,0x2000040000000000L}); |
| public static final BitSet FOLLOW_I_PACKED_SWITCH_ELEMENTS_in_packed_switch_elements837 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_label_ref_in_packed_switch_elements846 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000000L,0x4000000000000000L}); |
| public static final BitSet FOLLOW_I_SPARSE_SWITCH_ELEMENTS_in_sparse_switch_elements881 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_fixed_32bit_literal_in_sparse_switch_elements891 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x4000000000000000L}); |
| public static final BitSet FOLLOW_label_ref_in_sparse_switch_elements893 = new BitSet(new long[]{0x0000004000004C08L,0x0000000000400000L,0x2000040000000000L}); |
| public static final BitSet FOLLOW_I_METHOD_in_method945 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_method_name_and_prototype_in_method953 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); |
| public static final BitSet FOLLOW_access_list_in_method961 = new BitSet(new long[]{0x0000000000000000L,0x1021000000000000L}); |
| public static final BitSet FOLLOW_registers_directive_in_method988 = new BitSet(new long[]{0x0000000000000000L,0x0020000000000000L}); |
| public static final BitSet FOLLOW_ordered_method_items_in_method1045 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L}); |
| public static final BitSet FOLLOW_catches_in_method1053 = new BitSet(new long[]{0x0000000000000000L,0x0200000000000000L}); |
| public static final BitSet FOLLOW_parameters_in_method1061 = new BitSet(new long[]{0x0000000000000000L,0x0000000004000000L}); |
| public static final BitSet FOLLOW_annotations_in_method1070 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_METHOD_PROTOTYPE_in_method_prototype1094 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_I_METHOD_RETURN_TYPE_in_method_prototype1097 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_type_descriptor_in_method_prototype1099 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_method_type_list_in_method_prototype1102 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_SIMPLE_NAME_in_method_name_and_prototype1120 = new BitSet(new long[]{0x0000000000000000L,0x0008000000000000L}); |
| public static final BitSet FOLLOW_method_prototype_in_method_name_and_prototype1122 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_nonvoid_type_descriptor_in_method_type_list1156 = new BitSet(new long[]{0x0000000000008102L,0x0000000000000000L,0x0100000000000000L}); |
| public static final BitSet FOLLOW_reference_type_descriptor_in_method_reference1185 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x4000000000000000L}); |
| public static final BitSet FOLLOW_SIMPLE_NAME_in_method_reference1188 = new BitSet(new long[]{0x0000000000000000L,0x0008000000000000L}); |
| public static final BitSet FOLLOW_method_prototype_in_method_reference1190 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_reference_type_descriptor_in_field_reference1207 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x4000000000000000L}); |
| public static final BitSet FOLLOW_SIMPLE_NAME_in_field_reference1210 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0100000000000000L}); |
| public static final BitSet FOLLOW_nonvoid_type_descriptor_in_field_reference1212 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_I_REGISTERS_in_registers_directive1238 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_I_LOCALS_in_registers_directive1250 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_short_integral_literal_in_registers_directive1268 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_LABEL_in_label_def1288 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_SIMPLE_NAME_in_label_def1290 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_CATCHES_in_catches1316 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_catch_directive_in_catches1318 = new BitSet(new long[]{0x0000000000000008L,0x00000000C0000000L}); |
| public static final BitSet FOLLOW_catchall_directive_in_catches1321 = new BitSet(new long[]{0x0000000000000008L,0x0000000080000000L}); |
| public static final BitSet FOLLOW_I_CATCH_in_catch_directive1334 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_nonvoid_type_descriptor_in_catch_directive1336 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x4000000000000000L}); |
| public static final BitSet FOLLOW_label_ref_in_catch_directive1340 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x4000000000000000L}); |
| public static final BitSet FOLLOW_label_ref_in_catch_directive1344 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x4000000000000000L}); |
| public static final BitSet FOLLOW_label_ref_in_catch_directive1348 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_CATCHALL_in_catchall_directive1364 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_label_ref_in_catchall_directive1368 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x4000000000000000L}); |
| public static final BitSet FOLLOW_label_ref_in_catchall_directive1372 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x4000000000000000L}); |
| public static final BitSet FOLLOW_label_ref_in_catchall_directive1376 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_PARAMETERS_in_parameters1393 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_parameter_in_parameters1396 = new BitSet(new long[]{0x0000000000000008L,0x0100000000000000L}); |
| public static final BitSet FOLLOW_I_PARAMETER_in_parameter1412 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_REGISTER_in_parameter1414 = new BitSet(new long[]{0x0000000000000000L,0x0000000004000000L,0x0000000000000000L,0x0000000000000002L}); |
| public static final BitSet FOLLOW_string_literal_in_parameter1416 = new BitSet(new long[]{0x0000000000000000L,0x0000000004000000L}); |
| public static final BitSet FOLLOW_annotations_in_parameter1419 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_line_in_debug_directive1436 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_local_in_debug_directive1442 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_end_local_in_debug_directive1448 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_restart_local_in_debug_directive1454 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_prologue_in_debug_directive1460 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_epilogue_in_debug_directive1466 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_source_in_debug_directive1472 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_I_LINE_in_line1483 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_integral_literal_in_line1485 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_LOCAL_in_local1503 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_REGISTER_in_local1505 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000000L,0x0000400000000000L,0x0000000000000002L}); |
| public static final BitSet FOLLOW_NULL_LITERAL_in_local1509 = new BitSet(new long[]{0x0000000000008108L,0x0000000000000000L,0x0100000000000000L,0x0000000000000002L}); |
| public static final BitSet FOLLOW_string_literal_in_local1515 = new BitSet(new long[]{0x0000000000008108L,0x0000000000000000L,0x0100000000000000L,0x0000000000000002L}); |
| public static final BitSet FOLLOW_nonvoid_type_descriptor_in_local1518 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000000L,0x0000000000000000L,0x0000000000000002L}); |
| public static final BitSet FOLLOW_string_literal_in_local1523 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_END_LOCAL_in_end_local1544 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_REGISTER_in_end_local1546 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_RESTART_LOCAL_in_restart_local1564 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_REGISTER_in_restart_local1566 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_PROLOGUE_in_prologue1583 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_I_EPILOGUE_in_epilogue1599 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_I_SOURCE_in_source1616 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_string_literal_in_source1618 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_ORDERED_METHOD_ITEMS_in_ordered_method_items1637 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_label_def_in_ordered_method_items1640 = new BitSet(new long[]{0x0000000000000008L,0x8800E0C000000000L,0x0000000FFFFFFFFDL}); |
| public static final BitSet FOLLOW_instruction_in_ordered_method_items1644 = new BitSet(new long[]{0x0000000000000008L,0x8800E0C000000000L,0x0000000FFFFFFFFDL}); |
| public static final BitSet FOLLOW_debug_directive_in_ordered_method_items1648 = new BitSet(new long[]{0x0000000000000008L,0x8800E0C000000000L,0x0000000FFFFFFFFDL}); |
| public static final BitSet FOLLOW_SIMPLE_NAME_in_label_ref1664 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_I_REGISTER_LIST_in_register_list1689 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_REGISTER_in_register_list1698 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_I_REGISTER_RANGE_in_register_range1723 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_REGISTER_in_register_range1728 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_register_range1732 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_verification_error_reference1755 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_field_reference_in_verification_error_reference1765 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_method_reference_in_verification_error_reference1775 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_VERIFICATION_ERROR_TYPE_in_verification_error_type1792 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format10t_in_instruction1806 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format10x_in_instruction1812 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format11n_in_instruction1818 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format11x_in_instruction1824 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format12x_in_instruction1830 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format20bc_in_instruction1836 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format20t_in_instruction1842 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format21c_field_in_instruction1848 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format21c_string_in_instruction1854 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format21c_type_in_instruction1860 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format21ih_in_instruction1866 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format21lh_in_instruction1872 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format21s_in_instruction1878 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format21t_in_instruction1884 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format22b_in_instruction1890 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format22c_field_in_instruction1896 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format22c_type_in_instruction1902 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format22s_in_instruction1908 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format22t_in_instruction1914 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format22x_in_instruction1920 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format23x_in_instruction1926 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format30t_in_instruction1932 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format31c_in_instruction1938 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format31i_in_instruction1944 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format31t_in_instruction1950 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format32x_in_instruction1956 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format35c_method_in_instruction1962 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format35c_type_in_instruction1968 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format3rc_method_in_instruction1974 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format3rc_type_in_instruction1980 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_format51l_type_in_instruction1986 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_array_data_directive_in_instruction1992 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_packed_switch_directive_in_instruction1998 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_insn_sparse_switch_directive_in_instruction2004 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT10t_in_insn_format10t2028 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT10t_in_insn_format10t2030 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x4000000000000000L}); |
| public static final BitSet FOLLOW_label_ref_in_insn_format10t2032 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT10x_in_insn_format10x2055 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT10x_in_insn_format10x2057 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT11n_in_insn_format11n2080 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT11n_in_insn_format11n2082 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format11n2084 = new BitSet(new long[]{0x0000000000004800L,0x0000000000400000L,0x2000040000000000L}); |
| public static final BitSet FOLLOW_short_integral_literal_in_insn_format11n2086 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT11x_in_insn_format11x2109 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT11x_in_insn_format11x2111 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format11x2113 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT12x_in_insn_format12x2136 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT12x_in_insn_format12x2138 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format12x2142 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format12x2146 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT20bc_in_insn_format20bc2169 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT20bc_in_insn_format20bc2171 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000010L}); |
| public static final BitSet FOLLOW_verification_error_type_in_insn_format20bc2173 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x4000000000000000L}); |
| public static final BitSet FOLLOW_verification_error_reference_in_insn_format20bc2175 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT20t_in_insn_format20t2198 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT20t_in_insn_format20t2200 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x4000000000000000L}); |
| public static final BitSet FOLLOW_label_ref_in_insn_format20t2202 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT21c_FIELD_in_insn_format21c_field2225 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_set_in_insn_format21c_field2229 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format21c_field2237 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x4000000000000000L}); |
| public static final BitSet FOLLOW_field_reference_in_insn_format21c_field2239 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT21c_STRING_in_insn_format21c_string2262 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_STRING_in_insn_format21c_string2264 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format21c_string2266 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000002L}); |
| public static final BitSet FOLLOW_string_literal_in_insn_format21c_string2268 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT21c_TYPE_in_insn_format21c_type2291 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_TYPE_in_insn_format21c_type2293 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format21c_type2295 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0100000000000000L}); |
| public static final BitSet FOLLOW_nonvoid_type_descriptor_in_insn_format21c_type2297 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT21ih_in_insn_format21ih2320 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT21ih_in_insn_format21ih2322 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format21ih2324 = new BitSet(new long[]{0x0000004000004C00L,0x0000000000400000L,0x2000040000000000L}); |
| public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_format21ih2326 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT21lh_in_insn_format21lh2349 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT21lh_in_insn_format21lh2351 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format21lh2353 = new BitSet(new long[]{0x0000004000404C00L,0x0000000000400000L,0x2000040000000000L}); |
| public static final BitSet FOLLOW_fixed_64bit_literal_in_insn_format21lh2355 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT21s_in_insn_format21s2378 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT21s_in_insn_format21s2380 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format21s2382 = new BitSet(new long[]{0x0000000000004800L,0x0000000000400000L,0x2000040000000000L}); |
| public static final BitSet FOLLOW_short_integral_literal_in_insn_format21s2384 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT21t_in_insn_format21t2407 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT21t_in_insn_format21t2409 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format21t2411 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x4000000000000000L}); |
| public static final BitSet FOLLOW_label_ref_in_insn_format21t2413 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT22b_in_insn_format22b2436 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT22b_in_insn_format22b2438 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format22b2442 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format22b2446 = new BitSet(new long[]{0x0000000000004800L,0x0000000000400000L,0x2000040000000000L}); |
| public static final BitSet FOLLOW_short_integral_literal_in_insn_format22b2448 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT22c_FIELD_in_insn_format22c_field2471 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_set_in_insn_format22c_field2475 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format22c_field2485 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format22c_field2489 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x4000000000000000L}); |
| public static final BitSet FOLLOW_field_reference_in_insn_format22c_field2491 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT22c_TYPE_in_insn_format22c_type2514 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_TYPE_in_insn_format22c_type2516 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format22c_type2520 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format22c_type2524 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0100000000000000L}); |
| public static final BitSet FOLLOW_nonvoid_type_descriptor_in_insn_format22c_type2526 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT22s_in_insn_format22s2549 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT22s_in_insn_format22s2551 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format22s2555 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format22s2559 = new BitSet(new long[]{0x0000000000004800L,0x0000000000400000L,0x2000040000000000L}); |
| public static final BitSet FOLLOW_short_integral_literal_in_insn_format22s2561 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT22t_in_insn_format22t2584 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT22t_in_insn_format22t2586 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format22t2590 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format22t2594 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x4000000000000000L}); |
| public static final BitSet FOLLOW_label_ref_in_insn_format22t2596 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT22x_in_insn_format22x2619 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT22x_in_insn_format22x2621 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format22x2625 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format22x2629 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT23x_in_insn_format23x2652 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT23x_in_insn_format23x2654 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format23x2658 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format23x2662 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format23x2666 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT30t_in_insn_format30t2689 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT30t_in_insn_format30t2691 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x4000000000000000L}); |
| public static final BitSet FOLLOW_label_ref_in_insn_format30t2693 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT31c_in_insn_format31c2716 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT31c_in_insn_format31c2718 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format31c2720 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000002L}); |
| public static final BitSet FOLLOW_string_literal_in_insn_format31c2722 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT31i_in_insn_format31i2745 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT31i_in_insn_format31i2747 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format31i2749 = new BitSet(new long[]{0x0000004000004C00L,0x0000000000400000L,0x2000040000000000L}); |
| public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_format31i2751 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT31t_in_insn_format31t2774 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT31t_in_insn_format31t2776 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format31t2778 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x4000000000000000L}); |
| public static final BitSet FOLLOW_label_ref_in_insn_format31t2780 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT32x_in_insn_format32x2803 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT32x_in_insn_format32x2805 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format32x2809 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format32x2813 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT35c_METHOD_in_insn_format35c_method2836 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_METHOD_in_insn_format35c_method2838 = new BitSet(new long[]{0x0000000000000000L,0x2000000000000000L}); |
| public static final BitSet FOLLOW_register_list_in_insn_format35c_method2840 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x4000000000000000L}); |
| public static final BitSet FOLLOW_method_reference_in_insn_format35c_method2842 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT35c_TYPE_in_insn_format35c_type2865 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_TYPE_in_insn_format35c_type2867 = new BitSet(new long[]{0x0000000000000000L,0x2000000000000000L}); |
| public static final BitSet FOLLOW_register_list_in_insn_format35c_type2869 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0100000000000000L}); |
| public static final BitSet FOLLOW_nonvoid_type_descriptor_in_insn_format35c_type2871 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT3rc_METHOD_in_insn_format3rc_method2894 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rc_METHOD_in_insn_format3rc_method2896 = new BitSet(new long[]{0x0000000000000000L,0x4000000000000000L}); |
| public static final BitSet FOLLOW_register_range_in_insn_format3rc_method2898 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x4000000000000000L}); |
| public static final BitSet FOLLOW_method_reference_in_insn_format3rc_method2900 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT3rc_TYPE_in_insn_format3rc_type2923 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rc_TYPE_in_insn_format3rc_type2925 = new BitSet(new long[]{0x0000000000000000L,0x4000000000000000L}); |
| public static final BitSet FOLLOW_register_range_in_insn_format3rc_type2927 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0100000000000000L}); |
| public static final BitSet FOLLOW_nonvoid_type_descriptor_in_insn_format3rc_type2929 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_FORMAT51l_in_insn_format51l_type2952 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_INSTRUCTION_FORMAT51l_in_insn_format51l_type2954 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); |
| public static final BitSet FOLLOW_REGISTER_in_insn_format51l_type2956 = new BitSet(new long[]{0x0000004000404C00L,0x0000000000400000L,0x2000040000000000L}); |
| public static final BitSet FOLLOW_fixed_64bit_literal_in_insn_format51l_type2958 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_ARRAY_DATA_in_insn_array_data_directive2981 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_I_ARRAY_ELEMENT_SIZE_in_insn_array_data_directive2984 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_short_integral_literal_in_insn_array_data_directive2986 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_array_elements_in_insn_array_data_directive2989 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_PACKED_SWITCH_in_insn_packed_switch_directive3011 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_I_PACKED_SWITCH_START_KEY_in_insn_packed_switch_directive3014 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_packed_switch_directive3016 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_packed_switch_elements_in_insn_packed_switch_directive3019 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_STATEMENT_SPARSE_SWITCH_in_insn_sparse_switch_directive3043 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_sparse_switch_elements_in_insn_sparse_switch_directive3045 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_set_in_nonvoid_type_descriptor3066 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_set_in_reference_type_descriptor3098 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_VOID_TYPE_in_type_descriptor3124 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_nonvoid_type_descriptor_in_type_descriptor3132 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_long_literal_in_short_integral_literal3150 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_integer_literal_in_short_integral_literal3162 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_short_literal_in_short_integral_literal3174 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_char_literal_in_short_integral_literal3182 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_byte_literal_in_short_integral_literal3190 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_long_literal_in_integral_literal3205 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_integer_literal_in_integral_literal3217 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_short_literal_in_integral_literal3225 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_byte_literal_in_integral_literal3233 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_INTEGER_LITERAL_in_integer_literal3249 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_LONG_LITERAL_in_long_literal3264 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_SHORT_LITERAL_in_short_literal3279 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_BYTE_LITERAL_in_byte_literal3294 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_FLOAT_LITERAL_in_float_literal3309 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_DOUBLE_LITERAL_in_double_literal3324 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_CHAR_LITERAL_in_char_literal3339 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_STRING_LITERAL_in_string_literal3354 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_BOOL_LITERAL_in_bool_literal3373 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_I_ENCODED_ARRAY_in_array_literal3395 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_literal_in_array_literal3398 = new BitSet(new long[]{0x000000400040CD08L,0x0000003C00400000L,0x2100441000000000L,0x0000000000000022L}); |
| public static final BitSet FOLLOW_I_ANNOTATIONS_in_annotations3423 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_annotation_in_annotations3426 = new BitSet(new long[]{0x0000000000000008L,0x0000000002000000L}); |
| public static final BitSet FOLLOW_I_ANNOTATION_in_annotation3455 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_ANNOTATION_VISIBILITY_in_annotation3457 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000001000000000L}); |
| public static final BitSet FOLLOW_subannotation_in_annotation3459 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_ANNOTATION_ELEMENT_in_annotation_element3480 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_SIMPLE_NAME_in_annotation_element3482 = new BitSet(new long[]{0x000000400040CD00L,0x0000003C00400000L,0x2100441000000000L,0x0000000000000022L}); |
| public static final BitSet FOLLOW_literal_in_annotation_element3484 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_SUBANNOTATION_in_subannotation3511 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_subannotation3521 = new BitSet(new long[]{0x0000000000000008L,0x0000000008000000L}); |
| public static final BitSet FOLLOW_annotation_element_in_subannotation3532 = new BitSet(new long[]{0x0000000000000008L,0x0000000008000000L}); |
| public static final BitSet FOLLOW_I_ENCODED_FIELD_in_field_literal3571 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_field_reference_in_field_literal3573 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_ENCODED_METHOD_in_method_literal3594 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_method_reference_in_method_literal3596 = new BitSet(new long[]{0x0000000000000008L}); |
| public static final BitSet FOLLOW_I_ENCODED_ENUM_in_enum_literal3617 = new BitSet(new long[]{0x0000000000000004L}); |
| public static final BitSet FOLLOW_field_reference_in_enum_literal3619 = new BitSet(new long[]{0x0000000000000008L}); |
| } |