1 // $ANTLR 3.5.2 smaliTreeWalker.g 2019-04-05 11:21:30 2 3 package org.jf.smali; 4 5 import com.google.common.collect.ImmutableSet; 6 import com.google.common.collect.Iterables; 7 import com.google.common.collect.Lists; 8 import com.google.common.collect.Maps; 9 import org.antlr.runtime.BitSet; 10 import org.antlr.runtime.*; 11 import org.antlr.runtime.tree.CommonTree; 12 import org.antlr.runtime.tree.TreeNodeStream; 13 import org.antlr.runtime.tree.TreeParser; 14 import org.antlr.runtime.tree.TreeRuleReturnScope; 15 import org.jf.dexlib2.*; 16 import org.jf.dexlib2.builder.Label; 17 import org.jf.dexlib2.builder.MethodImplementationBuilder; 18 import org.jf.dexlib2.builder.SwitchLabelElement; 19 import org.jf.dexlib2.builder.instruction.*; 20 import org.jf.dexlib2.iface.Annotation; 21 import org.jf.dexlib2.iface.AnnotationElement; 22 import org.jf.dexlib2.iface.ClassDef; 23 import org.jf.dexlib2.iface.MethodImplementation; 24 import org.jf.dexlib2.iface.reference.FieldReference; 25 import org.jf.dexlib2.iface.reference.MethodReference; 26 import org.jf.dexlib2.iface.value.EncodedValue; 27 import org.jf.dexlib2.immutable.ImmutableAnnotation; 28 import org.jf.dexlib2.immutable.ImmutableAnnotationElement; 29 import org.jf.dexlib2.immutable.reference.ImmutableCallSiteReference; 30 import org.jf.dexlib2.immutable.reference.ImmutableFieldReference; 31 import org.jf.dexlib2.immutable.reference.ImmutableMethodHandleReference; 32 import org.jf.dexlib2.immutable.reference.ImmutableMethodReference; 33 import org.jf.dexlib2.immutable.reference.ImmutableMethodProtoReference; 34 import org.jf.dexlib2.immutable.reference.ImmutableReference; 35 import org.jf.dexlib2.immutable.reference.ImmutableTypeReference; 36 import org.jf.dexlib2.immutable.value.*; 37 import org.jf.dexlib2.util.MethodUtil; 38 import org.jf.dexlib2.writer.InstructionFactory; 39 import org.jf.dexlib2.writer.builder.*; 40 import org.jf.util.LinearSearch; 41 42 import java.util.*; 43 44 45 import org.antlr.runtime.*; 46 import org.antlr.runtime.tree.*; 47 import java.util.Stack; 48 import java.util.List; 49 import java.util.ArrayList; 50 51 @SuppressWarnings("all") 52 public class smaliTreeWalker extends TreeParser { 53 public static final String[] tokenNames = new String[] { 54 "<invalid>", "<EOR>", "<DOWN>", "<UP>", "ACCESS_SPEC", "ANNOTATION_DIRECTIVE", 55 "ANNOTATION_VISIBILITY", "ARRAY_DATA_DIRECTIVE", "ARRAY_TYPE_PREFIX", 56 "ARROW", "AT", "BOOL_LITERAL", "BYTE_LITERAL", "CATCHALL_DIRECTIVE", "CATCH_DIRECTIVE", 57 "CHAR_LITERAL", "CLASS_DESCRIPTOR", "CLASS_DIRECTIVE", "CLOSE_BRACE", 58 "CLOSE_PAREN", "COLON", "COMMA", "DOTDOT", "DOUBLE_LITERAL", "DOUBLE_LITERAL_OR_ID", 59 "END_ANNOTATION_DIRECTIVE", "END_ARRAY_DATA_DIRECTIVE", "END_FIELD_DIRECTIVE", 60 "END_LOCAL_DIRECTIVE", "END_METHOD_DIRECTIVE", "END_PACKED_SWITCH_DIRECTIVE", 61 "END_PARAMETER_DIRECTIVE", "END_SPARSE_SWITCH_DIRECTIVE", "END_SUBANNOTATION_DIRECTIVE", 62 "ENUM_DIRECTIVE", "EPILOGUE_DIRECTIVE", "EQUAL", "FIELD_DIRECTIVE", "FIELD_OFFSET", 63 "FLOAT_LITERAL", "FLOAT_LITERAL_OR_ID", "IMPLEMENTS_DIRECTIVE", "INLINE_INDEX", 64 "INSTRUCTION_FORMAT10t", "INSTRUCTION_FORMAT10x", "INSTRUCTION_FORMAT10x_ODEX", 65 "INSTRUCTION_FORMAT11n", "INSTRUCTION_FORMAT11x", "INSTRUCTION_FORMAT12x", 66 "INSTRUCTION_FORMAT12x_OR_ID", "INSTRUCTION_FORMAT20bc", "INSTRUCTION_FORMAT20t", 67 "INSTRUCTION_FORMAT21c_FIELD", "INSTRUCTION_FORMAT21c_FIELD_ODEX", "INSTRUCTION_FORMAT21c_METHOD_HANDLE", 68 "INSTRUCTION_FORMAT21c_METHOD_TYPE", "INSTRUCTION_FORMAT21c_STRING", "INSTRUCTION_FORMAT21c_TYPE", 69 "INSTRUCTION_FORMAT21ih", "INSTRUCTION_FORMAT21lh", "INSTRUCTION_FORMAT21s", 70 "INSTRUCTION_FORMAT21t", "INSTRUCTION_FORMAT22b", "INSTRUCTION_FORMAT22c_FIELD", 71 "INSTRUCTION_FORMAT22c_FIELD_ODEX", "INSTRUCTION_FORMAT22c_TYPE", "INSTRUCTION_FORMAT22cs_FIELD", 72 "INSTRUCTION_FORMAT22s", "INSTRUCTION_FORMAT22s_OR_ID", "INSTRUCTION_FORMAT22t", 73 "INSTRUCTION_FORMAT22x", "INSTRUCTION_FORMAT23x", "INSTRUCTION_FORMAT30t", 74 "INSTRUCTION_FORMAT31c", "INSTRUCTION_FORMAT31i", "INSTRUCTION_FORMAT31i_OR_ID", 75 "INSTRUCTION_FORMAT31t", "INSTRUCTION_FORMAT32x", "INSTRUCTION_FORMAT35c_CALL_SITE", 76 "INSTRUCTION_FORMAT35c_METHOD", "INSTRUCTION_FORMAT35c_METHOD_ODEX", "INSTRUCTION_FORMAT35c_METHOD_OR_METHOD_HANDLE_TYPE", 77 "INSTRUCTION_FORMAT35c_TYPE", "INSTRUCTION_FORMAT35mi_METHOD", "INSTRUCTION_FORMAT35ms_METHOD", 78 "INSTRUCTION_FORMAT3rc_CALL_SITE", "INSTRUCTION_FORMAT3rc_METHOD", "INSTRUCTION_FORMAT3rc_METHOD_ODEX", 79 "INSTRUCTION_FORMAT3rc_TYPE", "INSTRUCTION_FORMAT3rmi_METHOD", "INSTRUCTION_FORMAT3rms_METHOD", 80 "INSTRUCTION_FORMAT45cc_METHOD", "INSTRUCTION_FORMAT4rcc_METHOD", "INSTRUCTION_FORMAT51l", 81 "INTEGER_LITERAL", "INVALID_TOKEN", "I_ACCESS_LIST", "I_ANNOTATION", "I_ANNOTATIONS", 82 "I_ANNOTATION_ELEMENT", "I_ARRAY_ELEMENTS", "I_ARRAY_ELEMENT_SIZE", "I_CALL_SITE_EXTRA_ARGUMENTS", 83 "I_CALL_SITE_REFERENCE", "I_CATCH", "I_CATCHALL", "I_CATCHES", "I_CLASS_DEF", 84 "I_ENCODED_ARRAY", "I_ENCODED_ENUM", "I_ENCODED_FIELD", "I_ENCODED_METHOD", 85 "I_ENCODED_METHOD_HANDLE", "I_END_LOCAL", "I_EPILOGUE", "I_FIELD", "I_FIELDS", 86 "I_FIELD_INITIAL_VALUE", "I_FIELD_TYPE", "I_IMPLEMENTS", "I_LABEL", "I_LINE", 87 "I_LOCAL", "I_LOCALS", "I_METHOD", "I_METHODS", "I_METHOD_PROTOTYPE", 88 "I_METHOD_RETURN_TYPE", "I_ORDERED_METHOD_ITEMS", "I_PACKED_SWITCH_ELEMENTS", 89 "I_PACKED_SWITCH_START_KEY", "I_PARAMETER", "I_PARAMETERS", "I_PARAMETER_NOT_SPECIFIED", 90 "I_PROLOGUE", "I_REGISTERS", "I_REGISTER_LIST", "I_REGISTER_RANGE", "I_RESTART_LOCAL", 91 "I_SOURCE", "I_SPARSE_SWITCH_ELEMENTS", "I_STATEMENT_ARRAY_DATA", "I_STATEMENT_FORMAT10t", 92 "I_STATEMENT_FORMAT10x", "I_STATEMENT_FORMAT11n", "I_STATEMENT_FORMAT11x", 93 "I_STATEMENT_FORMAT12x", "I_STATEMENT_FORMAT20bc", "I_STATEMENT_FORMAT20t", 94 "I_STATEMENT_FORMAT21c_FIELD", "I_STATEMENT_FORMAT21c_METHOD_HANDLE", 95 "I_STATEMENT_FORMAT21c_METHOD_TYPE", "I_STATEMENT_FORMAT21c_STRING", "I_STATEMENT_FORMAT21c_TYPE", 96 "I_STATEMENT_FORMAT21ih", "I_STATEMENT_FORMAT21lh", "I_STATEMENT_FORMAT21s", 97 "I_STATEMENT_FORMAT21t", "I_STATEMENT_FORMAT22b", "I_STATEMENT_FORMAT22c_FIELD", 98 "I_STATEMENT_FORMAT22c_TYPE", "I_STATEMENT_FORMAT22s", "I_STATEMENT_FORMAT22t", 99 "I_STATEMENT_FORMAT22x", "I_STATEMENT_FORMAT23x", "I_STATEMENT_FORMAT30t", 100 "I_STATEMENT_FORMAT31c", "I_STATEMENT_FORMAT31i", "I_STATEMENT_FORMAT31t", 101 "I_STATEMENT_FORMAT32x", "I_STATEMENT_FORMAT35c_CALL_SITE", "I_STATEMENT_FORMAT35c_METHOD", 102 "I_STATEMENT_FORMAT35c_TYPE", "I_STATEMENT_FORMAT3rc_CALL_SITE", "I_STATEMENT_FORMAT3rc_METHOD", 103 "I_STATEMENT_FORMAT3rc_TYPE", "I_STATEMENT_FORMAT45cc_METHOD", "I_STATEMENT_FORMAT4rcc_METHOD", 104 "I_STATEMENT_FORMAT51l", "I_STATEMENT_PACKED_SWITCH", "I_STATEMENT_SPARSE_SWITCH", 105 "I_SUBANNOTATION", "I_SUPER", "LINE_COMMENT", "LINE_DIRECTIVE", "LOCALS_DIRECTIVE", 106 "LOCAL_DIRECTIVE", "LONG_LITERAL", "MEMBER_NAME", "METHOD_DIRECTIVE", 107 "METHOD_HANDLE_TYPE_FIELD", "METHOD_HANDLE_TYPE_METHOD", "NEGATIVE_INTEGER_LITERAL", 108 "NULL_LITERAL", "OPEN_BRACE", "OPEN_PAREN", "PACKED_SWITCH_DIRECTIVE", 109 "PARAMETER_DIRECTIVE", "PARAM_LIST_OR_ID_PRIMITIVE_TYPE", "POSITIVE_INTEGER_LITERAL", 110 "PRIMITIVE_TYPE", "PROLOGUE_DIRECTIVE", "REGISTER", "REGISTERS_DIRECTIVE", 111 "RESTART_LOCAL_DIRECTIVE", "SHORT_LITERAL", "SIMPLE_NAME", "SOURCE_DIRECTIVE", 112 "SPARSE_SWITCH_DIRECTIVE", "STRING_LITERAL", "SUBANNOTATION_DIRECTIVE", 113 "SUPER_DIRECTIVE", "VERIFICATION_ERROR_TYPE", "VOID_TYPE", "VTABLE_INDEX", 114 "WHITE_SPACE" 115 }; 116 public static final int EOF=-1; 117 public static final int ACCESS_SPEC=4; 118 public static final int ANNOTATION_DIRECTIVE=5; 119 public static final int ANNOTATION_VISIBILITY=6; 120 public static final int ARRAY_DATA_DIRECTIVE=7; 121 public static final int ARRAY_TYPE_PREFIX=8; 122 public static final int ARROW=9; 123 public static final int AT=10; 124 public static final int BOOL_LITERAL=11; 125 public static final int BYTE_LITERAL=12; 126 public static final int CATCHALL_DIRECTIVE=13; 127 public static final int CATCH_DIRECTIVE=14; 128 public static final int CHAR_LITERAL=15; 129 public static final int CLASS_DESCRIPTOR=16; 130 public static final int CLASS_DIRECTIVE=17; 131 public static final int CLOSE_BRACE=18; 132 public static final int CLOSE_PAREN=19; 133 public static final int COLON=20; 134 public static final int COMMA=21; 135 public static final int DOTDOT=22; 136 public static final int DOUBLE_LITERAL=23; 137 public static final int DOUBLE_LITERAL_OR_ID=24; 138 public static final int END_ANNOTATION_DIRECTIVE=25; 139 public static final int END_ARRAY_DATA_DIRECTIVE=26; 140 public static final int END_FIELD_DIRECTIVE=27; 141 public static final int END_LOCAL_DIRECTIVE=28; 142 public static final int END_METHOD_DIRECTIVE=29; 143 public static final int END_PACKED_SWITCH_DIRECTIVE=30; 144 public static final int END_PARAMETER_DIRECTIVE=31; 145 public static final int END_SPARSE_SWITCH_DIRECTIVE=32; 146 public static final int END_SUBANNOTATION_DIRECTIVE=33; 147 public static final int ENUM_DIRECTIVE=34; 148 public static final int EPILOGUE_DIRECTIVE=35; 149 public static final int EQUAL=36; 150 public static final int FIELD_DIRECTIVE=37; 151 public static final int FIELD_OFFSET=38; 152 public static final int FLOAT_LITERAL=39; 153 public static final int FLOAT_LITERAL_OR_ID=40; 154 public static final int IMPLEMENTS_DIRECTIVE=41; 155 public static final int INLINE_INDEX=42; 156 public static final int INSTRUCTION_FORMAT10t=43; 157 public static final int INSTRUCTION_FORMAT10x=44; 158 public static final int INSTRUCTION_FORMAT10x_ODEX=45; 159 public static final int INSTRUCTION_FORMAT11n=46; 160 public static final int INSTRUCTION_FORMAT11x=47; 161 public static final int INSTRUCTION_FORMAT12x=48; 162 public static final int INSTRUCTION_FORMAT12x_OR_ID=49; 163 public static final int INSTRUCTION_FORMAT20bc=50; 164 public static final int INSTRUCTION_FORMAT20t=51; 165 public static final int INSTRUCTION_FORMAT21c_FIELD=52; 166 public static final int INSTRUCTION_FORMAT21c_FIELD_ODEX=53; 167 public static final int INSTRUCTION_FORMAT21c_METHOD_HANDLE=54; 168 public static final int INSTRUCTION_FORMAT21c_METHOD_TYPE=55; 169 public static final int INSTRUCTION_FORMAT21c_STRING=56; 170 public static final int INSTRUCTION_FORMAT21c_TYPE=57; 171 public static final int INSTRUCTION_FORMAT21ih=58; 172 public static final int INSTRUCTION_FORMAT21lh=59; 173 public static final int INSTRUCTION_FORMAT21s=60; 174 public static final int INSTRUCTION_FORMAT21t=61; 175 public static final int INSTRUCTION_FORMAT22b=62; 176 public static final int INSTRUCTION_FORMAT22c_FIELD=63; 177 public static final int INSTRUCTION_FORMAT22c_FIELD_ODEX=64; 178 public static final int INSTRUCTION_FORMAT22c_TYPE=65; 179 public static final int INSTRUCTION_FORMAT22cs_FIELD=66; 180 public static final int INSTRUCTION_FORMAT22s=67; 181 public static final int INSTRUCTION_FORMAT22s_OR_ID=68; 182 public static final int INSTRUCTION_FORMAT22t=69; 183 public static final int INSTRUCTION_FORMAT22x=70; 184 public static final int INSTRUCTION_FORMAT23x=71; 185 public static final int INSTRUCTION_FORMAT30t=72; 186 public static final int INSTRUCTION_FORMAT31c=73; 187 public static final int INSTRUCTION_FORMAT31i=74; 188 public static final int INSTRUCTION_FORMAT31i_OR_ID=75; 189 public static final int INSTRUCTION_FORMAT31t=76; 190 public static final int INSTRUCTION_FORMAT32x=77; 191 public static final int INSTRUCTION_FORMAT35c_CALL_SITE=78; 192 public static final int INSTRUCTION_FORMAT35c_METHOD=79; 193 public static final int INSTRUCTION_FORMAT35c_METHOD_ODEX=80; 194 public static final int INSTRUCTION_FORMAT35c_METHOD_OR_METHOD_HANDLE_TYPE=81; 195 public static final int INSTRUCTION_FORMAT35c_TYPE=82; 196 public static final int INSTRUCTION_FORMAT35mi_METHOD=83; 197 public static final int INSTRUCTION_FORMAT35ms_METHOD=84; 198 public static final int INSTRUCTION_FORMAT3rc_CALL_SITE=85; 199 public static final int INSTRUCTION_FORMAT3rc_METHOD=86; 200 public static final int INSTRUCTION_FORMAT3rc_METHOD_ODEX=87; 201 public static final int INSTRUCTION_FORMAT3rc_TYPE=88; 202 public static final int INSTRUCTION_FORMAT3rmi_METHOD=89; 203 public static final int INSTRUCTION_FORMAT3rms_METHOD=90; 204 public static final int INSTRUCTION_FORMAT45cc_METHOD=91; 205 public static final int INSTRUCTION_FORMAT4rcc_METHOD=92; 206 public static final int INSTRUCTION_FORMAT51l=93; 207 public static final int INTEGER_LITERAL=94; 208 public static final int INVALID_TOKEN=95; 209 public static final int I_ACCESS_LIST=96; 210 public static final int I_ANNOTATION=97; 211 public static final int I_ANNOTATIONS=98; 212 public static final int I_ANNOTATION_ELEMENT=99; 213 public static final int I_ARRAY_ELEMENTS=100; 214 public static final int I_ARRAY_ELEMENT_SIZE=101; 215 public static final int I_CALL_SITE_EXTRA_ARGUMENTS=102; 216 public static final int I_CALL_SITE_REFERENCE=103; 217 public static final int I_CATCH=104; 218 public static final int I_CATCHALL=105; 219 public static final int I_CATCHES=106; 220 public static final int I_CLASS_DEF=107; 221 public static final int I_ENCODED_ARRAY=108; 222 public static final int I_ENCODED_ENUM=109; 223 public static final int I_ENCODED_FIELD=110; 224 public static final int I_ENCODED_METHOD=111; 225 public static final int I_ENCODED_METHOD_HANDLE=112; 226 public static final int I_END_LOCAL=113; 227 public static final int I_EPILOGUE=114; 228 public static final int I_FIELD=115; 229 public static final int I_FIELDS=116; 230 public static final int I_FIELD_INITIAL_VALUE=117; 231 public static final int I_FIELD_TYPE=118; 232 public static final int I_IMPLEMENTS=119; 233 public static final int I_LABEL=120; 234 public static final int I_LINE=121; 235 public static final int I_LOCAL=122; 236 public static final int I_LOCALS=123; 237 public static final int I_METHOD=124; 238 public static final int I_METHODS=125; 239 public static final int I_METHOD_PROTOTYPE=126; 240 public static final int I_METHOD_RETURN_TYPE=127; 241 public static final int I_ORDERED_METHOD_ITEMS=128; 242 public static final int I_PACKED_SWITCH_ELEMENTS=129; 243 public static final int I_PACKED_SWITCH_START_KEY=130; 244 public static final int I_PARAMETER=131; 245 public static final int I_PARAMETERS=132; 246 public static final int I_PARAMETER_NOT_SPECIFIED=133; 247 public static final int I_PROLOGUE=134; 248 public static final int I_REGISTERS=135; 249 public static final int I_REGISTER_LIST=136; 250 public static final int I_REGISTER_RANGE=137; 251 public static final int I_RESTART_LOCAL=138; 252 public static final int I_SOURCE=139; 253 public static final int I_SPARSE_SWITCH_ELEMENTS=140; 254 public static final int I_STATEMENT_ARRAY_DATA=141; 255 public static final int I_STATEMENT_FORMAT10t=142; 256 public static final int I_STATEMENT_FORMAT10x=143; 257 public static final int I_STATEMENT_FORMAT11n=144; 258 public static final int I_STATEMENT_FORMAT11x=145; 259 public static final int I_STATEMENT_FORMAT12x=146; 260 public static final int I_STATEMENT_FORMAT20bc=147; 261 public static final int I_STATEMENT_FORMAT20t=148; 262 public static final int I_STATEMENT_FORMAT21c_FIELD=149; 263 public static final int I_STATEMENT_FORMAT21c_METHOD_HANDLE=150; 264 public static final int I_STATEMENT_FORMAT21c_METHOD_TYPE=151; 265 public static final int I_STATEMENT_FORMAT21c_STRING=152; 266 public static final int I_STATEMENT_FORMAT21c_TYPE=153; 267 public static final int I_STATEMENT_FORMAT21ih=154; 268 public static final int I_STATEMENT_FORMAT21lh=155; 269 public static final int I_STATEMENT_FORMAT21s=156; 270 public static final int I_STATEMENT_FORMAT21t=157; 271 public static final int I_STATEMENT_FORMAT22b=158; 272 public static final int I_STATEMENT_FORMAT22c_FIELD=159; 273 public static final int I_STATEMENT_FORMAT22c_TYPE=160; 274 public static final int I_STATEMENT_FORMAT22s=161; 275 public static final int I_STATEMENT_FORMAT22t=162; 276 public static final int I_STATEMENT_FORMAT22x=163; 277 public static final int I_STATEMENT_FORMAT23x=164; 278 public static final int I_STATEMENT_FORMAT30t=165; 279 public static final int I_STATEMENT_FORMAT31c=166; 280 public static final int I_STATEMENT_FORMAT31i=167; 281 public static final int I_STATEMENT_FORMAT31t=168; 282 public static final int I_STATEMENT_FORMAT32x=169; 283 public static final int I_STATEMENT_FORMAT35c_CALL_SITE=170; 284 public static final int I_STATEMENT_FORMAT35c_METHOD=171; 285 public static final int I_STATEMENT_FORMAT35c_TYPE=172; 286 public static final int I_STATEMENT_FORMAT3rc_CALL_SITE=173; 287 public static final int I_STATEMENT_FORMAT3rc_METHOD=174; 288 public static final int I_STATEMENT_FORMAT3rc_TYPE=175; 289 public static final int I_STATEMENT_FORMAT45cc_METHOD=176; 290 public static final int I_STATEMENT_FORMAT4rcc_METHOD=177; 291 public static final int I_STATEMENT_FORMAT51l=178; 292 public static final int I_STATEMENT_PACKED_SWITCH=179; 293 public static final int I_STATEMENT_SPARSE_SWITCH=180; 294 public static final int I_SUBANNOTATION=181; 295 public static final int I_SUPER=182; 296 public static final int LINE_COMMENT=183; 297 public static final int LINE_DIRECTIVE=184; 298 public static final int LOCALS_DIRECTIVE=185; 299 public static final int LOCAL_DIRECTIVE=186; 300 public static final int LONG_LITERAL=187; 301 public static final int MEMBER_NAME=188; 302 public static final int METHOD_DIRECTIVE=189; 303 public static final int METHOD_HANDLE_TYPE_FIELD=190; 304 public static final int METHOD_HANDLE_TYPE_METHOD=191; 305 public static final int NEGATIVE_INTEGER_LITERAL=192; 306 public static final int NULL_LITERAL=193; 307 public static final int OPEN_BRACE=194; 308 public static final int OPEN_PAREN=195; 309 public static final int PACKED_SWITCH_DIRECTIVE=196; 310 public static final int PARAMETER_DIRECTIVE=197; 311 public static final int PARAM_LIST_OR_ID_PRIMITIVE_TYPE=198; 312 public static final int POSITIVE_INTEGER_LITERAL=199; 313 public static final int PRIMITIVE_TYPE=200; 314 public static final int PROLOGUE_DIRECTIVE=201; 315 public static final int REGISTER=202; 316 public static final int REGISTERS_DIRECTIVE=203; 317 public static final int RESTART_LOCAL_DIRECTIVE=204; 318 public static final int SHORT_LITERAL=205; 319 public static final int SIMPLE_NAME=206; 320 public static final int SOURCE_DIRECTIVE=207; 321 public static final int SPARSE_SWITCH_DIRECTIVE=208; 322 public static final int STRING_LITERAL=209; 323 public static final int SUBANNOTATION_DIRECTIVE=210; 324 public static final int SUPER_DIRECTIVE=211; 325 public static final int VERIFICATION_ERROR_TYPE=212; 326 public static final int VOID_TYPE=213; 327 public static final int VTABLE_INDEX=214; 328 public static final int WHITE_SPACE=215; 329 330 // delegates getDelegates()331 public TreeParser[] getDelegates() { 332 return new TreeParser[] {}; 333 } 334 335 // delegators 336 337 smaliTreeWalker(TreeNodeStream input)338 public smaliTreeWalker(TreeNodeStream input) { 339 this(input, new RecognizerSharedState()); 340 } smaliTreeWalker(TreeNodeStream input, RecognizerSharedState state)341 public smaliTreeWalker(TreeNodeStream input, RecognizerSharedState state) { 342 super(input, state); 343 } 344 getTokenNames()345 @Override public String[] getTokenNames() { return smaliTreeWalker.tokenNames; } getGrammarFileName()346 @Override public String getGrammarFileName() { return "smaliTreeWalker.g"; } 347 348 349 public String classType; 350 private boolean verboseErrors = false; 351 private int apiLevel = 15; 352 private Opcodes opcodes = Opcodes.forApi(apiLevel); 353 private DexBuilder dexBuilder; 354 private int callSiteNameIndex = 0; 355 setDexBuilder(DexBuilder dexBuilder)356 public void setDexBuilder(DexBuilder dexBuilder) { 357 this.dexBuilder = dexBuilder; 358 } 359 setApiLevel(int apiLevel)360 public void setApiLevel(int apiLevel) { 361 this.opcodes = Opcodes.forApi(apiLevel); 362 this.apiLevel = apiLevel; 363 } 364 setVerboseErrors(boolean verboseErrors)365 public void setVerboseErrors(boolean verboseErrors) { 366 this.verboseErrors = verboseErrors; 367 } 368 parseRegister_nibble(String register)369 private byte parseRegister_nibble(String register) 370 throws SemanticException { 371 int totalMethodRegisters = method_stack.peek().totalMethodRegisters; 372 int methodParameterRegisters = method_stack.peek().methodParameterRegisters; 373 374 //register should be in the format "v12" 375 int val = Byte.parseByte(register.substring(1)); 376 if (register.charAt(0) == 'p') { 377 val = totalMethodRegisters - methodParameterRegisters + val; 378 } 379 if (val >= 2<<4) { 380 throw new SemanticException(input, "The maximum allowed register in this context is list of registers is v15"); 381 } 382 //the parser wouldn't have accepted a negative register, i.e. v-1, so we don't have to check for val<0; 383 return (byte)val; 384 } 385 386 //return a short, because java's byte is signed parseRegister_byte(String register)387 private short parseRegister_byte(String register) 388 throws SemanticException { 389 int totalMethodRegisters = method_stack.peek().totalMethodRegisters; 390 int methodParameterRegisters = method_stack.peek().methodParameterRegisters; 391 //register should be in the format "v123" 392 int val = Short.parseShort(register.substring(1)); 393 if (register.charAt(0) == 'p') { 394 val = totalMethodRegisters - methodParameterRegisters + val; 395 } 396 if (val >= 2<<8) { 397 throw new SemanticException(input, "The maximum allowed register in this context is v255"); 398 } 399 return (short)val; 400 } 401 402 //return an int because java's short is signed parseRegister_short(String register)403 private int parseRegister_short(String register) 404 throws SemanticException { 405 int totalMethodRegisters = method_stack.peek().totalMethodRegisters; 406 int methodParameterRegisters = method_stack.peek().methodParameterRegisters; 407 //register should be in the format "v12345" 408 int val = Integer.parseInt(register.substring(1)); 409 if (register.charAt(0) == 'p') { 410 val = totalMethodRegisters - methodParameterRegisters + val; 411 } 412 if (val >= 2<<16) { 413 throw new SemanticException(input, "The maximum allowed register in this context is v65535"); 414 } 415 //the parser wouldn't accept a negative register, i.e. v-1, so we don't have to check for val<0; 416 return val; 417 } 418 getErrorMessage(RecognitionException e, String[] tokenNames)419 public String getErrorMessage(RecognitionException e, String[] tokenNames) { 420 if ( e instanceof SemanticException ) { 421 return e.getMessage(); 422 } else { 423 return super.getErrorMessage(e, tokenNames); 424 } 425 } 426 getErrorHeader(RecognitionException e)427 public String getErrorHeader(RecognitionException e) { 428 return getSourceName()+"["+ e.line+","+e.charPositionInLine+"]"; 429 } 430 431 432 433 // $ANTLR start "smali_file" 434 // smaliTreeWalker.g:163:1: smali_file returns [ClassDef classDef] : ^( I_CLASS_DEF header methods fields annotations ) ; smali_file()435 public final ClassDef smali_file() throws RecognitionException { 436 ClassDef classDef = null; 437 438 439 TreeRuleReturnScope header1 =null; 440 Set<Annotation> annotations2 =null; 441 List<BuilderField> fields3 =null; 442 List<BuilderMethod> methods4 =null; 443 444 try { 445 // smaliTreeWalker.g:164:3: ( ^( I_CLASS_DEF header methods fields annotations ) ) 446 // smaliTreeWalker.g:164:5: ^( I_CLASS_DEF header methods fields annotations ) 447 { 448 match(input,I_CLASS_DEF,FOLLOW_I_CLASS_DEF_in_smali_file52); 449 match(input, Token.DOWN, null); 450 pushFollow(FOLLOW_header_in_smali_file54); 451 header1=header(); 452 state._fsp--; 453 454 pushFollow(FOLLOW_methods_in_smali_file56); 455 methods4=methods(); 456 state._fsp--; 457 458 pushFollow(FOLLOW_fields_in_smali_file58); 459 fields3=fields(); 460 state._fsp--; 461 462 pushFollow(FOLLOW_annotations_in_smali_file60); 463 annotations2=annotations(); 464 state._fsp--; 465 466 match(input, Token.UP, null); 467 468 469 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), 470 (header1!=null?((smaliTreeWalker.header_return)header1).implementsList:null), (header1!=null?((smaliTreeWalker.header_return)header1).sourceSpec:null), annotations2, fields3, methods4); 471 472 } 473 474 } 475 catch (Exception ex) { 476 477 if (verboseErrors) { 478 ex.printStackTrace(System.err); 479 } 480 reportError(new SemanticException(input, ex)); 481 482 } 483 484 finally { 485 // do for sure before leaving 486 } 487 return classDef; 488 } 489 // $ANTLR end "smali_file" 490 491 492 public static class header_return extends TreeRuleReturnScope { 493 public String classType; 494 public int accessFlags; 495 public String superType; 496 public List<String> implementsList; 497 public String sourceSpec; 498 }; 499 500 501 // $ANTLR start "header" 502 // smaliTreeWalker.g:177:1: header returns [String classType, int accessFlags, String superType, List<String> implementsList, String sourceSpec] : class_spec ( super_spec )? implements_list source_spec ; header()503 public final smaliTreeWalker.header_return header() throws RecognitionException { 504 smaliTreeWalker.header_return retval = new smaliTreeWalker.header_return(); 505 retval.start = input.LT(1); 506 507 TreeRuleReturnScope class_spec5 =null; 508 String super_spec6 =null; 509 List<String> implements_list7 =null; 510 String source_spec8 =null; 511 512 try { 513 // smaliTreeWalker.g:178:3: ( class_spec ( super_spec )? implements_list source_spec ) 514 // smaliTreeWalker.g:178:3: class_spec ( super_spec )? implements_list source_spec 515 { 516 pushFollow(FOLLOW_class_spec_in_header85); 517 class_spec5=class_spec(); 518 state._fsp--; 519 520 // smaliTreeWalker.g:178:14: ( super_spec )? 521 int alt1=2; 522 int LA1_0 = input.LA(1); 523 if ( (LA1_0==I_SUPER) ) { 524 alt1=1; 525 } 526 switch (alt1) { 527 case 1 : 528 // smaliTreeWalker.g:178:14: super_spec 529 { 530 pushFollow(FOLLOW_super_spec_in_header87); 531 super_spec6=super_spec(); 532 state._fsp--; 533 534 } 535 break; 536 537 } 538 539 pushFollow(FOLLOW_implements_list_in_header90); 540 implements_list7=implements_list(); 541 state._fsp--; 542 543 pushFollow(FOLLOW_source_spec_in_header92); 544 source_spec8=source_spec(); 545 state._fsp--; 546 547 548 classType = (class_spec5!=null?((smaliTreeWalker.class_spec_return)class_spec5).type:null); 549 retval.classType = classType; 550 retval.accessFlags = (class_spec5!=null?((smaliTreeWalker.class_spec_return)class_spec5).accessFlags:0); 551 retval.superType = super_spec6; 552 retval.implementsList = implements_list7; 553 retval.sourceSpec = source_spec8; 554 555 } 556 557 } 558 catch (RecognitionException re) { 559 reportError(re); 560 recover(input,re); 561 } 562 finally { 563 // do for sure before leaving 564 } 565 return retval; 566 } 567 // $ANTLR end "header" 568 569 570 public static class class_spec_return extends TreeRuleReturnScope { 571 public String type; 572 public int accessFlags; 573 }; 574 575 576 // $ANTLR start "class_spec" 577 // smaliTreeWalker.g:189:1: class_spec returns [String type, int accessFlags] : CLASS_DESCRIPTOR access_list ; class_spec()578 public final smaliTreeWalker.class_spec_return class_spec() throws RecognitionException { 579 smaliTreeWalker.class_spec_return retval = new smaliTreeWalker.class_spec_return(); 580 retval.start = input.LT(1); 581 582 CommonTree CLASS_DESCRIPTOR9=null; 583 int access_list10 =0; 584 585 try { 586 // smaliTreeWalker.g:190:3: ( CLASS_DESCRIPTOR access_list ) 587 // smaliTreeWalker.g:190:5: CLASS_DESCRIPTOR access_list 588 { 589 CLASS_DESCRIPTOR9=(CommonTree)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_class_spec110); 590 pushFollow(FOLLOW_access_list_in_class_spec112); 591 access_list10=access_list(); 592 state._fsp--; 593 594 595 retval.type = (CLASS_DESCRIPTOR9!=null?CLASS_DESCRIPTOR9.getText():null); 596 retval.accessFlags = access_list10; 597 598 } 599 600 } 601 catch (RecognitionException re) { 602 reportError(re); 603 recover(input,re); 604 } 605 finally { 606 // do for sure before leaving 607 } 608 return retval; 609 } 610 // $ANTLR end "class_spec" 611 612 613 614 // $ANTLR start "super_spec" 615 // smaliTreeWalker.g:196:1: super_spec returns [String type] : ^( I_SUPER CLASS_DESCRIPTOR ) ; super_spec()616 public final String super_spec() throws RecognitionException { 617 String type = null; 618 619 620 CommonTree CLASS_DESCRIPTOR11=null; 621 622 try { 623 // smaliTreeWalker.g:197:3: ( ^( I_SUPER CLASS_DESCRIPTOR ) ) 624 // smaliTreeWalker.g:197:5: ^( I_SUPER CLASS_DESCRIPTOR ) 625 { 626 match(input,I_SUPER,FOLLOW_I_SUPER_in_super_spec130); 627 match(input, Token.DOWN, null); 628 CLASS_DESCRIPTOR11=(CommonTree)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_super_spec132); 629 match(input, Token.UP, null); 630 631 632 type = (CLASS_DESCRIPTOR11!=null?CLASS_DESCRIPTOR11.getText():null); 633 634 } 635 636 } 637 catch (RecognitionException re) { 638 reportError(re); 639 recover(input,re); 640 } 641 finally { 642 // do for sure before leaving 643 } 644 return type; 645 } 646 // $ANTLR end "super_spec" 647 648 649 650 // $ANTLR start "implements_spec" 651 // smaliTreeWalker.g:203:1: implements_spec returns [String type] : ^( I_IMPLEMENTS CLASS_DESCRIPTOR ) ; implements_spec()652 public final String implements_spec() throws RecognitionException { 653 String type = null; 654 655 656 CommonTree CLASS_DESCRIPTOR12=null; 657 658 try { 659 // smaliTreeWalker.g:204:3: ( ^( I_IMPLEMENTS CLASS_DESCRIPTOR ) ) 660 // smaliTreeWalker.g:204:5: ^( I_IMPLEMENTS CLASS_DESCRIPTOR ) 661 { 662 match(input,I_IMPLEMENTS,FOLLOW_I_IMPLEMENTS_in_implements_spec152); 663 match(input, Token.DOWN, null); 664 CLASS_DESCRIPTOR12=(CommonTree)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_implements_spec154); 665 match(input, Token.UP, null); 666 667 668 type = (CLASS_DESCRIPTOR12!=null?CLASS_DESCRIPTOR12.getText():null); 669 670 } 671 672 } 673 catch (RecognitionException re) { 674 reportError(re); 675 recover(input,re); 676 } 677 finally { 678 // do for sure before leaving 679 } 680 return type; 681 } 682 // $ANTLR end "implements_spec" 683 684 685 686 // $ANTLR start "implements_list" 687 // smaliTreeWalker.g:209:1: implements_list returns [List<String> implementsList] : ( implements_spec )* ; implements_list()688 public final List<String> implements_list() throws RecognitionException { 689 List<String> implementsList = null; 690 691 692 String implements_spec13 =null; 693 694 List<String> typeList; 695 try { 696 // smaliTreeWalker.g:211:3: ( ( implements_spec )* ) 697 // smaliTreeWalker.g:211:5: ( implements_spec )* 698 { 699 typeList = Lists.newArrayList(); 700 // smaliTreeWalker.g:212:5: ( implements_spec )* 701 loop2: 702 while (true) { 703 int alt2=2; 704 int LA2_0 = input.LA(1); 705 if ( (LA2_0==I_IMPLEMENTS) ) { 706 alt2=1; 707 } 708 709 switch (alt2) { 710 case 1 : 711 // smaliTreeWalker.g:212:6: implements_spec 712 { 713 pushFollow(FOLLOW_implements_spec_in_implements_list184); 714 implements_spec13=implements_spec(); 715 state._fsp--; 716 717 typeList.add(implements_spec13); 718 } 719 break; 720 721 default : 722 break loop2; 723 } 724 } 725 726 727 if (typeList.size() > 0) { 728 implementsList = typeList; 729 } else { 730 implementsList = null; 731 } 732 733 } 734 735 } 736 catch (RecognitionException re) { 737 reportError(re); 738 recover(input,re); 739 } 740 finally { 741 // do for sure before leaving 742 } 743 return implementsList; 744 } 745 // $ANTLR end "implements_list" 746 747 748 749 // $ANTLR start "source_spec" 750 // smaliTreeWalker.g:221:1: source_spec returns [String source] : ( ^( I_SOURCE string_literal ) |); source_spec()751 public final String source_spec() throws RecognitionException { 752 String source = null; 753 754 755 String string_literal14 =null; 756 757 try { 758 // smaliTreeWalker.g:222:3: ( ^( I_SOURCE string_literal ) |) 759 int alt3=2; 760 int LA3_0 = input.LA(1); 761 if ( (LA3_0==I_SOURCE) ) { 762 alt3=1; 763 } 764 else if ( (LA3_0==I_METHODS) ) { 765 alt3=2; 766 } 767 768 else { 769 NoViableAltException nvae = 770 new NoViableAltException("", 3, 0, input); 771 throw nvae; 772 } 773 774 switch (alt3) { 775 case 1 : 776 // smaliTreeWalker.g:222:5: ^( I_SOURCE string_literal ) 777 { 778 source = null; 779 match(input,I_SOURCE,FOLLOW_I_SOURCE_in_source_spec213); 780 match(input, Token.DOWN, null); 781 pushFollow(FOLLOW_string_literal_in_source_spec215); 782 string_literal14=string_literal(); 783 state._fsp--; 784 785 source = string_literal14; 786 match(input, Token.UP, null); 787 788 } 789 break; 790 case 2 : 791 // smaliTreeWalker.g:224:16: 792 { 793 } 794 break; 795 796 } 797 } 798 catch (RecognitionException re) { 799 reportError(re); 800 recover(input,re); 801 } 802 finally { 803 // do for sure before leaving 804 } 805 return source; 806 } 807 // $ANTLR end "source_spec" 808 809 810 811 // $ANTLR start "access_list" 812 // smaliTreeWalker.g:226:1: access_list returns [int value] : ^( I_ACCESS_LIST ( ACCESS_SPEC )* ) ; access_list()813 public final int access_list() throws RecognitionException { 814 int value = 0; 815 816 817 CommonTree ACCESS_SPEC15=null; 818 819 820 value = 0; 821 822 try { 823 // smaliTreeWalker.g:231:3: ( ^( I_ACCESS_LIST ( ACCESS_SPEC )* ) ) 824 // smaliTreeWalker.g:231:5: ^( I_ACCESS_LIST ( ACCESS_SPEC )* ) 825 { 826 match(input,I_ACCESS_LIST,FOLLOW_I_ACCESS_LIST_in_access_list248); 827 if ( input.LA(1)==Token.DOWN ) { 828 match(input, Token.DOWN, null); 829 // smaliTreeWalker.g:232:7: ( ACCESS_SPEC )* 830 loop4: 831 while (true) { 832 int alt4=2; 833 int LA4_0 = input.LA(1); 834 if ( (LA4_0==ACCESS_SPEC) ) { 835 alt4=1; 836 } 837 838 switch (alt4) { 839 case 1 : 840 // smaliTreeWalker.g:233:9: ACCESS_SPEC 841 { 842 ACCESS_SPEC15=(CommonTree)match(input,ACCESS_SPEC,FOLLOW_ACCESS_SPEC_in_access_list266); 843 844 value |= AccessFlags.getAccessFlag(ACCESS_SPEC15.getText()).getValue(); 845 846 } 847 break; 848 849 default : 850 break loop4; 851 } 852 } 853 854 match(input, Token.UP, null); 855 } 856 857 } 858 859 } 860 catch (RecognitionException re) { 861 reportError(re); 862 recover(input,re); 863 } 864 finally { 865 // do for sure before leaving 866 } 867 return value; 868 } 869 // $ANTLR end "access_list" 870 871 872 873 // $ANTLR start "fields" 874 // smaliTreeWalker.g:240:1: fields returns [List<BuilderField> fields] : ^( I_FIELDS ( field )* ) ; fields()875 public final List<BuilderField> fields() throws RecognitionException { 876 List<BuilderField> fields = null; 877 878 879 BuilderField field16 =null; 880 881 fields = Lists.newArrayList(); 882 try { 883 // smaliTreeWalker.g:242:3: ( ^( I_FIELDS ( field )* ) ) 884 // smaliTreeWalker.g:242:5: ^( I_FIELDS ( field )* ) 885 { 886 match(input,I_FIELDS,FOLLOW_I_FIELDS_in_fields308); 887 if ( input.LA(1)==Token.DOWN ) { 888 match(input, Token.DOWN, null); 889 // smaliTreeWalker.g:243:7: ( field )* 890 loop5: 891 while (true) { 892 int alt5=2; 893 int LA5_0 = input.LA(1); 894 if ( (LA5_0==I_FIELD) ) { 895 alt5=1; 896 } 897 898 switch (alt5) { 899 case 1 : 900 // smaliTreeWalker.g:243:8: field 901 { 902 pushFollow(FOLLOW_field_in_fields317); 903 field16=field(); 904 state._fsp--; 905 906 907 fields.add(field16); 908 909 } 910 break; 911 912 default : 913 break loop5; 914 } 915 } 916 917 match(input, Token.UP, null); 918 } 919 920 } 921 922 } 923 catch (RecognitionException re) { 924 reportError(re); 925 recover(input,re); 926 } 927 finally { 928 // do for sure before leaving 929 } 930 return fields; 931 } 932 // $ANTLR end "fields" 933 934 935 936 // $ANTLR start "methods" 937 // smaliTreeWalker.g:248:1: methods returns [List<BuilderMethod> methods] : ^( I_METHODS ( method )* ) ; methods()938 public final List<BuilderMethod> methods() throws RecognitionException { 939 List<BuilderMethod> methods = null; 940 941 942 BuilderMethod method17 =null; 943 944 methods = Lists.newArrayList(); 945 try { 946 // smaliTreeWalker.g:250:3: ( ^( I_METHODS ( method )* ) ) 947 // smaliTreeWalker.g:250:5: ^( I_METHODS ( method )* ) 948 { 949 match(input,I_METHODS,FOLLOW_I_METHODS_in_methods349); 950 if ( input.LA(1)==Token.DOWN ) { 951 match(input, Token.DOWN, null); 952 // smaliTreeWalker.g:251:7: ( method )* 953 loop6: 954 while (true) { 955 int alt6=2; 956 int LA6_0 = input.LA(1); 957 if ( (LA6_0==I_METHOD) ) { 958 alt6=1; 959 } 960 961 switch (alt6) { 962 case 1 : 963 // smaliTreeWalker.g:251:8: method 964 { 965 pushFollow(FOLLOW_method_in_methods358); 966 method17=method(); 967 state._fsp--; 968 969 970 methods.add(method17); 971 972 } 973 break; 974 975 default : 976 break loop6; 977 } 978 } 979 980 match(input, Token.UP, null); 981 } 982 983 } 984 985 } 986 catch (RecognitionException re) { 987 reportError(re); 988 recover(input,re); 989 } 990 finally { 991 // do for sure before leaving 992 } 993 return methods; 994 } 995 // $ANTLR end "methods" 996 997 998 999 // $ANTLR start "field" 1000 // smaliTreeWalker.g:256:1: field returns [BuilderField field] : ^( I_FIELD SIMPLE_NAME access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) field_initial_value ( annotations )? ) ; field()1001 public final BuilderField field() throws RecognitionException { 1002 BuilderField field = null; 1003 1004 1005 CommonTree SIMPLE_NAME20=null; 1006 int access_list18 =0; 1007 EncodedValue field_initial_value19 =null; 1008 TreeRuleReturnScope nonvoid_type_descriptor21 =null; 1009 Set<Annotation> annotations22 =null; 1010 1011 try { 1012 // smaliTreeWalker.g:257:3: ( ^( I_FIELD SIMPLE_NAME access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) field_initial_value ( annotations )? ) ) 1013 // smaliTreeWalker.g:257:4: ^( I_FIELD SIMPLE_NAME access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) field_initial_value ( annotations )? ) 1014 { 1015 match(input,I_FIELD,FOLLOW_I_FIELD_in_field383); 1016 match(input, Token.DOWN, null); 1017 SIMPLE_NAME20=(CommonTree)match(input,SIMPLE_NAME,FOLLOW_SIMPLE_NAME_in_field385); 1018 pushFollow(FOLLOW_access_list_in_field387); 1019 access_list18=access_list(); 1020 state._fsp--; 1021 1022 match(input,I_FIELD_TYPE,FOLLOW_I_FIELD_TYPE_in_field390); 1023 match(input, Token.DOWN, null); 1024 pushFollow(FOLLOW_nonvoid_type_descriptor_in_field392); 1025 nonvoid_type_descriptor21=nonvoid_type_descriptor(); 1026 state._fsp--; 1027 1028 match(input, Token.UP, null); 1029 1030 pushFollow(FOLLOW_field_initial_value_in_field395); 1031 field_initial_value19=field_initial_value(); 1032 state._fsp--; 1033 1034 // smaliTreeWalker.g:257:98: ( annotations )? 1035 int alt7=2; 1036 int LA7_0 = input.LA(1); 1037 if ( (LA7_0==I_ANNOTATIONS) ) { 1038 alt7=1; 1039 } 1040 switch (alt7) { 1041 case 1 : 1042 // smaliTreeWalker.g:257:98: annotations 1043 { 1044 pushFollow(FOLLOW_annotations_in_field397); 1045 annotations22=annotations(); 1046 state._fsp--; 1047 1048 } 1049 break; 1050 1051 } 1052 1053 match(input, Token.UP, null); 1054 1055 1056 int accessFlags = access_list18; 1057 1058 1059 if (!AccessFlags.STATIC.isSet(accessFlags) && field_initial_value19 != null) { 1060 throw new SemanticException(input, "Initial field values can only be specified for static fields."); 1061 } 1062 1063 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, 1064 field_initial_value19, annotations22); 1065 1066 } 1067 1068 } 1069 catch (RecognitionException re) { 1070 reportError(re); 1071 recover(input,re); 1072 } 1073 finally { 1074 // do for sure before leaving 1075 } 1076 return field; 1077 } 1078 // $ANTLR end "field" 1079 1080 1081 1082 // $ANTLR start "field_initial_value" 1083 // smaliTreeWalker.g:271:1: field_initial_value returns [EncodedValue encodedValue] : ( ^( I_FIELD_INITIAL_VALUE literal ) |); field_initial_value()1084 public final EncodedValue field_initial_value() throws RecognitionException { 1085 EncodedValue encodedValue = null; 1086 1087 1088 ImmutableEncodedValue literal23 =null; 1089 1090 try { 1091 // smaliTreeWalker.g:272:3: ( ^( I_FIELD_INITIAL_VALUE literal ) |) 1092 int alt8=2; 1093 int LA8_0 = input.LA(1); 1094 if ( (LA8_0==I_FIELD_INITIAL_VALUE) ) { 1095 alt8=1; 1096 } 1097 else if ( (LA8_0==UP||LA8_0==I_ANNOTATIONS) ) { 1098 alt8=2; 1099 } 1100 1101 else { 1102 NoViableAltException nvae = 1103 new NoViableAltException("", 8, 0, input); 1104 throw nvae; 1105 } 1106 1107 switch (alt8) { 1108 case 1 : 1109 // smaliTreeWalker.g:272:5: ^( I_FIELD_INITIAL_VALUE literal ) 1110 { 1111 match(input,I_FIELD_INITIAL_VALUE,FOLLOW_I_FIELD_INITIAL_VALUE_in_field_initial_value418); 1112 match(input, Token.DOWN, null); 1113 pushFollow(FOLLOW_literal_in_field_initial_value420); 1114 literal23=literal(); 1115 state._fsp--; 1116 1117 match(input, Token.UP, null); 1118 1119 encodedValue = literal23; 1120 } 1121 break; 1122 case 2 : 1123 // smaliTreeWalker.g:273:16: 1124 { 1125 } 1126 break; 1127 1128 } 1129 } 1130 catch (RecognitionException re) { 1131 reportError(re); 1132 recover(input,re); 1133 } 1134 finally { 1135 // do for sure before leaving 1136 } 1137 return encodedValue; 1138 } 1139 // $ANTLR end "field_initial_value" 1140 1141 1142 1143 // $ANTLR start "literal" 1144 // smaliTreeWalker.g:275:1: literal returns [ImmutableEncodedValue 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 | method_handle_literal | method_prototype ); literal()1145 public final ImmutableEncodedValue literal() throws RecognitionException { 1146 ImmutableEncodedValue encodedValue = null; 1147 1148 1149 int integer_literal24 =0; 1150 long long_literal25 =0; 1151 short short_literal26 =0; 1152 byte byte_literal27 =0; 1153 float float_literal28 =0.0f; 1154 double double_literal29 =0.0; 1155 char char_literal30 =0; 1156 String string_literal31 =null; 1157 boolean bool_literal32 =false; 1158 String type_descriptor33 =null; 1159 List<EncodedValue> array_literal34 =null; 1160 TreeRuleReturnScope subannotation35 =null; 1161 ImmutableFieldReference field_literal36 =null; 1162 ImmutableMethodReference method_literal37 =null; 1163 ImmutableFieldReference enum_literal38 =null; 1164 ImmutableMethodHandleReference method_handle_literal39 =null; 1165 ImmutableMethodProtoReference method_prototype40 =null; 1166 1167 try { 1168 // smaliTreeWalker.g:276: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 | method_handle_literal | method_prototype ) 1169 int alt9=18; 1170 switch ( input.LA(1) ) { 1171 case INTEGER_LITERAL: 1172 { 1173 alt9=1; 1174 } 1175 break; 1176 case LONG_LITERAL: 1177 { 1178 alt9=2; 1179 } 1180 break; 1181 case SHORT_LITERAL: 1182 { 1183 alt9=3; 1184 } 1185 break; 1186 case BYTE_LITERAL: 1187 { 1188 alt9=4; 1189 } 1190 break; 1191 case FLOAT_LITERAL: 1192 { 1193 alt9=5; 1194 } 1195 break; 1196 case DOUBLE_LITERAL: 1197 { 1198 alt9=6; 1199 } 1200 break; 1201 case CHAR_LITERAL: 1202 { 1203 alt9=7; 1204 } 1205 break; 1206 case STRING_LITERAL: 1207 { 1208 alt9=8; 1209 } 1210 break; 1211 case BOOL_LITERAL: 1212 { 1213 alt9=9; 1214 } 1215 break; 1216 case NULL_LITERAL: 1217 { 1218 alt9=10; 1219 } 1220 break; 1221 case ARRAY_TYPE_PREFIX: 1222 case CLASS_DESCRIPTOR: 1223 case PRIMITIVE_TYPE: 1224 case VOID_TYPE: 1225 { 1226 alt9=11; 1227 } 1228 break; 1229 case I_ENCODED_ARRAY: 1230 { 1231 alt9=12; 1232 } 1233 break; 1234 case I_SUBANNOTATION: 1235 { 1236 alt9=13; 1237 } 1238 break; 1239 case I_ENCODED_FIELD: 1240 { 1241 alt9=14; 1242 } 1243 break; 1244 case I_ENCODED_METHOD: 1245 { 1246 alt9=15; 1247 } 1248 break; 1249 case I_ENCODED_ENUM: 1250 { 1251 alt9=16; 1252 } 1253 break; 1254 case I_ENCODED_METHOD_HANDLE: 1255 { 1256 alt9=17; 1257 } 1258 break; 1259 case I_METHOD_PROTOTYPE: 1260 { 1261 alt9=18; 1262 } 1263 break; 1264 default: 1265 NoViableAltException nvae = 1266 new NoViableAltException("", 9, 0, input); 1267 throw nvae; 1268 } 1269 switch (alt9) { 1270 case 1 : 1271 // smaliTreeWalker.g:276:5: integer_literal 1272 { 1273 pushFollow(FOLLOW_integer_literal_in_literal442); 1274 integer_literal24=integer_literal(); 1275 state._fsp--; 1276 1277 encodedValue = new ImmutableIntEncodedValue(integer_literal24); 1278 } 1279 break; 1280 case 2 : 1281 // smaliTreeWalker.g:277:5: long_literal 1282 { 1283 pushFollow(FOLLOW_long_literal_in_literal450); 1284 long_literal25=long_literal(); 1285 state._fsp--; 1286 1287 encodedValue = new ImmutableLongEncodedValue(long_literal25); 1288 } 1289 break; 1290 case 3 : 1291 // smaliTreeWalker.g:278:5: short_literal 1292 { 1293 pushFollow(FOLLOW_short_literal_in_literal458); 1294 short_literal26=short_literal(); 1295 state._fsp--; 1296 1297 encodedValue = new ImmutableShortEncodedValue(short_literal26); 1298 } 1299 break; 1300 case 4 : 1301 // smaliTreeWalker.g:279:5: byte_literal 1302 { 1303 pushFollow(FOLLOW_byte_literal_in_literal466); 1304 byte_literal27=byte_literal(); 1305 state._fsp--; 1306 1307 encodedValue = new ImmutableByteEncodedValue(byte_literal27); 1308 } 1309 break; 1310 case 5 : 1311 // smaliTreeWalker.g:280:5: float_literal 1312 { 1313 pushFollow(FOLLOW_float_literal_in_literal474); 1314 float_literal28=float_literal(); 1315 state._fsp--; 1316 1317 encodedValue = new ImmutableFloatEncodedValue(float_literal28); 1318 } 1319 break; 1320 case 6 : 1321 // smaliTreeWalker.g:281:5: double_literal 1322 { 1323 pushFollow(FOLLOW_double_literal_in_literal482); 1324 double_literal29=double_literal(); 1325 state._fsp--; 1326 1327 encodedValue = new ImmutableDoubleEncodedValue(double_literal29); 1328 } 1329 break; 1330 case 7 : 1331 // smaliTreeWalker.g:282:5: char_literal 1332 { 1333 pushFollow(FOLLOW_char_literal_in_literal490); 1334 char_literal30=char_literal(); 1335 state._fsp--; 1336 1337 encodedValue = new ImmutableCharEncodedValue(char_literal30); 1338 } 1339 break; 1340 case 8 : 1341 // smaliTreeWalker.g:283:5: string_literal 1342 { 1343 pushFollow(FOLLOW_string_literal_in_literal498); 1344 string_literal31=string_literal(); 1345 state._fsp--; 1346 1347 encodedValue = new ImmutableStringEncodedValue(string_literal31); 1348 } 1349 break; 1350 case 9 : 1351 // smaliTreeWalker.g:284:5: bool_literal 1352 { 1353 pushFollow(FOLLOW_bool_literal_in_literal506); 1354 bool_literal32=bool_literal(); 1355 state._fsp--; 1356 1357 encodedValue = ImmutableBooleanEncodedValue.forBoolean(bool_literal32); 1358 } 1359 break; 1360 case 10 : 1361 // smaliTreeWalker.g:285:5: NULL_LITERAL 1362 { 1363 match(input,NULL_LITERAL,FOLLOW_NULL_LITERAL_in_literal514); 1364 encodedValue = ImmutableNullEncodedValue.INSTANCE; 1365 } 1366 break; 1367 case 11 : 1368 // smaliTreeWalker.g:286:5: type_descriptor 1369 { 1370 pushFollow(FOLLOW_type_descriptor_in_literal522); 1371 type_descriptor33=type_descriptor(); 1372 state._fsp--; 1373 1374 encodedValue = new ImmutableTypeEncodedValue(type_descriptor33); 1375 } 1376 break; 1377 case 12 : 1378 // smaliTreeWalker.g:287:5: array_literal 1379 { 1380 pushFollow(FOLLOW_array_literal_in_literal530); 1381 array_literal34=array_literal(); 1382 state._fsp--; 1383 1384 encodedValue = new ImmutableArrayEncodedValue(array_literal34); 1385 } 1386 break; 1387 case 13 : 1388 // smaliTreeWalker.g:288:5: subannotation 1389 { 1390 pushFollow(FOLLOW_subannotation_in_literal538); 1391 subannotation35=subannotation(); 1392 state._fsp--; 1393 1394 encodedValue = new ImmutableAnnotationEncodedValue((subannotation35!=null?((smaliTreeWalker.subannotation_return)subannotation35).annotationType:null), (subannotation35!=null?((smaliTreeWalker.subannotation_return)subannotation35).elements:null)); 1395 } 1396 break; 1397 case 14 : 1398 // smaliTreeWalker.g:289:5: field_literal 1399 { 1400 pushFollow(FOLLOW_field_literal_in_literal546); 1401 field_literal36=field_literal(); 1402 state._fsp--; 1403 1404 encodedValue = new ImmutableFieldEncodedValue(field_literal36); 1405 } 1406 break; 1407 case 15 : 1408 // smaliTreeWalker.g:290:5: method_literal 1409 { 1410 pushFollow(FOLLOW_method_literal_in_literal554); 1411 method_literal37=method_literal(); 1412 state._fsp--; 1413 1414 encodedValue = new ImmutableMethodEncodedValue(method_literal37); 1415 } 1416 break; 1417 case 16 : 1418 // smaliTreeWalker.g:291:5: enum_literal 1419 { 1420 pushFollow(FOLLOW_enum_literal_in_literal562); 1421 enum_literal38=enum_literal(); 1422 state._fsp--; 1423 1424 encodedValue = new ImmutableEnumEncodedValue(enum_literal38); 1425 } 1426 break; 1427 case 17 : 1428 // smaliTreeWalker.g:292:5: method_handle_literal 1429 { 1430 pushFollow(FOLLOW_method_handle_literal_in_literal570); 1431 method_handle_literal39=method_handle_literal(); 1432 state._fsp--; 1433 1434 encodedValue = new ImmutableMethodHandleEncodedValue(method_handle_literal39); 1435 } 1436 break; 1437 case 18 : 1438 // smaliTreeWalker.g:293:5: method_prototype 1439 { 1440 pushFollow(FOLLOW_method_prototype_in_literal578); 1441 method_prototype40=method_prototype(); 1442 state._fsp--; 1443 1444 encodedValue = new ImmutableMethodTypeEncodedValue(method_prototype40); 1445 } 1446 break; 1447 1448 } 1449 } 1450 catch (RecognitionException re) { 1451 reportError(re); 1452 recover(input,re); 1453 } 1454 finally { 1455 // do for sure before leaving 1456 } 1457 return encodedValue; 1458 } 1459 // $ANTLR end "literal" 1460 1461 1462 1463 // $ANTLR start "fixed_64bit_literal_number" 1464 // smaliTreeWalker.g:296:1: fixed_64bit_literal_number returns [Number value] : ( integer_literal | long_literal | short_literal | byte_literal | float_literal | double_literal | char_literal | bool_literal ); fixed_64bit_literal_number()1465 public final Number fixed_64bit_literal_number() throws RecognitionException { 1466 Number value = null; 1467 1468 1469 int integer_literal41 =0; 1470 long long_literal42 =0; 1471 short short_literal43 =0; 1472 byte byte_literal44 =0; 1473 float float_literal45 =0.0f; 1474 double double_literal46 =0.0; 1475 char char_literal47 =0; 1476 boolean bool_literal48 =false; 1477 1478 try { 1479 // smaliTreeWalker.g:297:3: ( integer_literal | long_literal | short_literal | byte_literal | float_literal | double_literal | char_literal | bool_literal ) 1480 int alt10=8; 1481 switch ( input.LA(1) ) { 1482 case INTEGER_LITERAL: 1483 { 1484 alt10=1; 1485 } 1486 break; 1487 case LONG_LITERAL: 1488 { 1489 alt10=2; 1490 } 1491 break; 1492 case SHORT_LITERAL: 1493 { 1494 alt10=3; 1495 } 1496 break; 1497 case BYTE_LITERAL: 1498 { 1499 alt10=4; 1500 } 1501 break; 1502 case FLOAT_LITERAL: 1503 { 1504 alt10=5; 1505 } 1506 break; 1507 case DOUBLE_LITERAL: 1508 { 1509 alt10=6; 1510 } 1511 break; 1512 case CHAR_LITERAL: 1513 { 1514 alt10=7; 1515 } 1516 break; 1517 case BOOL_LITERAL: 1518 { 1519 alt10=8; 1520 } 1521 break; 1522 default: 1523 NoViableAltException nvae = 1524 new NoViableAltException("", 10, 0, input); 1525 throw nvae; 1526 } 1527 switch (alt10) { 1528 case 1 : 1529 // smaliTreeWalker.g:297:5: integer_literal 1530 { 1531 pushFollow(FOLLOW_integer_literal_in_fixed_64bit_literal_number594); 1532 integer_literal41=integer_literal(); 1533 state._fsp--; 1534 1535 value = integer_literal41; 1536 } 1537 break; 1538 case 2 : 1539 // smaliTreeWalker.g:298:5: long_literal 1540 { 1541 pushFollow(FOLLOW_long_literal_in_fixed_64bit_literal_number602); 1542 long_literal42=long_literal(); 1543 state._fsp--; 1544 1545 value = long_literal42; 1546 } 1547 break; 1548 case 3 : 1549 // smaliTreeWalker.g:299:5: short_literal 1550 { 1551 pushFollow(FOLLOW_short_literal_in_fixed_64bit_literal_number610); 1552 short_literal43=short_literal(); 1553 state._fsp--; 1554 1555 value = short_literal43; 1556 } 1557 break; 1558 case 4 : 1559 // smaliTreeWalker.g:300:5: byte_literal 1560 { 1561 pushFollow(FOLLOW_byte_literal_in_fixed_64bit_literal_number618); 1562 byte_literal44=byte_literal(); 1563 state._fsp--; 1564 1565 value = byte_literal44; 1566 } 1567 break; 1568 case 5 : 1569 // smaliTreeWalker.g:301:5: float_literal 1570 { 1571 pushFollow(FOLLOW_float_literal_in_fixed_64bit_literal_number626); 1572 float_literal45=float_literal(); 1573 state._fsp--; 1574 1575 value = Float.floatToRawIntBits(float_literal45); 1576 } 1577 break; 1578 case 6 : 1579 // smaliTreeWalker.g:302:5: double_literal 1580 { 1581 pushFollow(FOLLOW_double_literal_in_fixed_64bit_literal_number634); 1582 double_literal46=double_literal(); 1583 state._fsp--; 1584 1585 value = Double.doubleToRawLongBits(double_literal46); 1586 } 1587 break; 1588 case 7 : 1589 // smaliTreeWalker.g:303:5: char_literal 1590 { 1591 pushFollow(FOLLOW_char_literal_in_fixed_64bit_literal_number642); 1592 char_literal47=char_literal(); 1593 state._fsp--; 1594 1595 value = (int)char_literal47; 1596 } 1597 break; 1598 case 8 : 1599 // smaliTreeWalker.g:304:5: bool_literal 1600 { 1601 pushFollow(FOLLOW_bool_literal_in_fixed_64bit_literal_number650); 1602 bool_literal48=bool_literal(); 1603 state._fsp--; 1604 1605 value = bool_literal48?1:0; 1606 } 1607 break; 1608 1609 } 1610 } 1611 catch (RecognitionException re) { 1612 reportError(re); 1613 recover(input,re); 1614 } 1615 finally { 1616 // do for sure before leaving 1617 } 1618 return value; 1619 } 1620 // $ANTLR end "fixed_64bit_literal_number" 1621 1622 1623 1624 // $ANTLR start "fixed_64bit_literal" 1625 // smaliTreeWalker.g:306:1: fixed_64bit_literal returns [long value] : ( integer_literal | long_literal | short_literal | byte_literal | float_literal | double_literal | char_literal | bool_literal ); fixed_64bit_literal()1626 public final long fixed_64bit_literal() throws RecognitionException { 1627 long value = 0; 1628 1629 1630 int integer_literal49 =0; 1631 long long_literal50 =0; 1632 short short_literal51 =0; 1633 byte byte_literal52 =0; 1634 float float_literal53 =0.0f; 1635 double double_literal54 =0.0; 1636 char char_literal55 =0; 1637 boolean bool_literal56 =false; 1638 1639 try { 1640 // smaliTreeWalker.g:307:3: ( integer_literal | long_literal | short_literal | byte_literal | float_literal | double_literal | char_literal | bool_literal ) 1641 int alt11=8; 1642 switch ( input.LA(1) ) { 1643 case INTEGER_LITERAL: 1644 { 1645 alt11=1; 1646 } 1647 break; 1648 case LONG_LITERAL: 1649 { 1650 alt11=2; 1651 } 1652 break; 1653 case SHORT_LITERAL: 1654 { 1655 alt11=3; 1656 } 1657 break; 1658 case BYTE_LITERAL: 1659 { 1660 alt11=4; 1661 } 1662 break; 1663 case FLOAT_LITERAL: 1664 { 1665 alt11=5; 1666 } 1667 break; 1668 case DOUBLE_LITERAL: 1669 { 1670 alt11=6; 1671 } 1672 break; 1673 case CHAR_LITERAL: 1674 { 1675 alt11=7; 1676 } 1677 break; 1678 case BOOL_LITERAL: 1679 { 1680 alt11=8; 1681 } 1682 break; 1683 default: 1684 NoViableAltException nvae = 1685 new NoViableAltException("", 11, 0, input); 1686 throw nvae; 1687 } 1688 switch (alt11) { 1689 case 1 : 1690 // smaliTreeWalker.g:307:5: integer_literal 1691 { 1692 pushFollow(FOLLOW_integer_literal_in_fixed_64bit_literal665); 1693 integer_literal49=integer_literal(); 1694 state._fsp--; 1695 1696 value = integer_literal49; 1697 } 1698 break; 1699 case 2 : 1700 // smaliTreeWalker.g:308:5: long_literal 1701 { 1702 pushFollow(FOLLOW_long_literal_in_fixed_64bit_literal673); 1703 long_literal50=long_literal(); 1704 state._fsp--; 1705 1706 value = long_literal50; 1707 } 1708 break; 1709 case 3 : 1710 // smaliTreeWalker.g:309:5: short_literal 1711 { 1712 pushFollow(FOLLOW_short_literal_in_fixed_64bit_literal681); 1713 short_literal51=short_literal(); 1714 state._fsp--; 1715 1716 value = short_literal51; 1717 } 1718 break; 1719 case 4 : 1720 // smaliTreeWalker.g:310:5: byte_literal 1721 { 1722 pushFollow(FOLLOW_byte_literal_in_fixed_64bit_literal689); 1723 byte_literal52=byte_literal(); 1724 state._fsp--; 1725 1726 value = byte_literal52; 1727 } 1728 break; 1729 case 5 : 1730 // smaliTreeWalker.g:311:5: float_literal 1731 { 1732 pushFollow(FOLLOW_float_literal_in_fixed_64bit_literal697); 1733 float_literal53=float_literal(); 1734 state._fsp--; 1735 1736 value = Float.floatToRawIntBits(float_literal53); 1737 } 1738 break; 1739 case 6 : 1740 // smaliTreeWalker.g:312:5: double_literal 1741 { 1742 pushFollow(FOLLOW_double_literal_in_fixed_64bit_literal705); 1743 double_literal54=double_literal(); 1744 state._fsp--; 1745 1746 value = Double.doubleToRawLongBits(double_literal54); 1747 } 1748 break; 1749 case 7 : 1750 // smaliTreeWalker.g:313:5: char_literal 1751 { 1752 pushFollow(FOLLOW_char_literal_in_fixed_64bit_literal713); 1753 char_literal55=char_literal(); 1754 state._fsp--; 1755 1756 value = char_literal55; 1757 } 1758 break; 1759 case 8 : 1760 // smaliTreeWalker.g:314:5: bool_literal 1761 { 1762 pushFollow(FOLLOW_bool_literal_in_fixed_64bit_literal721); 1763 bool_literal56=bool_literal(); 1764 state._fsp--; 1765 1766 value = bool_literal56?1:0; 1767 } 1768 break; 1769 1770 } 1771 } 1772 catch (RecognitionException re) { 1773 reportError(re); 1774 recover(input,re); 1775 } 1776 finally { 1777 // do for sure before leaving 1778 } 1779 return value; 1780 } 1781 // $ANTLR end "fixed_64bit_literal" 1782 1783 1784 1785 // $ANTLR start "fixed_32bit_literal" 1786 // smaliTreeWalker.g:318:1: fixed_32bit_literal returns [int value] : ( integer_literal | long_literal | short_literal | byte_literal | float_literal | char_literal | bool_literal ); fixed_32bit_literal()1787 public final int fixed_32bit_literal() throws RecognitionException { 1788 int value = 0; 1789 1790 1791 int integer_literal57 =0; 1792 long long_literal58 =0; 1793 short short_literal59 =0; 1794 byte byte_literal60 =0; 1795 float float_literal61 =0.0f; 1796 char char_literal62 =0; 1797 boolean bool_literal63 =false; 1798 1799 try { 1800 // smaliTreeWalker.g:319:3: ( integer_literal | long_literal | short_literal | byte_literal | float_literal | char_literal | bool_literal ) 1801 int alt12=7; 1802 switch ( input.LA(1) ) { 1803 case INTEGER_LITERAL: 1804 { 1805 alt12=1; 1806 } 1807 break; 1808 case LONG_LITERAL: 1809 { 1810 alt12=2; 1811 } 1812 break; 1813 case SHORT_LITERAL: 1814 { 1815 alt12=3; 1816 } 1817 break; 1818 case BYTE_LITERAL: 1819 { 1820 alt12=4; 1821 } 1822 break; 1823 case FLOAT_LITERAL: 1824 { 1825 alt12=5; 1826 } 1827 break; 1828 case CHAR_LITERAL: 1829 { 1830 alt12=6; 1831 } 1832 break; 1833 case BOOL_LITERAL: 1834 { 1835 alt12=7; 1836 } 1837 break; 1838 default: 1839 NoViableAltException nvae = 1840 new NoViableAltException("", 12, 0, input); 1841 throw nvae; 1842 } 1843 switch (alt12) { 1844 case 1 : 1845 // smaliTreeWalker.g:319:5: integer_literal 1846 { 1847 pushFollow(FOLLOW_integer_literal_in_fixed_32bit_literal738); 1848 integer_literal57=integer_literal(); 1849 state._fsp--; 1850 1851 value = integer_literal57; 1852 } 1853 break; 1854 case 2 : 1855 // smaliTreeWalker.g:320:5: long_literal 1856 { 1857 pushFollow(FOLLOW_long_literal_in_fixed_32bit_literal746); 1858 long_literal58=long_literal(); 1859 state._fsp--; 1860 1861 LiteralTools.checkInt(long_literal58); value = (int)long_literal58; 1862 } 1863 break; 1864 case 3 : 1865 // smaliTreeWalker.g:321:5: short_literal 1866 { 1867 pushFollow(FOLLOW_short_literal_in_fixed_32bit_literal754); 1868 short_literal59=short_literal(); 1869 state._fsp--; 1870 1871 value = short_literal59; 1872 } 1873 break; 1874 case 4 : 1875 // smaliTreeWalker.g:322:5: byte_literal 1876 { 1877 pushFollow(FOLLOW_byte_literal_in_fixed_32bit_literal762); 1878 byte_literal60=byte_literal(); 1879 state._fsp--; 1880 1881 value = byte_literal60; 1882 } 1883 break; 1884 case 5 : 1885 // smaliTreeWalker.g:323:5: float_literal 1886 { 1887 pushFollow(FOLLOW_float_literal_in_fixed_32bit_literal770); 1888 float_literal61=float_literal(); 1889 state._fsp--; 1890 1891 value = Float.floatToRawIntBits(float_literal61); 1892 } 1893 break; 1894 case 6 : 1895 // smaliTreeWalker.g:324:5: char_literal 1896 { 1897 pushFollow(FOLLOW_char_literal_in_fixed_32bit_literal778); 1898 char_literal62=char_literal(); 1899 state._fsp--; 1900 1901 value = char_literal62; 1902 } 1903 break; 1904 case 7 : 1905 // smaliTreeWalker.g:325:5: bool_literal 1906 { 1907 pushFollow(FOLLOW_bool_literal_in_fixed_32bit_literal786); 1908 bool_literal63=bool_literal(); 1909 state._fsp--; 1910 1911 value = bool_literal63?1:0; 1912 } 1913 break; 1914 1915 } 1916 } 1917 catch (RecognitionException re) { 1918 reportError(re); 1919 recover(input,re); 1920 } 1921 finally { 1922 // do for sure before leaving 1923 } 1924 return value; 1925 } 1926 // $ANTLR end "fixed_32bit_literal" 1927 1928 1929 1930 // $ANTLR start "array_elements" 1931 // smaliTreeWalker.g:327:1: array_elements returns [List<Number> elements] : ^( I_ARRAY_ELEMENTS ( fixed_64bit_literal_number )* ) ; array_elements()1932 public final List<Number> array_elements() throws RecognitionException { 1933 List<Number> elements = null; 1934 1935 1936 Number fixed_64bit_literal_number64 =null; 1937 1938 try { 1939 // smaliTreeWalker.g:328:3: ( ^( I_ARRAY_ELEMENTS ( fixed_64bit_literal_number )* ) ) 1940 // smaliTreeWalker.g:328:5: ^( I_ARRAY_ELEMENTS ( fixed_64bit_literal_number )* ) 1941 { 1942 elements = Lists.newArrayList(); 1943 match(input,I_ARRAY_ELEMENTS,FOLLOW_I_ARRAY_ELEMENTS_in_array_elements808); 1944 if ( input.LA(1)==Token.DOWN ) { 1945 match(input, Token.DOWN, null); 1946 // smaliTreeWalker.g:330:7: ( fixed_64bit_literal_number )* 1947 loop13: 1948 while (true) { 1949 int alt13=2; 1950 int LA13_0 = input.LA(1); 1951 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) ) { 1952 alt13=1; 1953 } 1954 1955 switch (alt13) { 1956 case 1 : 1957 // smaliTreeWalker.g:330:8: fixed_64bit_literal_number 1958 { 1959 pushFollow(FOLLOW_fixed_64bit_literal_number_in_array_elements817); 1960 fixed_64bit_literal_number64=fixed_64bit_literal_number(); 1961 state._fsp--; 1962 1963 1964 elements.add(fixed_64bit_literal_number64); 1965 1966 } 1967 break; 1968 1969 default : 1970 break loop13; 1971 } 1972 } 1973 1974 match(input, Token.UP, null); 1975 } 1976 1977 } 1978 1979 } 1980 catch (RecognitionException re) { 1981 reportError(re); 1982 recover(input,re); 1983 } 1984 finally { 1985 // do for sure before leaving 1986 } 1987 return elements; 1988 } 1989 // $ANTLR end "array_elements" 1990 1991 1992 1993 // $ANTLR start "packed_switch_elements" 1994 // smaliTreeWalker.g:335:1: packed_switch_elements returns [List<Label> elements] : ^( I_PACKED_SWITCH_ELEMENTS ( label_ref )* ) ; packed_switch_elements()1995 public final List<Label> packed_switch_elements() throws RecognitionException { 1996 List<Label> elements = null; 1997 1998 1999 Label label_ref65 =null; 2000 2001 elements = Lists.newArrayList(); 2002 try { 2003 // smaliTreeWalker.g:337:3: ( ^( I_PACKED_SWITCH_ELEMENTS ( label_ref )* ) ) 2004 // smaliTreeWalker.g:338:5: ^( I_PACKED_SWITCH_ELEMENTS ( label_ref )* ) 2005 { 2006 match(input,I_PACKED_SWITCH_ELEMENTS,FOLLOW_I_PACKED_SWITCH_ELEMENTS_in_packed_switch_elements853); 2007 if ( input.LA(1)==Token.DOWN ) { 2008 match(input, Token.DOWN, null); 2009 // smaliTreeWalker.g:339:7: ( label_ref )* 2010 loop14: 2011 while (true) { 2012 int alt14=2; 2013 int LA14_0 = input.LA(1); 2014 if ( (LA14_0==SIMPLE_NAME) ) { 2015 alt14=1; 2016 } 2017 2018 switch (alt14) { 2019 case 1 : 2020 // smaliTreeWalker.g:339:8: label_ref 2021 { 2022 pushFollow(FOLLOW_label_ref_in_packed_switch_elements862); 2023 label_ref65=label_ref(); 2024 state._fsp--; 2025 2026 elements.add(label_ref65); 2027 } 2028 break; 2029 2030 default : 2031 break loop14; 2032 } 2033 } 2034 2035 match(input, Token.UP, null); 2036 } 2037 2038 } 2039 2040 } 2041 catch (RecognitionException re) { 2042 reportError(re); 2043 recover(input,re); 2044 } 2045 finally { 2046 // do for sure before leaving 2047 } 2048 return elements; 2049 } 2050 // $ANTLR end "packed_switch_elements" 2051 2052 2053 2054 // $ANTLR start "sparse_switch_elements" 2055 // smaliTreeWalker.g:342:1: sparse_switch_elements returns [List<SwitchLabelElement> elements] : ^( I_SPARSE_SWITCH_ELEMENTS ( fixed_32bit_literal label_ref )* ) ; sparse_switch_elements()2056 public final List<SwitchLabelElement> sparse_switch_elements() throws RecognitionException { 2057 List<SwitchLabelElement> elements = null; 2058 2059 2060 int fixed_32bit_literal66 =0; 2061 Label label_ref67 =null; 2062 2063 elements = Lists.newArrayList(); 2064 try { 2065 // smaliTreeWalker.g:344:3: ( ^( I_SPARSE_SWITCH_ELEMENTS ( fixed_32bit_literal label_ref )* ) ) 2066 // smaliTreeWalker.g:345:5: ^( I_SPARSE_SWITCH_ELEMENTS ( fixed_32bit_literal label_ref )* ) 2067 { 2068 match(input,I_SPARSE_SWITCH_ELEMENTS,FOLLOW_I_SPARSE_SWITCH_ELEMENTS_in_sparse_switch_elements897); 2069 if ( input.LA(1)==Token.DOWN ) { 2070 match(input, Token.DOWN, null); 2071 // smaliTreeWalker.g:346:8: ( fixed_32bit_literal label_ref )* 2072 loop15: 2073 while (true) { 2074 int alt15=2; 2075 int LA15_0 = input.LA(1); 2076 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) ) { 2077 alt15=1; 2078 } 2079 2080 switch (alt15) { 2081 case 1 : 2082 // smaliTreeWalker.g:346:9: fixed_32bit_literal label_ref 2083 { 2084 pushFollow(FOLLOW_fixed_32bit_literal_in_sparse_switch_elements907); 2085 fixed_32bit_literal66=fixed_32bit_literal(); 2086 state._fsp--; 2087 2088 pushFollow(FOLLOW_label_ref_in_sparse_switch_elements909); 2089 label_ref67=label_ref(); 2090 state._fsp--; 2091 2092 2093 elements.add(new SwitchLabelElement(fixed_32bit_literal66, label_ref67)); 2094 2095 } 2096 break; 2097 2098 default : 2099 break loop15; 2100 } 2101 } 2102 2103 match(input, Token.UP, null); 2104 } 2105 2106 } 2107 2108 } 2109 catch (RecognitionException re) { 2110 reportError(re); 2111 recover(input,re); 2112 } 2113 finally { 2114 // do for sure before leaving 2115 } 2116 return elements; 2117 } 2118 // $ANTLR end "sparse_switch_elements" 2119 2120 2121 protected static class method_scope { 2122 boolean isStatic; 2123 int totalMethodRegisters; 2124 int methodParameterRegisters; 2125 MethodImplementationBuilder methodBuilder; 2126 } 2127 protected Stack<method_scope> method_stack = new Stack<method_scope>(); 2128 2129 2130 // $ANTLR start "method" 2131 // smaliTreeWalker.g:352: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 ) ; method()2132 public final BuilderMethod method() throws RecognitionException { 2133 method_stack.push(new method_scope()); 2134 BuilderMethod ret = null; 2135 2136 2137 CommonTree I_METHOD72=null; 2138 int access_list68 =0; 2139 TreeRuleReturnScope method_name_and_prototype69 =null; 2140 TreeRuleReturnScope registers_directive70 =null; 2141 List<BuilderTryBlock> catches71 =null; 2142 Set<Annotation> annotations73 =null; 2143 2144 2145 method_stack.peek().totalMethodRegisters = 0; 2146 method_stack.peek().methodParameterRegisters = 0; 2147 int accessFlags = 0; 2148 method_stack.peek().isStatic = false; 2149 2150 try { 2151 // smaliTreeWalker.g:367:3: ( ^( I_METHOD method_name_and_prototype access_list ( ( registers_directive ) |) ordered_method_items catches parameters[$method_name_and_prototype.parameters] annotations ) ) 2152 // smaliTreeWalker.g:368:5: ^( I_METHOD method_name_and_prototype access_list ( ( registers_directive ) |) ordered_method_items catches parameters[$method_name_and_prototype.parameters] annotations ) 2153 { 2154 I_METHOD72=(CommonTree)match(input,I_METHOD,FOLLOW_I_METHOD_in_method961); 2155 match(input, Token.DOWN, null); 2156 pushFollow(FOLLOW_method_name_and_prototype_in_method969); 2157 method_name_and_prototype69=method_name_and_prototype(); 2158 state._fsp--; 2159 2160 pushFollow(FOLLOW_access_list_in_method977); 2161 access_list68=access_list(); 2162 state._fsp--; 2163 2164 2165 accessFlags = access_list68; 2166 method_stack.peek().isStatic = AccessFlags.STATIC.isSet(accessFlags); 2167 method_stack.peek().methodParameterRegisters = 2168 MethodUtil.getParameterRegisterCount((method_name_and_prototype69!=null?((smaliTreeWalker.method_name_and_prototype_return)method_name_and_prototype69).parameters:null), method_stack.peek().isStatic); 2169 2170 // smaliTreeWalker.g:377:7: ( ( registers_directive ) |) 2171 int alt16=2; 2172 int LA16_0 = input.LA(1); 2173 if ( (LA16_0==I_LOCALS||LA16_0==I_REGISTERS) ) { 2174 alt16=1; 2175 } 2176 else if ( (LA16_0==I_ORDERED_METHOD_ITEMS) ) { 2177 alt16=2; 2178 } 2179 2180 else { 2181 NoViableAltException nvae = 2182 new NoViableAltException("", 16, 0, input); 2183 throw nvae; 2184 } 2185 2186 switch (alt16) { 2187 case 1 : 2188 // smaliTreeWalker.g:378:9: ( registers_directive ) 2189 { 2190 // smaliTreeWalker.g:378:9: ( registers_directive ) 2191 // smaliTreeWalker.g:378:10: registers_directive 2192 { 2193 pushFollow(FOLLOW_registers_directive_in_method1004); 2194 registers_directive70=registers_directive(); 2195 state._fsp--; 2196 2197 2198 if ((registers_directive70!=null?((smaliTreeWalker.registers_directive_return)registers_directive70).isLocalsDirective:false)) { 2199 method_stack.peek().totalMethodRegisters = (registers_directive70!=null?((smaliTreeWalker.registers_directive_return)registers_directive70).registers:0) + method_stack.peek().methodParameterRegisters; 2200 } else { 2201 method_stack.peek().totalMethodRegisters = (registers_directive70!=null?((smaliTreeWalker.registers_directive_return)registers_directive70).registers:0); 2202 } 2203 2204 method_stack.peek().methodBuilder = new MethodImplementationBuilder(method_stack.peek().totalMethodRegisters); 2205 2206 2207 } 2208 2209 } 2210 break; 2211 case 2 : 2212 // smaliTreeWalker.g:391:9: 2213 { 2214 2215 method_stack.peek().methodBuilder = new MethodImplementationBuilder(0); 2216 2217 } 2218 break; 2219 2220 } 2221 2222 pushFollow(FOLLOW_ordered_method_items_in_method1061); 2223 ordered_method_items(); 2224 state._fsp--; 2225 2226 pushFollow(FOLLOW_catches_in_method1069); 2227 catches71=catches(); 2228 state._fsp--; 2229 2230 pushFollow(FOLLOW_parameters_in_method1077); 2231 parameters((method_name_and_prototype69!=null?((smaliTreeWalker.method_name_and_prototype_return)method_name_and_prototype69).parameters:null)); 2232 state._fsp--; 2233 2234 pushFollow(FOLLOW_annotations_in_method1086); 2235 annotations73=annotations(); 2236 state._fsp--; 2237 2238 match(input, Token.UP, null); 2239 2240 2241 MethodImplementation methodImplementation = null; 2242 List<BuilderTryBlock> tryBlocks = catches71; 2243 2244 boolean isAbstract = false; 2245 boolean isNative = false; 2246 2247 if ((accessFlags & AccessFlags.ABSTRACT.getValue()) != 0) { 2248 isAbstract = true; 2249 } else if ((accessFlags & AccessFlags.NATIVE.getValue()) != 0) { 2250 isNative = true; 2251 } 2252 2253 methodImplementation = method_stack.peek().methodBuilder.getMethodImplementation(); 2254 2255 if (Iterables.isEmpty(methodImplementation.getInstructions())) { 2256 if (!isAbstract && !isNative) { 2257 throw new SemanticException(input, I_METHOD72, "A non-abstract/non-native method must have at least 1 instruction"); 2258 } 2259 2260 String methodType; 2261 if (isAbstract) { 2262 methodType = "an abstract"; 2263 } else { 2264 methodType = "a native"; 2265 } 2266 2267 if ((registers_directive70!=null?((CommonTree)registers_directive70.start):null) != null) { 2268 if ((registers_directive70!=null?((smaliTreeWalker.registers_directive_return)registers_directive70).isLocalsDirective:false)) { 2269 throw new SemanticException(input, (registers_directive70!=null?((CommonTree)registers_directive70.start):null), "A .locals directive is not valid in %s method", methodType); 2270 } else { 2271 throw new SemanticException(input, (registers_directive70!=null?((CommonTree)registers_directive70.start):null), "A .registers directive is not valid in %s method", methodType); 2272 } 2273 } 2274 2275 if (methodImplementation.getTryBlocks().size() > 0) { 2276 throw new SemanticException(input, I_METHOD72, "try/catch blocks cannot be present in %s method", methodType); 2277 } 2278 2279 if (!Iterables.isEmpty(methodImplementation.getDebugItems())) { 2280 throw new SemanticException(input, I_METHOD72, "debug directives cannot be present in %s method", methodType); 2281 } 2282 2283 methodImplementation = null; 2284 } else { 2285 if (isAbstract) { 2286 throw new SemanticException(input, I_METHOD72, "An abstract method cannot have any instructions"); 2287 } 2288 if (isNative) { 2289 throw new SemanticException(input, I_METHOD72, "A native method cannot have any instructions"); 2290 } 2291 2292 if ((registers_directive70!=null?((CommonTree)registers_directive70.start):null) == null) { 2293 throw new SemanticException(input, I_METHOD72, "A .registers or .locals directive must be present for a non-abstract/non-final method"); 2294 } 2295 2296 if (method_stack.peek().totalMethodRegisters < method_stack.peek().methodParameterRegisters) { 2297 throw new SemanticException(input, (registers_directive70!=null?((CommonTree)registers_directive70.start):null), "This method requires at least " + 2298 Integer.toString(method_stack.peek().methodParameterRegisters) + 2299 " registers, for the method parameters"); 2300 } 2301 } 2302 2303 ret = dexBuilder.internMethod( 2304 classType, 2305 (method_name_and_prototype69!=null?((smaliTreeWalker.method_name_and_prototype_return)method_name_and_prototype69).name:null), 2306 (method_name_and_prototype69!=null?((smaliTreeWalker.method_name_and_prototype_return)method_name_and_prototype69).parameters:null), 2307 (method_name_and_prototype69!=null?((smaliTreeWalker.method_name_and_prototype_return)method_name_and_prototype69).returnType:null), 2308 accessFlags, 2309 annotations73, 2310 methodImplementation); 2311 2312 } 2313 2314 } 2315 catch (RecognitionException re) { 2316 reportError(re); 2317 recover(input,re); 2318 } 2319 finally { 2320 // do for sure before leaving 2321 method_stack.pop(); 2322 } 2323 return ret; 2324 } 2325 // $ANTLR end "method" 2326 2327 2328 2329 // $ANTLR start "method_prototype" 2330 // smaliTreeWalker.g:473:1: method_prototype returns [ImmutableMethodProtoReference proto] : ^( I_METHOD_PROTOTYPE ^( I_METHOD_RETURN_TYPE type_descriptor ) method_type_list ) ; method_prototype()2331 public final ImmutableMethodProtoReference method_prototype() throws RecognitionException { 2332 ImmutableMethodProtoReference proto = null; 2333 2334 2335 String type_descriptor74 =null; 2336 List<String> method_type_list75 =null; 2337 2338 try { 2339 // smaliTreeWalker.g:474:3: ( ^( I_METHOD_PROTOTYPE ^( I_METHOD_RETURN_TYPE type_descriptor ) method_type_list ) ) 2340 // smaliTreeWalker.g:474:5: ^( I_METHOD_PROTOTYPE ^( I_METHOD_RETURN_TYPE type_descriptor ) method_type_list ) 2341 { 2342 match(input,I_METHOD_PROTOTYPE,FOLLOW_I_METHOD_PROTOTYPE_in_method_prototype1110); 2343 match(input, Token.DOWN, null); 2344 match(input,I_METHOD_RETURN_TYPE,FOLLOW_I_METHOD_RETURN_TYPE_in_method_prototype1113); 2345 match(input, Token.DOWN, null); 2346 pushFollow(FOLLOW_type_descriptor_in_method_prototype1115); 2347 type_descriptor74=type_descriptor(); 2348 state._fsp--; 2349 2350 match(input, Token.UP, null); 2351 2352 pushFollow(FOLLOW_method_type_list_in_method_prototype1118); 2353 method_type_list75=method_type_list(); 2354 state._fsp--; 2355 2356 match(input, Token.UP, null); 2357 2358 2359 String returnType = type_descriptor74; 2360 List<String> parameters = method_type_list75; 2361 proto = new ImmutableMethodProtoReference(parameters, returnType); 2362 2363 } 2364 2365 } 2366 catch (RecognitionException re) { 2367 reportError(re); 2368 recover(input,re); 2369 } 2370 finally { 2371 // do for sure before leaving 2372 } 2373 return proto; 2374 } 2375 // $ANTLR end "method_prototype" 2376 2377 2378 public static class method_name_and_prototype_return extends TreeRuleReturnScope { 2379 public String name; 2380 public List<SmaliMethodParameter> parameters; 2381 public String returnType; 2382 }; 2383 2384 2385 // $ANTLR start "method_name_and_prototype" 2386 // smaliTreeWalker.g:481:1: method_name_and_prototype returns [String name, List<SmaliMethodParameter> parameters, String returnType] : SIMPLE_NAME method_prototype ; method_name_and_prototype()2387 public final smaliTreeWalker.method_name_and_prototype_return method_name_and_prototype() throws RecognitionException { 2388 smaliTreeWalker.method_name_and_prototype_return retval = new smaliTreeWalker.method_name_and_prototype_return(); 2389 retval.start = input.LT(1); 2390 2391 CommonTree SIMPLE_NAME76=null; 2392 ImmutableMethodProtoReference method_prototype77 =null; 2393 2394 try { 2395 // smaliTreeWalker.g:482:3: ( SIMPLE_NAME method_prototype ) 2396 // smaliTreeWalker.g:482:5: SIMPLE_NAME method_prototype 2397 { 2398 SIMPLE_NAME76=(CommonTree)match(input,SIMPLE_NAME,FOLLOW_SIMPLE_NAME_in_method_name_and_prototype1136); 2399 pushFollow(FOLLOW_method_prototype_in_method_name_and_prototype1138); 2400 method_prototype77=method_prototype(); 2401 state._fsp--; 2402 2403 2404 retval.name = (SIMPLE_NAME76!=null?SIMPLE_NAME76.getText():null); 2405 retval.parameters = Lists.newArrayList(); 2406 2407 int paramRegister = 0; 2408 for (CharSequence type: method_prototype77.getParameterTypes()) { 2409 retval.parameters.add(new SmaliMethodParameter(paramRegister++, type.toString())); 2410 char c = type.charAt(0); 2411 if (c == 'D' || c == 'J') { 2412 paramRegister++; 2413 } 2414 } 2415 retval.returnType = method_prototype77.getReturnType(); 2416 2417 } 2418 2419 } 2420 catch (RecognitionException re) { 2421 reportError(re); 2422 recover(input,re); 2423 } 2424 finally { 2425 // do for sure before leaving 2426 } 2427 return retval; 2428 } 2429 // $ANTLR end "method_name_and_prototype" 2430 2431 2432 2433 // $ANTLR start "method_type_list" 2434 // smaliTreeWalker.g:498:1: method_type_list returns [List<String> types] : ( nonvoid_type_descriptor )* ; method_type_list()2435 public final List<String> method_type_list() throws RecognitionException { 2436 List<String> types = null; 2437 2438 2439 TreeRuleReturnScope nonvoid_type_descriptor78 =null; 2440 2441 2442 types = Lists.newArrayList(); 2443 2444 try { 2445 // smaliTreeWalker.g:503:3: ( ( nonvoid_type_descriptor )* ) 2446 // smaliTreeWalker.g:503:5: ( nonvoid_type_descriptor )* 2447 { 2448 // smaliTreeWalker.g:503:5: ( nonvoid_type_descriptor )* 2449 loop17: 2450 while (true) { 2451 int alt17=2; 2452 int LA17_0 = input.LA(1); 2453 if ( (LA17_0==ARRAY_TYPE_PREFIX||LA17_0==CLASS_DESCRIPTOR||LA17_0==PRIMITIVE_TYPE) ) { 2454 alt17=1; 2455 } 2456 2457 switch (alt17) { 2458 case 1 : 2459 // smaliTreeWalker.g:504:7: nonvoid_type_descriptor 2460 { 2461 pushFollow(FOLLOW_nonvoid_type_descriptor_in_method_type_list1172); 2462 nonvoid_type_descriptor78=nonvoid_type_descriptor(); 2463 state._fsp--; 2464 2465 2466 types.add((nonvoid_type_descriptor78!=null?((smaliTreeWalker.nonvoid_type_descriptor_return)nonvoid_type_descriptor78).type:null)); 2467 2468 } 2469 break; 2470 2471 default : 2472 break loop17; 2473 } 2474 } 2475 2476 } 2477 2478 } 2479 catch (RecognitionException re) { 2480 reportError(re); 2481 recover(input,re); 2482 } 2483 finally { 2484 // do for sure before leaving 2485 } 2486 return types; 2487 } 2488 // $ANTLR end "method_type_list" 2489 2490 2491 2492 // $ANTLR start "call_site_reference" 2493 // smaliTreeWalker.g:510:1: call_site_reference returns [ImmutableCallSiteReference callSiteReference] : ^( I_CALL_SITE_REFERENCE call_site_name= SIMPLE_NAME method_name= string_literal method_prototype call_site_extra_arguments method_reference ) ; call_site_reference()2494 public final ImmutableCallSiteReference call_site_reference() throws RecognitionException { 2495 ImmutableCallSiteReference callSiteReference = null; 2496 2497 2498 CommonTree call_site_name=null; 2499 String method_name =null; 2500 ImmutableMethodReference method_reference79 =null; 2501 ImmutableMethodProtoReference method_prototype80 =null; 2502 List<ImmutableEncodedValue> call_site_extra_arguments81 =null; 2503 2504 try { 2505 // smaliTreeWalker.g:511:3: ( ^( I_CALL_SITE_REFERENCE call_site_name= SIMPLE_NAME method_name= string_literal method_prototype call_site_extra_arguments method_reference ) ) 2506 // smaliTreeWalker.g:512:3: ^( I_CALL_SITE_REFERENCE call_site_name= SIMPLE_NAME method_name= string_literal method_prototype call_site_extra_arguments method_reference ) 2507 { 2508 match(input,I_CALL_SITE_REFERENCE,FOLLOW_I_CALL_SITE_REFERENCE_in_call_site_reference1203); 2509 match(input, Token.DOWN, null); 2510 call_site_name=(CommonTree)match(input,SIMPLE_NAME,FOLLOW_SIMPLE_NAME_in_call_site_reference1207); 2511 pushFollow(FOLLOW_string_literal_in_call_site_reference1211); 2512 method_name=string_literal(); 2513 state._fsp--; 2514 2515 pushFollow(FOLLOW_method_prototype_in_call_site_reference1213); 2516 method_prototype80=method_prototype(); 2517 state._fsp--; 2518 2519 pushFollow(FOLLOW_call_site_extra_arguments_in_call_site_reference1223); 2520 call_site_extra_arguments81=call_site_extra_arguments(); 2521 state._fsp--; 2522 2523 pushFollow(FOLLOW_method_reference_in_call_site_reference1225); 2524 method_reference79=method_reference(); 2525 state._fsp--; 2526 2527 match(input, Token.UP, null); 2528 2529 2530 String callSiteName = (call_site_name!=null?call_site_name.getText():null); 2531 ImmutableMethodHandleReference methodHandleReference = 2532 new ImmutableMethodHandleReference(MethodHandleType.INVOKE_STATIC, 2533 method_reference79); 2534 callSiteReference = new ImmutableCallSiteReference( 2535 callSiteName, methodHandleReference, method_name, method_prototype80, 2536 call_site_extra_arguments81); 2537 2538 } 2539 2540 } 2541 catch (RecognitionException re) { 2542 reportError(re); 2543 recover(input,re); 2544 } 2545 finally { 2546 // do for sure before leaving 2547 } 2548 return callSiteReference; 2549 } 2550 // $ANTLR end "call_site_reference" 2551 2552 2553 public static class method_handle_type_return extends TreeRuleReturnScope { 2554 public int methodHandleType; 2555 }; 2556 2557 2558 // $ANTLR start "method_handle_type" 2559 // smaliTreeWalker.g:524:1: method_handle_type returns [int methodHandleType] : ( METHOD_HANDLE_TYPE_FIELD | METHOD_HANDLE_TYPE_METHOD | INSTRUCTION_FORMAT35c_METHOD_OR_METHOD_HANDLE_TYPE ) ; method_handle_type()2560 public final smaliTreeWalker.method_handle_type_return method_handle_type() throws RecognitionException { 2561 smaliTreeWalker.method_handle_type_return retval = new smaliTreeWalker.method_handle_type_return(); 2562 retval.start = input.LT(1); 2563 2564 try { 2565 // smaliTreeWalker.g:525:3: ( ( METHOD_HANDLE_TYPE_FIELD | METHOD_HANDLE_TYPE_METHOD | INSTRUCTION_FORMAT35c_METHOD_OR_METHOD_HANDLE_TYPE ) ) 2566 // smaliTreeWalker.g:525:5: ( METHOD_HANDLE_TYPE_FIELD | METHOD_HANDLE_TYPE_METHOD | INSTRUCTION_FORMAT35c_METHOD_OR_METHOD_HANDLE_TYPE ) 2567 { 2568 if ( input.LA(1)==INSTRUCTION_FORMAT35c_METHOD_OR_METHOD_HANDLE_TYPE||(input.LA(1) >= METHOD_HANDLE_TYPE_FIELD && input.LA(1) <= METHOD_HANDLE_TYPE_METHOD) ) { 2569 input.consume(); 2570 state.errorRecovery=false; 2571 } 2572 else { 2573 MismatchedSetException mse = new MismatchedSetException(null,input); 2574 throw mse; 2575 } 2576 2577 retval.methodHandleType = MethodHandleType.getMethodHandleType(input.getTokenStream().toString(input.getTreeAdaptor().getTokenStartIndex(retval.start),input.getTreeAdaptor().getTokenStopIndex(retval.start))); 2578 2579 } 2580 2581 } 2582 catch (RecognitionException re) { 2583 reportError(re); 2584 recover(input,re); 2585 } 2586 finally { 2587 // do for sure before leaving 2588 } 2589 return retval; 2590 } 2591 // $ANTLR end "method_handle_type" 2592 2593 2594 2595 // $ANTLR start "method_handle_reference" 2596 // smaliTreeWalker.g:529:1: method_handle_reference returns [ImmutableMethodHandleReference methodHandle] : method_handle_type ( field_reference | method_reference ) ; method_handle_reference()2597 public final ImmutableMethodHandleReference method_handle_reference() throws RecognitionException { 2598 ImmutableMethodHandleReference methodHandle = null; 2599 2600 2601 TreeRuleReturnScope field_reference82 =null; 2602 ImmutableMethodReference method_reference83 =null; 2603 TreeRuleReturnScope method_handle_type84 =null; 2604 2605 try { 2606 // smaliTreeWalker.g:530:3: ( method_handle_type ( field_reference | method_reference ) ) 2607 // smaliTreeWalker.g:530:5: method_handle_type ( field_reference | method_reference ) 2608 { 2609 pushFollow(FOLLOW_method_handle_type_in_method_handle_reference1270); 2610 method_handle_type84=method_handle_type(); 2611 state._fsp--; 2612 2613 // smaliTreeWalker.g:530:24: ( field_reference | method_reference ) 2614 int alt18=2; 2615 switch ( input.LA(1) ) { 2616 case CLASS_DESCRIPTOR: 2617 { 2618 int LA18_1 = input.LA(2); 2619 if ( (LA18_1==SIMPLE_NAME) ) { 2620 int LA18_3 = input.LA(3); 2621 if ( (LA18_3==ARRAY_TYPE_PREFIX||LA18_3==CLASS_DESCRIPTOR||LA18_3==PRIMITIVE_TYPE) ) { 2622 alt18=1; 2623 } 2624 else if ( (LA18_3==I_METHOD_PROTOTYPE) ) { 2625 alt18=2; 2626 } 2627 2628 else { 2629 int nvaeMark = input.mark(); 2630 try { 2631 for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) { 2632 input.consume(); 2633 } 2634 NoViableAltException nvae = 2635 new NoViableAltException("", 18, 3, input); 2636 throw nvae; 2637 } finally { 2638 input.rewind(nvaeMark); 2639 } 2640 } 2641 2642 } 2643 2644 else { 2645 int nvaeMark = input.mark(); 2646 try { 2647 input.consume(); 2648 NoViableAltException nvae = 2649 new NoViableAltException("", 18, 1, input); 2650 throw nvae; 2651 } finally { 2652 input.rewind(nvaeMark); 2653 } 2654 } 2655 2656 } 2657 break; 2658 case ARRAY_TYPE_PREFIX: 2659 { 2660 int LA18_2 = input.LA(2); 2661 if ( (LA18_2==PRIMITIVE_TYPE) ) { 2662 int LA18_4 = input.LA(3); 2663 if ( (LA18_4==SIMPLE_NAME) ) { 2664 int LA18_3 = input.LA(4); 2665 if ( (LA18_3==ARRAY_TYPE_PREFIX||LA18_3==CLASS_DESCRIPTOR||LA18_3==PRIMITIVE_TYPE) ) { 2666 alt18=1; 2667 } 2668 else if ( (LA18_3==I_METHOD_PROTOTYPE) ) { 2669 alt18=2; 2670 } 2671 2672 else { 2673 int nvaeMark = input.mark(); 2674 try { 2675 for (int nvaeConsume = 0; nvaeConsume < 4 - 1; nvaeConsume++) { 2676 input.consume(); 2677 } 2678 NoViableAltException nvae = 2679 new NoViableAltException("", 18, 3, input); 2680 throw nvae; 2681 } finally { 2682 input.rewind(nvaeMark); 2683 } 2684 } 2685 2686 } 2687 2688 else { 2689 int nvaeMark = input.mark(); 2690 try { 2691 for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) { 2692 input.consume(); 2693 } 2694 NoViableAltException nvae = 2695 new NoViableAltException("", 18, 4, input); 2696 throw nvae; 2697 } finally { 2698 input.rewind(nvaeMark); 2699 } 2700 } 2701 2702 } 2703 else if ( (LA18_2==CLASS_DESCRIPTOR) ) { 2704 int LA18_5 = input.LA(3); 2705 if ( (LA18_5==SIMPLE_NAME) ) { 2706 int LA18_3 = input.LA(4); 2707 if ( (LA18_3==ARRAY_TYPE_PREFIX||LA18_3==CLASS_DESCRIPTOR||LA18_3==PRIMITIVE_TYPE) ) { 2708 alt18=1; 2709 } 2710 else if ( (LA18_3==I_METHOD_PROTOTYPE) ) { 2711 alt18=2; 2712 } 2713 2714 else { 2715 int nvaeMark = input.mark(); 2716 try { 2717 for (int nvaeConsume = 0; nvaeConsume < 4 - 1; nvaeConsume++) { 2718 input.consume(); 2719 } 2720 NoViableAltException nvae = 2721 new NoViableAltException("", 18, 3, input); 2722 throw nvae; 2723 } finally { 2724 input.rewind(nvaeMark); 2725 } 2726 } 2727 2728 } 2729 2730 else { 2731 int nvaeMark = input.mark(); 2732 try { 2733 for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) { 2734 input.consume(); 2735 } 2736 NoViableAltException nvae = 2737 new NoViableAltException("", 18, 5, input); 2738 throw nvae; 2739 } finally { 2740 input.rewind(nvaeMark); 2741 } 2742 } 2743 2744 } 2745 2746 else { 2747 int nvaeMark = input.mark(); 2748 try { 2749 input.consume(); 2750 NoViableAltException nvae = 2751 new NoViableAltException("", 18, 2, input); 2752 throw nvae; 2753 } finally { 2754 input.rewind(nvaeMark); 2755 } 2756 } 2757 2758 } 2759 break; 2760 case SIMPLE_NAME: 2761 { 2762 int LA18_3 = input.LA(2); 2763 if ( (LA18_3==ARRAY_TYPE_PREFIX||LA18_3==CLASS_DESCRIPTOR||LA18_3==PRIMITIVE_TYPE) ) { 2764 alt18=1; 2765 } 2766 else if ( (LA18_3==I_METHOD_PROTOTYPE) ) { 2767 alt18=2; 2768 } 2769 2770 else { 2771 int nvaeMark = input.mark(); 2772 try { 2773 input.consume(); 2774 NoViableAltException nvae = 2775 new NoViableAltException("", 18, 3, input); 2776 throw nvae; 2777 } finally { 2778 input.rewind(nvaeMark); 2779 } 2780 } 2781 2782 } 2783 break; 2784 default: 2785 NoViableAltException nvae = 2786 new NoViableAltException("", 18, 0, input); 2787 throw nvae; 2788 } 2789 switch (alt18) { 2790 case 1 : 2791 // smaliTreeWalker.g:530:25: field_reference 2792 { 2793 pushFollow(FOLLOW_field_reference_in_method_handle_reference1273); 2794 field_reference82=field_reference(); 2795 state._fsp--; 2796 2797 } 2798 break; 2799 case 2 : 2800 // smaliTreeWalker.g:530:43: method_reference 2801 { 2802 pushFollow(FOLLOW_method_reference_in_method_handle_reference1277); 2803 method_reference83=method_reference(); 2804 state._fsp--; 2805 2806 } 2807 break; 2808 2809 } 2810 2811 2812 ImmutableReference reference; 2813 if ((field_reference82!=null?(input.getTokenStream().toString(input.getTreeAdaptor().getTokenStartIndex(field_reference82.start),input.getTreeAdaptor().getTokenStopIndex(field_reference82.start))):null) != null) { 2814 reference = (field_reference82!=null?((smaliTreeWalker.field_reference_return)field_reference82).fieldReference:null); 2815 } else { 2816 reference = method_reference83; 2817 } 2818 methodHandle = new ImmutableMethodHandleReference((method_handle_type84!=null?((smaliTreeWalker.method_handle_type_return)method_handle_type84).methodHandleType:0), reference); 2819 2820 } 2821 2822 } 2823 catch (RecognitionException re) { 2824 reportError(re); 2825 recover(input,re); 2826 } 2827 finally { 2828 // do for sure before leaving 2829 } 2830 return methodHandle; 2831 } 2832 // $ANTLR end "method_handle_reference" 2833 2834 2835 2836 // $ANTLR start "method_handle_literal" 2837 // smaliTreeWalker.g:540:1: method_handle_literal returns [ImmutableMethodHandleReference value] : ( I_ENCODED_METHOD_HANDLE method_handle_reference ) ; method_handle_literal()2838 public final ImmutableMethodHandleReference method_handle_literal() throws RecognitionException { 2839 ImmutableMethodHandleReference value = null; 2840 2841 2842 ImmutableMethodHandleReference method_handle_reference85 =null; 2843 2844 try { 2845 // smaliTreeWalker.g:541:3: ( ( I_ENCODED_METHOD_HANDLE method_handle_reference ) ) 2846 // smaliTreeWalker.g:541:5: ( I_ENCODED_METHOD_HANDLE method_handle_reference ) 2847 { 2848 // smaliTreeWalker.g:541:5: ( I_ENCODED_METHOD_HANDLE method_handle_reference ) 2849 // smaliTreeWalker.g:541:6: I_ENCODED_METHOD_HANDLE method_handle_reference 2850 { 2851 match(input,I_ENCODED_METHOD_HANDLE,FOLLOW_I_ENCODED_METHOD_HANDLE_in_method_handle_literal1294); 2852 pushFollow(FOLLOW_method_handle_reference_in_method_handle_literal1296); 2853 method_handle_reference85=method_handle_reference(); 2854 state._fsp--; 2855 2856 } 2857 2858 2859 value = method_handle_reference85; 2860 2861 } 2862 2863 } 2864 catch (RecognitionException re) { 2865 reportError(re); 2866 recover(input,re); 2867 } 2868 finally { 2869 // do for sure before leaving 2870 } 2871 return value; 2872 } 2873 // $ANTLR end "method_handle_literal" 2874 2875 2876 2877 // $ANTLR start "method_reference" 2878 // smaliTreeWalker.g:545:1: method_reference returns [ImmutableMethodReference methodReference] : ( reference_type_descriptor )? SIMPLE_NAME method_prototype ; method_reference()2879 public final ImmutableMethodReference method_reference() throws RecognitionException { 2880 ImmutableMethodReference methodReference = null; 2881 2882 2883 CommonTree SIMPLE_NAME87=null; 2884 TreeRuleReturnScope reference_type_descriptor86 =null; 2885 ImmutableMethodProtoReference method_prototype88 =null; 2886 2887 try { 2888 // smaliTreeWalker.g:546:3: ( ( reference_type_descriptor )? SIMPLE_NAME method_prototype ) 2889 // smaliTreeWalker.g:546:5: ( reference_type_descriptor )? SIMPLE_NAME method_prototype 2890 { 2891 // smaliTreeWalker.g:546:5: ( reference_type_descriptor )? 2892 int alt19=2; 2893 int LA19_0 = input.LA(1); 2894 if ( (LA19_0==ARRAY_TYPE_PREFIX||LA19_0==CLASS_DESCRIPTOR) ) { 2895 alt19=1; 2896 } 2897 switch (alt19) { 2898 case 1 : 2899 // smaliTreeWalker.g:546:5: reference_type_descriptor 2900 { 2901 pushFollow(FOLLOW_reference_type_descriptor_in_method_reference1312); 2902 reference_type_descriptor86=reference_type_descriptor(); 2903 state._fsp--; 2904 2905 } 2906 break; 2907 2908 } 2909 2910 SIMPLE_NAME87=(CommonTree)match(input,SIMPLE_NAME,FOLLOW_SIMPLE_NAME_in_method_reference1315); 2911 pushFollow(FOLLOW_method_prototype_in_method_reference1317); 2912 method_prototype88=method_prototype(); 2913 state._fsp--; 2914 2915 2916 String type; 2917 if ((reference_type_descriptor86!=null?((smaliTreeWalker.reference_type_descriptor_return)reference_type_descriptor86).type:null) == null) { 2918 type = classType; 2919 } else { 2920 type = (reference_type_descriptor86!=null?((smaliTreeWalker.reference_type_descriptor_return)reference_type_descriptor86).type:null); 2921 } 2922 methodReference = new ImmutableMethodReference(type, (SIMPLE_NAME87!=null?SIMPLE_NAME87.getText():null), 2923 method_prototype88.getParameterTypes(), method_prototype88.getReturnType()); 2924 2925 } 2926 2927 } 2928 catch (RecognitionException re) { 2929 reportError(re); 2930 recover(input,re); 2931 } 2932 finally { 2933 // do for sure before leaving 2934 } 2935 return methodReference; 2936 } 2937 // $ANTLR end "method_reference" 2938 2939 2940 public static class field_reference_return extends TreeRuleReturnScope { 2941 public ImmutableFieldReference fieldReference; 2942 }; 2943 2944 2945 // $ANTLR start "field_reference" 2946 // smaliTreeWalker.g:558:1: field_reference returns [ImmutableFieldReference fieldReference] : ( reference_type_descriptor )? SIMPLE_NAME nonvoid_type_descriptor ; field_reference()2947 public final smaliTreeWalker.field_reference_return field_reference() throws RecognitionException { 2948 smaliTreeWalker.field_reference_return retval = new smaliTreeWalker.field_reference_return(); 2949 retval.start = input.LT(1); 2950 2951 CommonTree SIMPLE_NAME90=null; 2952 TreeRuleReturnScope reference_type_descriptor89 =null; 2953 TreeRuleReturnScope nonvoid_type_descriptor91 =null; 2954 2955 try { 2956 // smaliTreeWalker.g:559:3: ( ( reference_type_descriptor )? SIMPLE_NAME nonvoid_type_descriptor ) 2957 // smaliTreeWalker.g:559:5: ( reference_type_descriptor )? SIMPLE_NAME nonvoid_type_descriptor 2958 { 2959 // smaliTreeWalker.g:559:5: ( reference_type_descriptor )? 2960 int alt20=2; 2961 int LA20_0 = input.LA(1); 2962 if ( (LA20_0==ARRAY_TYPE_PREFIX||LA20_0==CLASS_DESCRIPTOR) ) { 2963 alt20=1; 2964 } 2965 switch (alt20) { 2966 case 1 : 2967 // smaliTreeWalker.g:559:5: reference_type_descriptor 2968 { 2969 pushFollow(FOLLOW_reference_type_descriptor_in_field_reference1334); 2970 reference_type_descriptor89=reference_type_descriptor(); 2971 state._fsp--; 2972 2973 } 2974 break; 2975 2976 } 2977 2978 SIMPLE_NAME90=(CommonTree)match(input,SIMPLE_NAME,FOLLOW_SIMPLE_NAME_in_field_reference1337); 2979 pushFollow(FOLLOW_nonvoid_type_descriptor_in_field_reference1339); 2980 nonvoid_type_descriptor91=nonvoid_type_descriptor(); 2981 state._fsp--; 2982 2983 2984 String type; 2985 if ((reference_type_descriptor89!=null?((smaliTreeWalker.reference_type_descriptor_return)reference_type_descriptor89).type:null) == null) { 2986 type = classType; 2987 } else { 2988 type = (reference_type_descriptor89!=null?((smaliTreeWalker.reference_type_descriptor_return)reference_type_descriptor89).type:null); 2989 } 2990 retval.fieldReference = new ImmutableFieldReference(type, (SIMPLE_NAME90!=null?SIMPLE_NAME90.getText():null), 2991 (nonvoid_type_descriptor91!=null?((smaliTreeWalker.nonvoid_type_descriptor_return)nonvoid_type_descriptor91).type:null)); 2992 2993 } 2994 2995 } 2996 catch (RecognitionException re) { 2997 reportError(re); 2998 recover(input,re); 2999 } 3000 finally { 3001 // do for sure before leaving 3002 } 3003 return retval; 3004 } 3005 // $ANTLR end "field_reference" 3006 3007 3008 public static class registers_directive_return extends TreeRuleReturnScope { 3009 public boolean isLocalsDirective; 3010 public int registers; 3011 }; 3012 3013 3014 // $ANTLR start "registers_directive" 3015 // smaliTreeWalker.g:571:1: registers_directive returns [boolean isLocalsDirective, int registers] : ^( ( I_REGISTERS | I_LOCALS ) short_integral_literal ) ; registers_directive()3016 public final smaliTreeWalker.registers_directive_return registers_directive() throws RecognitionException { 3017 smaliTreeWalker.registers_directive_return retval = new smaliTreeWalker.registers_directive_return(); 3018 retval.start = input.LT(1); 3019 3020 short short_integral_literal92 =0; 3021 3022 try { 3023 // smaliTreeWalker.g:572:3: ( ^( ( I_REGISTERS | I_LOCALS ) short_integral_literal ) ) 3024 // smaliTreeWalker.g:572:5: ^( ( I_REGISTERS | I_LOCALS ) short_integral_literal ) 3025 { 3026 retval.registers = 0; 3027 // smaliTreeWalker.g:573:7: ( I_REGISTERS | I_LOCALS ) 3028 int alt21=2; 3029 int LA21_0 = input.LA(1); 3030 if ( (LA21_0==I_REGISTERS) ) { 3031 alt21=1; 3032 } 3033 else if ( (LA21_0==I_LOCALS) ) { 3034 alt21=2; 3035 } 3036 3037 else { 3038 NoViableAltException nvae = 3039 new NoViableAltException("", 21, 0, input); 3040 throw nvae; 3041 } 3042 3043 switch (alt21) { 3044 case 1 : 3045 // smaliTreeWalker.g:573:9: I_REGISTERS 3046 { 3047 match(input,I_REGISTERS,FOLLOW_I_REGISTERS_in_registers_directive1365); 3048 retval.isLocalsDirective = false; 3049 } 3050 break; 3051 case 2 : 3052 // smaliTreeWalker.g:574:9: I_LOCALS 3053 { 3054 match(input,I_LOCALS,FOLLOW_I_LOCALS_in_registers_directive1377); 3055 retval.isLocalsDirective = true; 3056 } 3057 break; 3058 3059 } 3060 3061 match(input, Token.DOWN, null); 3062 pushFollow(FOLLOW_short_integral_literal_in_registers_directive1395); 3063 short_integral_literal92=short_integral_literal(); 3064 state._fsp--; 3065 3066 retval.registers = short_integral_literal92 & 0xFFFF; 3067 match(input, Token.UP, null); 3068 3069 } 3070 3071 } 3072 catch (RecognitionException re) { 3073 reportError(re); 3074 recover(input,re); 3075 } 3076 finally { 3077 // do for sure before leaving 3078 } 3079 return retval; 3080 } 3081 // $ANTLR end "registers_directive" 3082 3083 3084 3085 // $ANTLR start "label_def" 3086 // smaliTreeWalker.g:579:1: label_def : ^( I_LABEL SIMPLE_NAME ) ; label_def()3087 public final void label_def() throws RecognitionException { 3088 CommonTree SIMPLE_NAME93=null; 3089 3090 try { 3091 // smaliTreeWalker.g:580:3: ( ^( I_LABEL SIMPLE_NAME ) ) 3092 // smaliTreeWalker.g:580:5: ^( I_LABEL SIMPLE_NAME ) 3093 { 3094 match(input,I_LABEL,FOLLOW_I_LABEL_in_label_def1415); 3095 match(input, Token.DOWN, null); 3096 SIMPLE_NAME93=(CommonTree)match(input,SIMPLE_NAME,FOLLOW_SIMPLE_NAME_in_label_def1417); 3097 match(input, Token.UP, null); 3098 3099 3100 method_stack.peek().methodBuilder.addLabel((SIMPLE_NAME93!=null?SIMPLE_NAME93.getText():null)); 3101 3102 } 3103 3104 } 3105 catch (RecognitionException re) { 3106 reportError(re); 3107 recover(input,re); 3108 } 3109 finally { 3110 // do for sure before leaving 3111 } 3112 } 3113 // $ANTLR end "label_def" 3114 3115 3116 3117 // $ANTLR start "catches" 3118 // smaliTreeWalker.g:585:1: catches returns [List<BuilderTryBlock> tryBlocks] : ^( I_CATCHES ( catch_directive )* ( catchall_directive )* ) ; catches()3119 public final List<BuilderTryBlock> catches() throws RecognitionException { 3120 List<BuilderTryBlock> tryBlocks = null; 3121 3122 3123 tryBlocks = Lists.newArrayList(); 3124 try { 3125 // smaliTreeWalker.g:587:3: ( ^( I_CATCHES ( catch_directive )* ( catchall_directive )* ) ) 3126 // smaliTreeWalker.g:587:5: ^( I_CATCHES ( catch_directive )* ( catchall_directive )* ) 3127 { 3128 match(input,I_CATCHES,FOLLOW_I_CATCHES_in_catches1443); 3129 if ( input.LA(1)==Token.DOWN ) { 3130 match(input, Token.DOWN, null); 3131 // smaliTreeWalker.g:587:17: ( catch_directive )* 3132 loop22: 3133 while (true) { 3134 int alt22=2; 3135 int LA22_0 = input.LA(1); 3136 if ( (LA22_0==I_CATCH) ) { 3137 alt22=1; 3138 } 3139 3140 switch (alt22) { 3141 case 1 : 3142 // smaliTreeWalker.g:587:17: catch_directive 3143 { 3144 pushFollow(FOLLOW_catch_directive_in_catches1445); 3145 catch_directive(); 3146 state._fsp--; 3147 3148 } 3149 break; 3150 3151 default : 3152 break loop22; 3153 } 3154 } 3155 3156 // smaliTreeWalker.g:587:34: ( catchall_directive )* 3157 loop23: 3158 while (true) { 3159 int alt23=2; 3160 int LA23_0 = input.LA(1); 3161 if ( (LA23_0==I_CATCHALL) ) { 3162 alt23=1; 3163 } 3164 3165 switch (alt23) { 3166 case 1 : 3167 // smaliTreeWalker.g:587:34: catchall_directive 3168 { 3169 pushFollow(FOLLOW_catchall_directive_in_catches1448); 3170 catchall_directive(); 3171 state._fsp--; 3172 3173 } 3174 break; 3175 3176 default : 3177 break loop23; 3178 } 3179 } 3180 3181 match(input, Token.UP, null); 3182 } 3183 3184 } 3185 3186 } 3187 catch (RecognitionException re) { 3188 reportError(re); 3189 recover(input,re); 3190 } 3191 finally { 3192 // do for sure before leaving 3193 } 3194 return tryBlocks; 3195 } 3196 // $ANTLR end "catches" 3197 3198 3199 3200 // $ANTLR start "catch_directive" 3201 // smaliTreeWalker.g:589:1: catch_directive : ^( I_CATCH nonvoid_type_descriptor from= label_ref to= label_ref using= label_ref ) ; catch_directive()3202 public final void catch_directive() throws RecognitionException { 3203 Label from =null; 3204 Label to =null; 3205 Label using =null; 3206 TreeRuleReturnScope nonvoid_type_descriptor94 =null; 3207 3208 try { 3209 // smaliTreeWalker.g:590:3: ( ^( I_CATCH nonvoid_type_descriptor from= label_ref to= label_ref using= label_ref ) ) 3210 // smaliTreeWalker.g:590:5: ^( I_CATCH nonvoid_type_descriptor from= label_ref to= label_ref using= label_ref ) 3211 { 3212 match(input,I_CATCH,FOLLOW_I_CATCH_in_catch_directive1461); 3213 match(input, Token.DOWN, null); 3214 pushFollow(FOLLOW_nonvoid_type_descriptor_in_catch_directive1463); 3215 nonvoid_type_descriptor94=nonvoid_type_descriptor(); 3216 state._fsp--; 3217 3218 pushFollow(FOLLOW_label_ref_in_catch_directive1467); 3219 from=label_ref(); 3220 state._fsp--; 3221 3222 pushFollow(FOLLOW_label_ref_in_catch_directive1471); 3223 to=label_ref(); 3224 state._fsp--; 3225 3226 pushFollow(FOLLOW_label_ref_in_catch_directive1475); 3227 using=label_ref(); 3228 state._fsp--; 3229 3230 match(input, Token.UP, null); 3231 3232 3233 method_stack.peek().methodBuilder.addCatch(dexBuilder.internTypeReference((nonvoid_type_descriptor94!=null?((smaliTreeWalker.nonvoid_type_descriptor_return)nonvoid_type_descriptor94).type:null)), 3234 from, to, using); 3235 3236 } 3237 3238 } 3239 catch (RecognitionException re) { 3240 reportError(re); 3241 recover(input,re); 3242 } 3243 finally { 3244 // do for sure before leaving 3245 } 3246 } 3247 // $ANTLR end "catch_directive" 3248 3249 3250 3251 // $ANTLR start "catchall_directive" 3252 // smaliTreeWalker.g:596:1: catchall_directive : ^( I_CATCHALL from= label_ref to= label_ref using= label_ref ) ; catchall_directive()3253 public final void catchall_directive() throws RecognitionException { 3254 Label from =null; 3255 Label to =null; 3256 Label using =null; 3257 3258 try { 3259 // smaliTreeWalker.g:597:3: ( ^( I_CATCHALL from= label_ref to= label_ref using= label_ref ) ) 3260 // smaliTreeWalker.g:597:5: ^( I_CATCHALL from= label_ref to= label_ref using= label_ref ) 3261 { 3262 match(input,I_CATCHALL,FOLLOW_I_CATCHALL_in_catchall_directive1491); 3263 match(input, Token.DOWN, null); 3264 pushFollow(FOLLOW_label_ref_in_catchall_directive1495); 3265 from=label_ref(); 3266 state._fsp--; 3267 3268 pushFollow(FOLLOW_label_ref_in_catchall_directive1499); 3269 to=label_ref(); 3270 state._fsp--; 3271 3272 pushFollow(FOLLOW_label_ref_in_catchall_directive1503); 3273 using=label_ref(); 3274 state._fsp--; 3275 3276 match(input, Token.UP, null); 3277 3278 3279 method_stack.peek().methodBuilder.addCatch(from, to, using); 3280 3281 } 3282 3283 } 3284 catch (RecognitionException re) { 3285 reportError(re); 3286 recover(input,re); 3287 } 3288 finally { 3289 // do for sure before leaving 3290 } 3291 } 3292 // $ANTLR end "catchall_directive" 3293 3294 3295 3296 // $ANTLR start "parameters" 3297 // smaliTreeWalker.g:602:1: parameters[List<SmaliMethodParameter> parameters] : ^( I_PARAMETERS ( parameter[parameters] )* ) ; parameters(List<SmaliMethodParameter> parameters)3298 public final void parameters(List<SmaliMethodParameter> parameters) throws RecognitionException { 3299 try { 3300 // smaliTreeWalker.g:603:3: ( ^( I_PARAMETERS ( parameter[parameters] )* ) ) 3301 // smaliTreeWalker.g:603:5: ^( I_PARAMETERS ( parameter[parameters] )* ) 3302 { 3303 match(input,I_PARAMETERS,FOLLOW_I_PARAMETERS_in_parameters1520); 3304 if ( input.LA(1)==Token.DOWN ) { 3305 match(input, Token.DOWN, null); 3306 // smaliTreeWalker.g:603:20: ( parameter[parameters] )* 3307 loop24: 3308 while (true) { 3309 int alt24=2; 3310 int LA24_0 = input.LA(1); 3311 if ( (LA24_0==I_PARAMETER) ) { 3312 alt24=1; 3313 } 3314 3315 switch (alt24) { 3316 case 1 : 3317 // smaliTreeWalker.g:603:21: parameter[parameters] 3318 { 3319 pushFollow(FOLLOW_parameter_in_parameters1523); 3320 parameter(parameters); 3321 state._fsp--; 3322 3323 } 3324 break; 3325 3326 default : 3327 break loop24; 3328 } 3329 } 3330 3331 match(input, Token.UP, null); 3332 } 3333 3334 } 3335 3336 } 3337 catch (RecognitionException re) { 3338 reportError(re); 3339 recover(input,re); 3340 } 3341 finally { 3342 // do for sure before leaving 3343 } 3344 } 3345 // $ANTLR end "parameters" 3346 3347 3348 3349 // $ANTLR start "parameter" 3350 // smaliTreeWalker.g:605:1: parameter[List<SmaliMethodParameter> parameters] : ^( I_PARAMETER REGISTER ( string_literal )? annotations ) ; parameter(List<SmaliMethodParameter> parameters)3351 public final void parameter(List<SmaliMethodParameter> parameters) throws RecognitionException { 3352 CommonTree REGISTER95=null; 3353 CommonTree I_PARAMETER96=null; 3354 String string_literal97 =null; 3355 Set<Annotation> annotations98 =null; 3356 3357 try { 3358 // smaliTreeWalker.g:606:3: ( ^( I_PARAMETER REGISTER ( string_literal )? annotations ) ) 3359 // smaliTreeWalker.g:606:5: ^( I_PARAMETER REGISTER ( string_literal )? annotations ) 3360 { 3361 I_PARAMETER96=(CommonTree)match(input,I_PARAMETER,FOLLOW_I_PARAMETER_in_parameter1539); 3362 match(input, Token.DOWN, null); 3363 REGISTER95=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_parameter1541); 3364 // smaliTreeWalker.g:606:28: ( string_literal )? 3365 int alt25=2; 3366 int LA25_0 = input.LA(1); 3367 if ( (LA25_0==STRING_LITERAL) ) { 3368 alt25=1; 3369 } 3370 switch (alt25) { 3371 case 1 : 3372 // smaliTreeWalker.g:606:28: string_literal 3373 { 3374 pushFollow(FOLLOW_string_literal_in_parameter1543); 3375 string_literal97=string_literal(); 3376 state._fsp--; 3377 3378 } 3379 break; 3380 3381 } 3382 3383 pushFollow(FOLLOW_annotations_in_parameter1546); 3384 annotations98=annotations(); 3385 state._fsp--; 3386 3387 match(input, Token.UP, null); 3388 3389 3390 final int registerNumber = parseRegister_short((REGISTER95!=null?REGISTER95.getText():null)); 3391 int totalMethodRegisters = method_stack.peek().totalMethodRegisters; 3392 int methodParameterRegisters = method_stack.peek().methodParameterRegisters; 3393 3394 if (registerNumber >= totalMethodRegisters) { 3395 throw new SemanticException(input, I_PARAMETER96, "Register %s is larger than the maximum register v%d " + 3396 "for this method", (REGISTER95!=null?REGISTER95.getText():null), totalMethodRegisters-1); 3397 } 3398 final int indexGuess = registerNumber - (totalMethodRegisters - methodParameterRegisters) - (method_stack.peek().isStatic?0:1); 3399 3400 if (indexGuess < 0) { 3401 throw new SemanticException(input, I_PARAMETER96, "Register %s is not a parameter register.", 3402 (REGISTER95!=null?REGISTER95.getText():null)); 3403 } 3404 3405 int parameterIndex = LinearSearch.linearSearch(parameters, SmaliMethodParameter.COMPARATOR, 3406 new WithRegister() { public int getRegister() { return indexGuess; } }, 3407 indexGuess); 3408 3409 if (parameterIndex < 0) { 3410 throw new SemanticException(input, I_PARAMETER96, "Register %s is the second half of a wide parameter.", 3411 (REGISTER95!=null?REGISTER95.getText():null)); 3412 } 3413 3414 SmaliMethodParameter methodParameter = parameters.get(parameterIndex); 3415 methodParameter.name = string_literal97; 3416 if (annotations98 != null && annotations98.size() > 0) { 3417 methodParameter.annotations = annotations98; 3418 } 3419 3420 } 3421 3422 } 3423 catch (RecognitionException re) { 3424 reportError(re); 3425 recover(input,re); 3426 } 3427 finally { 3428 // do for sure before leaving 3429 } 3430 } 3431 // $ANTLR end "parameter" 3432 3433 3434 3435 // $ANTLR start "debug_directive" 3436 // smaliTreeWalker.g:639:1: debug_directive : ( line | local | end_local | restart_local | prologue | epilogue | source ); debug_directive()3437 public final void debug_directive() throws RecognitionException { 3438 try { 3439 // smaliTreeWalker.g:640:3: ( line | local | end_local | restart_local | prologue | epilogue | source ) 3440 int alt26=7; 3441 switch ( input.LA(1) ) { 3442 case I_LINE: 3443 { 3444 alt26=1; 3445 } 3446 break; 3447 case I_LOCAL: 3448 { 3449 alt26=2; 3450 } 3451 break; 3452 case I_END_LOCAL: 3453 { 3454 alt26=3; 3455 } 3456 break; 3457 case I_RESTART_LOCAL: 3458 { 3459 alt26=4; 3460 } 3461 break; 3462 case I_PROLOGUE: 3463 { 3464 alt26=5; 3465 } 3466 break; 3467 case I_EPILOGUE: 3468 { 3469 alt26=6; 3470 } 3471 break; 3472 case I_SOURCE: 3473 { 3474 alt26=7; 3475 } 3476 break; 3477 default: 3478 NoViableAltException nvae = 3479 new NoViableAltException("", 26, 0, input); 3480 throw nvae; 3481 } 3482 switch (alt26) { 3483 case 1 : 3484 // smaliTreeWalker.g:640:5: line 3485 { 3486 pushFollow(FOLLOW_line_in_debug_directive1563); 3487 line(); 3488 state._fsp--; 3489 3490 } 3491 break; 3492 case 2 : 3493 // smaliTreeWalker.g:641:5: local 3494 { 3495 pushFollow(FOLLOW_local_in_debug_directive1569); 3496 local(); 3497 state._fsp--; 3498 3499 } 3500 break; 3501 case 3 : 3502 // smaliTreeWalker.g:642:5: end_local 3503 { 3504 pushFollow(FOLLOW_end_local_in_debug_directive1575); 3505 end_local(); 3506 state._fsp--; 3507 3508 } 3509 break; 3510 case 4 : 3511 // smaliTreeWalker.g:643:5: restart_local 3512 { 3513 pushFollow(FOLLOW_restart_local_in_debug_directive1581); 3514 restart_local(); 3515 state._fsp--; 3516 3517 } 3518 break; 3519 case 5 : 3520 // smaliTreeWalker.g:644:5: prologue 3521 { 3522 pushFollow(FOLLOW_prologue_in_debug_directive1587); 3523 prologue(); 3524 state._fsp--; 3525 3526 } 3527 break; 3528 case 6 : 3529 // smaliTreeWalker.g:645:5: epilogue 3530 { 3531 pushFollow(FOLLOW_epilogue_in_debug_directive1593); 3532 epilogue(); 3533 state._fsp--; 3534 3535 } 3536 break; 3537 case 7 : 3538 // smaliTreeWalker.g:646:5: source 3539 { 3540 pushFollow(FOLLOW_source_in_debug_directive1599); 3541 source(); 3542 state._fsp--; 3543 3544 } 3545 break; 3546 3547 } 3548 } 3549 catch (RecognitionException re) { 3550 reportError(re); 3551 recover(input,re); 3552 } 3553 finally { 3554 // do for sure before leaving 3555 } 3556 } 3557 // $ANTLR end "debug_directive" 3558 3559 3560 3561 // $ANTLR start "line" 3562 // smaliTreeWalker.g:648:1: line : ^( I_LINE integral_literal ) ; line()3563 public final void line() throws RecognitionException { 3564 int integral_literal99 =0; 3565 3566 try { 3567 // smaliTreeWalker.g:649:3: ( ^( I_LINE integral_literal ) ) 3568 // smaliTreeWalker.g:649:5: ^( I_LINE integral_literal ) 3569 { 3570 match(input,I_LINE,FOLLOW_I_LINE_in_line1610); 3571 match(input, Token.DOWN, null); 3572 pushFollow(FOLLOW_integral_literal_in_line1612); 3573 integral_literal99=integral_literal(); 3574 state._fsp--; 3575 3576 match(input, Token.UP, null); 3577 3578 3579 method_stack.peek().methodBuilder.addLineNumber(integral_literal99); 3580 3581 } 3582 3583 } 3584 catch (RecognitionException re) { 3585 reportError(re); 3586 recover(input,re); 3587 } 3588 finally { 3589 // do for sure before leaving 3590 } 3591 } 3592 // $ANTLR end "line" 3593 3594 3595 3596 // $ANTLR start "local" 3597 // smaliTreeWalker.g:654:1: local : ^( I_LOCAL REGISTER ( ( NULL_LITERAL |name= string_literal ) ( nonvoid_type_descriptor )? (signature= string_literal )? )? ) ; local()3598 public final void local() throws RecognitionException { 3599 CommonTree REGISTER100=null; 3600 String name =null; 3601 String signature =null; 3602 TreeRuleReturnScope nonvoid_type_descriptor101 =null; 3603 3604 try { 3605 // smaliTreeWalker.g:655:3: ( ^( I_LOCAL REGISTER ( ( NULL_LITERAL |name= string_literal ) ( nonvoid_type_descriptor )? (signature= string_literal )? )? ) ) 3606 // smaliTreeWalker.g:655:5: ^( I_LOCAL REGISTER ( ( NULL_LITERAL |name= string_literal ) ( nonvoid_type_descriptor )? (signature= string_literal )? )? ) 3607 { 3608 match(input,I_LOCAL,FOLLOW_I_LOCAL_in_local1630); 3609 match(input, Token.DOWN, null); 3610 REGISTER100=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_local1632); 3611 // smaliTreeWalker.g:655:24: ( ( NULL_LITERAL |name= string_literal ) ( nonvoid_type_descriptor )? (signature= string_literal )? )? 3612 int alt30=2; 3613 int LA30_0 = input.LA(1); 3614 if ( (LA30_0==NULL_LITERAL||LA30_0==STRING_LITERAL) ) { 3615 alt30=1; 3616 } 3617 switch (alt30) { 3618 case 1 : 3619 // smaliTreeWalker.g:655:25: ( NULL_LITERAL |name= string_literal ) ( nonvoid_type_descriptor )? (signature= string_literal )? 3620 { 3621 // smaliTreeWalker.g:655:25: ( NULL_LITERAL |name= string_literal ) 3622 int alt27=2; 3623 int LA27_0 = input.LA(1); 3624 if ( (LA27_0==NULL_LITERAL) ) { 3625 alt27=1; 3626 } 3627 else if ( (LA27_0==STRING_LITERAL) ) { 3628 alt27=2; 3629 } 3630 3631 else { 3632 NoViableAltException nvae = 3633 new NoViableAltException("", 27, 0, input); 3634 throw nvae; 3635 } 3636 3637 switch (alt27) { 3638 case 1 : 3639 // smaliTreeWalker.g:655:26: NULL_LITERAL 3640 { 3641 match(input,NULL_LITERAL,FOLLOW_NULL_LITERAL_in_local1636); 3642 } 3643 break; 3644 case 2 : 3645 // smaliTreeWalker.g:655:41: name= string_literal 3646 { 3647 pushFollow(FOLLOW_string_literal_in_local1642); 3648 name=string_literal(); 3649 state._fsp--; 3650 3651 } 3652 break; 3653 3654 } 3655 3656 // smaliTreeWalker.g:655:62: ( nonvoid_type_descriptor )? 3657 int alt28=2; 3658 int LA28_0 = input.LA(1); 3659 if ( (LA28_0==ARRAY_TYPE_PREFIX||LA28_0==CLASS_DESCRIPTOR||LA28_0==PRIMITIVE_TYPE) ) { 3660 alt28=1; 3661 } 3662 switch (alt28) { 3663 case 1 : 3664 // smaliTreeWalker.g:655:62: nonvoid_type_descriptor 3665 { 3666 pushFollow(FOLLOW_nonvoid_type_descriptor_in_local1645); 3667 nonvoid_type_descriptor101=nonvoid_type_descriptor(); 3668 state._fsp--; 3669 3670 } 3671 break; 3672 3673 } 3674 3675 // smaliTreeWalker.g:655:96: (signature= string_literal )? 3676 int alt29=2; 3677 int LA29_0 = input.LA(1); 3678 if ( (LA29_0==STRING_LITERAL) ) { 3679 alt29=1; 3680 } 3681 switch (alt29) { 3682 case 1 : 3683 // smaliTreeWalker.g:655:96: signature= string_literal 3684 { 3685 pushFollow(FOLLOW_string_literal_in_local1650); 3686 signature=string_literal(); 3687 state._fsp--; 3688 3689 } 3690 break; 3691 3692 } 3693 3694 } 3695 break; 3696 3697 } 3698 3699 match(input, Token.UP, null); 3700 3701 3702 int registerNumber = parseRegister_short((REGISTER100!=null?REGISTER100.getText():null)); 3703 method_stack.peek().methodBuilder.addStartLocal(registerNumber, 3704 dexBuilder.internNullableStringReference(name), 3705 dexBuilder.internNullableTypeReference((nonvoid_type_descriptor101!=null?((smaliTreeWalker.nonvoid_type_descriptor_return)nonvoid_type_descriptor101).type:null)), 3706 dexBuilder.internNullableStringReference(signature)); 3707 3708 } 3709 3710 } 3711 catch (RecognitionException re) { 3712 reportError(re); 3713 recover(input,re); 3714 } 3715 finally { 3716 // do for sure before leaving 3717 } 3718 } 3719 // $ANTLR end "local" 3720 3721 3722 3723 // $ANTLR start "end_local" 3724 // smaliTreeWalker.g:664:1: end_local : ^( I_END_LOCAL REGISTER ) ; end_local()3725 public final void end_local() throws RecognitionException { 3726 CommonTree REGISTER102=null; 3727 3728 try { 3729 // smaliTreeWalker.g:665:3: ( ^( I_END_LOCAL REGISTER ) ) 3730 // smaliTreeWalker.g:665:5: ^( I_END_LOCAL REGISTER ) 3731 { 3732 match(input,I_END_LOCAL,FOLLOW_I_END_LOCAL_in_end_local1671); 3733 match(input, Token.DOWN, null); 3734 REGISTER102=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_end_local1673); 3735 match(input, Token.UP, null); 3736 3737 3738 int registerNumber = parseRegister_short((REGISTER102!=null?REGISTER102.getText():null)); 3739 method_stack.peek().methodBuilder.addEndLocal(registerNumber); 3740 3741 } 3742 3743 } 3744 catch (RecognitionException re) { 3745 reportError(re); 3746 recover(input,re); 3747 } 3748 finally { 3749 // do for sure before leaving 3750 } 3751 } 3752 // $ANTLR end "end_local" 3753 3754 3755 3756 // $ANTLR start "restart_local" 3757 // smaliTreeWalker.g:671:1: restart_local : ^( I_RESTART_LOCAL REGISTER ) ; restart_local()3758 public final void restart_local() throws RecognitionException { 3759 CommonTree REGISTER103=null; 3760 3761 try { 3762 // smaliTreeWalker.g:672:3: ( ^( I_RESTART_LOCAL REGISTER ) ) 3763 // smaliTreeWalker.g:672:5: ^( I_RESTART_LOCAL REGISTER ) 3764 { 3765 match(input,I_RESTART_LOCAL,FOLLOW_I_RESTART_LOCAL_in_restart_local1691); 3766 match(input, Token.DOWN, null); 3767 REGISTER103=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_restart_local1693); 3768 match(input, Token.UP, null); 3769 3770 3771 int registerNumber = parseRegister_short((REGISTER103!=null?REGISTER103.getText():null)); 3772 method_stack.peek().methodBuilder.addRestartLocal(registerNumber); 3773 3774 } 3775 3776 } 3777 catch (RecognitionException re) { 3778 reportError(re); 3779 recover(input,re); 3780 } 3781 finally { 3782 // do for sure before leaving 3783 } 3784 } 3785 // $ANTLR end "restart_local" 3786 3787 3788 3789 // $ANTLR start "prologue" 3790 // smaliTreeWalker.g:678:1: prologue : I_PROLOGUE ; prologue()3791 public final void prologue() throws RecognitionException { 3792 try { 3793 // smaliTreeWalker.g:679:3: ( I_PROLOGUE ) 3794 // smaliTreeWalker.g:679:5: I_PROLOGUE 3795 { 3796 match(input,I_PROLOGUE,FOLLOW_I_PROLOGUE_in_prologue1710); 3797 3798 method_stack.peek().methodBuilder.addPrologue(); 3799 3800 } 3801 3802 } 3803 catch (RecognitionException re) { 3804 reportError(re); 3805 recover(input,re); 3806 } 3807 finally { 3808 // do for sure before leaving 3809 } 3810 } 3811 // $ANTLR end "prologue" 3812 3813 3814 3815 // $ANTLR start "epilogue" 3816 // smaliTreeWalker.g:684:1: epilogue : I_EPILOGUE ; epilogue()3817 public final void epilogue() throws RecognitionException { 3818 try { 3819 // smaliTreeWalker.g:685:3: ( I_EPILOGUE ) 3820 // smaliTreeWalker.g:685:5: I_EPILOGUE 3821 { 3822 match(input,I_EPILOGUE,FOLLOW_I_EPILOGUE_in_epilogue1726); 3823 3824 method_stack.peek().methodBuilder.addEpilogue(); 3825 3826 } 3827 3828 } 3829 catch (RecognitionException re) { 3830 reportError(re); 3831 recover(input,re); 3832 } 3833 finally { 3834 // do for sure before leaving 3835 } 3836 } 3837 // $ANTLR end "epilogue" 3838 3839 3840 3841 // $ANTLR start "source" 3842 // smaliTreeWalker.g:690:1: source : ^( I_SOURCE ( string_literal )? ) ; source()3843 public final void source() throws RecognitionException { 3844 String string_literal104 =null; 3845 3846 try { 3847 // smaliTreeWalker.g:691:3: ( ^( I_SOURCE ( string_literal )? ) ) 3848 // smaliTreeWalker.g:691:5: ^( I_SOURCE ( string_literal )? ) 3849 { 3850 match(input,I_SOURCE,FOLLOW_I_SOURCE_in_source1743); 3851 if ( input.LA(1)==Token.DOWN ) { 3852 match(input, Token.DOWN, null); 3853 // smaliTreeWalker.g:691:16: ( string_literal )? 3854 int alt31=2; 3855 int LA31_0 = input.LA(1); 3856 if ( (LA31_0==STRING_LITERAL) ) { 3857 alt31=1; 3858 } 3859 switch (alt31) { 3860 case 1 : 3861 // smaliTreeWalker.g:691:16: string_literal 3862 { 3863 pushFollow(FOLLOW_string_literal_in_source1745); 3864 string_literal104=string_literal(); 3865 state._fsp--; 3866 3867 } 3868 break; 3869 3870 } 3871 3872 match(input, Token.UP, null); 3873 } 3874 3875 3876 method_stack.peek().methodBuilder.addSetSourceFile(dexBuilder.internNullableStringReference(string_literal104)); 3877 3878 } 3879 3880 } 3881 catch (RecognitionException re) { 3882 reportError(re); 3883 recover(input,re); 3884 } 3885 finally { 3886 // do for sure before leaving 3887 } 3888 } 3889 // $ANTLR end "source" 3890 3891 3892 3893 // $ANTLR start "call_site_extra_arguments" 3894 // smaliTreeWalker.g:696:1: call_site_extra_arguments returns [List<ImmutableEncodedValue> extraArguments] : ^( I_CALL_SITE_EXTRA_ARGUMENTS ( literal )* ) ; call_site_extra_arguments()3895 public final List<ImmutableEncodedValue> call_site_extra_arguments() throws RecognitionException { 3896 List<ImmutableEncodedValue> extraArguments = null; 3897 3898 3899 ImmutableEncodedValue literal105 =null; 3900 3901 try { 3902 // smaliTreeWalker.g:697:3: ( ^( I_CALL_SITE_EXTRA_ARGUMENTS ( literal )* ) ) 3903 // smaliTreeWalker.g:697:5: ^( I_CALL_SITE_EXTRA_ARGUMENTS ( literal )* ) 3904 { 3905 extraArguments = Lists.newArrayList(); 3906 match(input,I_CALL_SITE_EXTRA_ARGUMENTS,FOLLOW_I_CALL_SITE_EXTRA_ARGUMENTS_in_call_site_extra_arguments1771); 3907 if ( input.LA(1)==Token.DOWN ) { 3908 match(input, Token.DOWN, null); 3909 // smaliTreeWalker.g:698:33: ( literal )* 3910 loop32: 3911 while (true) { 3912 int alt32=2; 3913 int LA32_0 = input.LA(1); 3914 if ( (LA32_0==ARRAY_TYPE_PREFIX||(LA32_0 >= BOOL_LITERAL && LA32_0 <= BYTE_LITERAL)||(LA32_0 >= CHAR_LITERAL && LA32_0 <= CLASS_DESCRIPTOR)||LA32_0==DOUBLE_LITERAL||LA32_0==FLOAT_LITERAL||LA32_0==INTEGER_LITERAL||(LA32_0 >= I_ENCODED_ARRAY && LA32_0 <= I_ENCODED_METHOD_HANDLE)||LA32_0==I_METHOD_PROTOTYPE||LA32_0==I_SUBANNOTATION||LA32_0==LONG_LITERAL||LA32_0==NULL_LITERAL||LA32_0==PRIMITIVE_TYPE||LA32_0==SHORT_LITERAL||LA32_0==STRING_LITERAL||LA32_0==VOID_TYPE) ) { 3915 alt32=1; 3916 } 3917 3918 switch (alt32) { 3919 case 1 : 3920 // smaliTreeWalker.g:698:34: literal 3921 { 3922 pushFollow(FOLLOW_literal_in_call_site_extra_arguments1774); 3923 literal105=literal(); 3924 state._fsp--; 3925 3926 extraArguments.add(literal105); 3927 } 3928 break; 3929 3930 default : 3931 break loop32; 3932 } 3933 } 3934 3935 match(input, Token.UP, null); 3936 } 3937 3938 } 3939 3940 } 3941 catch (RecognitionException re) { 3942 reportError(re); 3943 recover(input,re); 3944 } 3945 finally { 3946 // do for sure before leaving 3947 } 3948 return extraArguments; 3949 } 3950 // $ANTLR end "call_site_extra_arguments" 3951 3952 3953 3954 // $ANTLR start "ordered_method_items" 3955 // smaliTreeWalker.g:700:1: ordered_method_items : ^( I_ORDERED_METHOD_ITEMS ( label_def | instruction | debug_directive )* ) ; ordered_method_items()3956 public final void ordered_method_items() throws RecognitionException { 3957 try { 3958 // smaliTreeWalker.g:701:3: ( ^( I_ORDERED_METHOD_ITEMS ( label_def | instruction | debug_directive )* ) ) 3959 // smaliTreeWalker.g:701:5: ^( I_ORDERED_METHOD_ITEMS ( label_def | instruction | debug_directive )* ) 3960 { 3961 match(input,I_ORDERED_METHOD_ITEMS,FOLLOW_I_ORDERED_METHOD_ITEMS_in_ordered_method_items1790); 3962 if ( input.LA(1)==Token.DOWN ) { 3963 match(input, Token.DOWN, null); 3964 // smaliTreeWalker.g:701:30: ( label_def | instruction | debug_directive )* 3965 loop33: 3966 while (true) { 3967 int alt33=4; 3968 switch ( input.LA(1) ) { 3969 case I_LABEL: 3970 { 3971 alt33=1; 3972 } 3973 break; 3974 case I_STATEMENT_ARRAY_DATA: 3975 case I_STATEMENT_FORMAT10t: 3976 case I_STATEMENT_FORMAT10x: 3977 case I_STATEMENT_FORMAT11n: 3978 case I_STATEMENT_FORMAT11x: 3979 case I_STATEMENT_FORMAT12x: 3980 case I_STATEMENT_FORMAT20bc: 3981 case I_STATEMENT_FORMAT20t: 3982 case I_STATEMENT_FORMAT21c_FIELD: 3983 case I_STATEMENT_FORMAT21c_METHOD_HANDLE: 3984 case I_STATEMENT_FORMAT21c_METHOD_TYPE: 3985 case I_STATEMENT_FORMAT21c_STRING: 3986 case I_STATEMENT_FORMAT21c_TYPE: 3987 case I_STATEMENT_FORMAT21ih: 3988 case I_STATEMENT_FORMAT21lh: 3989 case I_STATEMENT_FORMAT21s: 3990 case I_STATEMENT_FORMAT21t: 3991 case I_STATEMENT_FORMAT22b: 3992 case I_STATEMENT_FORMAT22c_FIELD: 3993 case I_STATEMENT_FORMAT22c_TYPE: 3994 case I_STATEMENT_FORMAT22s: 3995 case I_STATEMENT_FORMAT22t: 3996 case I_STATEMENT_FORMAT22x: 3997 case I_STATEMENT_FORMAT23x: 3998 case I_STATEMENT_FORMAT30t: 3999 case I_STATEMENT_FORMAT31c: 4000 case I_STATEMENT_FORMAT31i: 4001 case I_STATEMENT_FORMAT31t: 4002 case I_STATEMENT_FORMAT32x: 4003 case I_STATEMENT_FORMAT35c_CALL_SITE: 4004 case I_STATEMENT_FORMAT35c_METHOD: 4005 case I_STATEMENT_FORMAT35c_TYPE: 4006 case I_STATEMENT_FORMAT3rc_CALL_SITE: 4007 case I_STATEMENT_FORMAT3rc_METHOD: 4008 case I_STATEMENT_FORMAT3rc_TYPE: 4009 case I_STATEMENT_FORMAT45cc_METHOD: 4010 case I_STATEMENT_FORMAT4rcc_METHOD: 4011 case I_STATEMENT_FORMAT51l: 4012 case I_STATEMENT_PACKED_SWITCH: 4013 case I_STATEMENT_SPARSE_SWITCH: 4014 { 4015 alt33=2; 4016 } 4017 break; 4018 case I_END_LOCAL: 4019 case I_EPILOGUE: 4020 case I_LINE: 4021 case I_LOCAL: 4022 case I_PROLOGUE: 4023 case I_RESTART_LOCAL: 4024 case I_SOURCE: 4025 { 4026 alt33=3; 4027 } 4028 break; 4029 } 4030 switch (alt33) { 4031 case 1 : 4032 // smaliTreeWalker.g:701:31: label_def 4033 { 4034 pushFollow(FOLLOW_label_def_in_ordered_method_items1793); 4035 label_def(); 4036 state._fsp--; 4037 4038 } 4039 break; 4040 case 2 : 4041 // smaliTreeWalker.g:701:43: instruction 4042 { 4043 pushFollow(FOLLOW_instruction_in_ordered_method_items1797); 4044 instruction(); 4045 state._fsp--; 4046 4047 } 4048 break; 4049 case 3 : 4050 // smaliTreeWalker.g:701:57: debug_directive 4051 { 4052 pushFollow(FOLLOW_debug_directive_in_ordered_method_items1801); 4053 debug_directive(); 4054 state._fsp--; 4055 4056 } 4057 break; 4058 4059 default : 4060 break loop33; 4061 } 4062 } 4063 4064 match(input, Token.UP, null); 4065 } 4066 4067 } 4068 4069 } 4070 catch (RecognitionException re) { 4071 reportError(re); 4072 recover(input,re); 4073 } 4074 finally { 4075 // do for sure before leaving 4076 } 4077 } 4078 // $ANTLR end "ordered_method_items" 4079 4080 4081 4082 // $ANTLR start "label_ref" 4083 // smaliTreeWalker.g:703:1: label_ref returns [Label label] : SIMPLE_NAME ; label_ref()4084 public final Label label_ref() throws RecognitionException { 4085 Label label = null; 4086 4087 4088 CommonTree SIMPLE_NAME106=null; 4089 4090 try { 4091 // smaliTreeWalker.g:704:3: ( SIMPLE_NAME ) 4092 // smaliTreeWalker.g:704:5: SIMPLE_NAME 4093 { 4094 SIMPLE_NAME106=(CommonTree)match(input,SIMPLE_NAME,FOLLOW_SIMPLE_NAME_in_label_ref1817); 4095 label = method_stack.peek().methodBuilder.getLabel((SIMPLE_NAME106!=null?SIMPLE_NAME106.getText():null)); 4096 } 4097 4098 } 4099 catch (RecognitionException re) { 4100 reportError(re); 4101 recover(input,re); 4102 } 4103 finally { 4104 // do for sure before leaving 4105 } 4106 return label; 4107 } 4108 // $ANTLR end "label_ref" 4109 4110 4111 public static class register_list_return extends TreeRuleReturnScope { 4112 public byte[] registers; 4113 public byte registerCount; 4114 }; 4115 4116 4117 // $ANTLR start "register_list" 4118 // smaliTreeWalker.g:706:1: register_list returns [byte[] registers, byte registerCount] : ^( I_REGISTER_LIST ( REGISTER )* ) ; register_list()4119 public final smaliTreeWalker.register_list_return register_list() throws RecognitionException { 4120 smaliTreeWalker.register_list_return retval = new smaliTreeWalker.register_list_return(); 4121 retval.start = input.LT(1); 4122 4123 CommonTree I_REGISTER_LIST107=null; 4124 CommonTree REGISTER108=null; 4125 4126 4127 retval.registers = new byte[5]; 4128 retval.registerCount = 0; 4129 4130 try { 4131 // smaliTreeWalker.g:712:3: ( ^( I_REGISTER_LIST ( REGISTER )* ) ) 4132 // smaliTreeWalker.g:712:5: ^( I_REGISTER_LIST ( REGISTER )* ) 4133 { 4134 I_REGISTER_LIST107=(CommonTree)match(input,I_REGISTER_LIST,FOLLOW_I_REGISTER_LIST_in_register_list1842); 4135 if ( input.LA(1)==Token.DOWN ) { 4136 match(input, Token.DOWN, null); 4137 // smaliTreeWalker.g:713:7: ( REGISTER )* 4138 loop34: 4139 while (true) { 4140 int alt34=2; 4141 int LA34_0 = input.LA(1); 4142 if ( (LA34_0==REGISTER) ) { 4143 alt34=1; 4144 } 4145 4146 switch (alt34) { 4147 case 1 : 4148 // smaliTreeWalker.g:713:8: REGISTER 4149 { 4150 REGISTER108=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_register_list1851); 4151 4152 if (retval.registerCount == 5) { 4153 throw new SemanticException(input, I_REGISTER_LIST107, "A list of registers can only have a maximum of 5 " + 4154 "registers. Use the <op>/range alternate opcode instead."); 4155 } 4156 retval.registers[retval.registerCount++] = parseRegister_nibble((REGISTER108!=null?REGISTER108.getText():null)); 4157 4158 } 4159 break; 4160 4161 default : 4162 break loop34; 4163 } 4164 } 4165 4166 match(input, Token.UP, null); 4167 } 4168 4169 } 4170 4171 } 4172 catch (RecognitionException re) { 4173 reportError(re); 4174 recover(input,re); 4175 } 4176 finally { 4177 // do for sure before leaving 4178 } 4179 return retval; 4180 } 4181 // $ANTLR end "register_list" 4182 4183 4184 public static class register_range_return extends TreeRuleReturnScope { 4185 public int startRegister; 4186 public int endRegister; 4187 }; 4188 4189 4190 // $ANTLR start "register_range" 4191 // smaliTreeWalker.g:722:1: register_range returns [int startRegister, int endRegister] : ^( I_REGISTER_RANGE (startReg= REGISTER (endReg= REGISTER )? )? ) ; register_range()4192 public final smaliTreeWalker.register_range_return register_range() throws RecognitionException { 4193 smaliTreeWalker.register_range_return retval = new smaliTreeWalker.register_range_return(); 4194 retval.start = input.LT(1); 4195 4196 CommonTree startReg=null; 4197 CommonTree endReg=null; 4198 CommonTree I_REGISTER_RANGE109=null; 4199 4200 try { 4201 // smaliTreeWalker.g:723:3: ( ^( I_REGISTER_RANGE (startReg= REGISTER (endReg= REGISTER )? )? ) ) 4202 // smaliTreeWalker.g:723:5: ^( I_REGISTER_RANGE (startReg= REGISTER (endReg= REGISTER )? )? ) 4203 { 4204 I_REGISTER_RANGE109=(CommonTree)match(input,I_REGISTER_RANGE,FOLLOW_I_REGISTER_RANGE_in_register_range1876); 4205 if ( input.LA(1)==Token.DOWN ) { 4206 match(input, Token.DOWN, null); 4207 // smaliTreeWalker.g:723:24: (startReg= REGISTER (endReg= REGISTER )? )? 4208 int alt36=2; 4209 int LA36_0 = input.LA(1); 4210 if ( (LA36_0==REGISTER) ) { 4211 alt36=1; 4212 } 4213 switch (alt36) { 4214 case 1 : 4215 // smaliTreeWalker.g:723:25: startReg= REGISTER (endReg= REGISTER )? 4216 { 4217 startReg=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_register_range1881); 4218 // smaliTreeWalker.g:723:49: (endReg= REGISTER )? 4219 int alt35=2; 4220 int LA35_0 = input.LA(1); 4221 if ( (LA35_0==REGISTER) ) { 4222 alt35=1; 4223 } 4224 switch (alt35) { 4225 case 1 : 4226 // smaliTreeWalker.g:723:49: endReg= REGISTER 4227 { 4228 endReg=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_register_range1885); 4229 } 4230 break; 4231 4232 } 4233 4234 } 4235 break; 4236 4237 } 4238 4239 match(input, Token.UP, null); 4240 } 4241 4242 4243 if (startReg == null) { 4244 retval.startRegister = 0; 4245 retval.endRegister = -1; 4246 } else { 4247 retval.startRegister = parseRegister_short((startReg!=null?startReg.getText():null)); 4248 if (endReg == null) { 4249 retval.endRegister = retval.startRegister; 4250 } else { 4251 retval.endRegister = parseRegister_short((endReg!=null?endReg.getText():null)); 4252 } 4253 4254 int registerCount = retval.endRegister-retval.startRegister+1; 4255 if (registerCount < 1) { 4256 throw new SemanticException(input, I_REGISTER_RANGE109, "A register range must have the lower register listed first"); 4257 } 4258 } 4259 4260 } 4261 4262 } 4263 catch (RecognitionException re) { 4264 reportError(re); 4265 recover(input,re); 4266 } 4267 finally { 4268 // do for sure before leaving 4269 } 4270 return retval; 4271 } 4272 // $ANTLR end "register_range" 4273 4274 4275 4276 // $ANTLR start "verification_error_reference" 4277 // smaliTreeWalker.g:743:1: verification_error_reference returns [ImmutableReference reference] : ( CLASS_DESCRIPTOR | field_reference | method_reference ); verification_error_reference()4278 public final ImmutableReference verification_error_reference() throws RecognitionException { 4279 ImmutableReference reference = null; 4280 4281 4282 CommonTree CLASS_DESCRIPTOR110=null; 4283 TreeRuleReturnScope field_reference111 =null; 4284 ImmutableMethodReference method_reference112 =null; 4285 4286 try { 4287 // smaliTreeWalker.g:744:3: ( CLASS_DESCRIPTOR | field_reference | method_reference ) 4288 int alt37=3; 4289 switch ( input.LA(1) ) { 4290 case CLASS_DESCRIPTOR: 4291 { 4292 int LA37_1 = input.LA(2); 4293 if ( (LA37_1==UP) ) { 4294 alt37=1; 4295 } 4296 else if ( (LA37_1==SIMPLE_NAME) ) { 4297 int LA37_3 = input.LA(3); 4298 if ( (LA37_3==ARRAY_TYPE_PREFIX||LA37_3==CLASS_DESCRIPTOR||LA37_3==PRIMITIVE_TYPE) ) { 4299 alt37=2; 4300 } 4301 else if ( (LA37_3==I_METHOD_PROTOTYPE) ) { 4302 alt37=3; 4303 } 4304 4305 else { 4306 int nvaeMark = input.mark(); 4307 try { 4308 for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) { 4309 input.consume(); 4310 } 4311 NoViableAltException nvae = 4312 new NoViableAltException("", 37, 3, input); 4313 throw nvae; 4314 } finally { 4315 input.rewind(nvaeMark); 4316 } 4317 } 4318 4319 } 4320 4321 else { 4322 int nvaeMark = input.mark(); 4323 try { 4324 input.consume(); 4325 NoViableAltException nvae = 4326 new NoViableAltException("", 37, 1, input); 4327 throw nvae; 4328 } finally { 4329 input.rewind(nvaeMark); 4330 } 4331 } 4332 4333 } 4334 break; 4335 case ARRAY_TYPE_PREFIX: 4336 { 4337 int LA37_2 = input.LA(2); 4338 if ( (LA37_2==PRIMITIVE_TYPE) ) { 4339 int LA37_5 = input.LA(3); 4340 if ( (LA37_5==SIMPLE_NAME) ) { 4341 int LA37_3 = input.LA(4); 4342 if ( (LA37_3==ARRAY_TYPE_PREFIX||LA37_3==CLASS_DESCRIPTOR||LA37_3==PRIMITIVE_TYPE) ) { 4343 alt37=2; 4344 } 4345 else if ( (LA37_3==I_METHOD_PROTOTYPE) ) { 4346 alt37=3; 4347 } 4348 4349 else { 4350 int nvaeMark = input.mark(); 4351 try { 4352 for (int nvaeConsume = 0; nvaeConsume < 4 - 1; nvaeConsume++) { 4353 input.consume(); 4354 } 4355 NoViableAltException nvae = 4356 new NoViableAltException("", 37, 3, input); 4357 throw nvae; 4358 } finally { 4359 input.rewind(nvaeMark); 4360 } 4361 } 4362 4363 } 4364 4365 else { 4366 int nvaeMark = input.mark(); 4367 try { 4368 for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) { 4369 input.consume(); 4370 } 4371 NoViableAltException nvae = 4372 new NoViableAltException("", 37, 5, input); 4373 throw nvae; 4374 } finally { 4375 input.rewind(nvaeMark); 4376 } 4377 } 4378 4379 } 4380 else if ( (LA37_2==CLASS_DESCRIPTOR) ) { 4381 int LA37_6 = input.LA(3); 4382 if ( (LA37_6==SIMPLE_NAME) ) { 4383 int LA37_3 = input.LA(4); 4384 if ( (LA37_3==ARRAY_TYPE_PREFIX||LA37_3==CLASS_DESCRIPTOR||LA37_3==PRIMITIVE_TYPE) ) { 4385 alt37=2; 4386 } 4387 else if ( (LA37_3==I_METHOD_PROTOTYPE) ) { 4388 alt37=3; 4389 } 4390 4391 else { 4392 int nvaeMark = input.mark(); 4393 try { 4394 for (int nvaeConsume = 0; nvaeConsume < 4 - 1; nvaeConsume++) { 4395 input.consume(); 4396 } 4397 NoViableAltException nvae = 4398 new NoViableAltException("", 37, 3, input); 4399 throw nvae; 4400 } finally { 4401 input.rewind(nvaeMark); 4402 } 4403 } 4404 4405 } 4406 4407 else { 4408 int nvaeMark = input.mark(); 4409 try { 4410 for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) { 4411 input.consume(); 4412 } 4413 NoViableAltException nvae = 4414 new NoViableAltException("", 37, 6, input); 4415 throw nvae; 4416 } finally { 4417 input.rewind(nvaeMark); 4418 } 4419 } 4420 4421 } 4422 4423 else { 4424 int nvaeMark = input.mark(); 4425 try { 4426 input.consume(); 4427 NoViableAltException nvae = 4428 new NoViableAltException("", 37, 2, input); 4429 throw nvae; 4430 } finally { 4431 input.rewind(nvaeMark); 4432 } 4433 } 4434 4435 } 4436 break; 4437 case SIMPLE_NAME: 4438 { 4439 int LA37_3 = input.LA(2); 4440 if ( (LA37_3==ARRAY_TYPE_PREFIX||LA37_3==CLASS_DESCRIPTOR||LA37_3==PRIMITIVE_TYPE) ) { 4441 alt37=2; 4442 } 4443 else if ( (LA37_3==I_METHOD_PROTOTYPE) ) { 4444 alt37=3; 4445 } 4446 4447 else { 4448 int nvaeMark = input.mark(); 4449 try { 4450 input.consume(); 4451 NoViableAltException nvae = 4452 new NoViableAltException("", 37, 3, input); 4453 throw nvae; 4454 } finally { 4455 input.rewind(nvaeMark); 4456 } 4457 } 4458 4459 } 4460 break; 4461 default: 4462 NoViableAltException nvae = 4463 new NoViableAltException("", 37, 0, input); 4464 throw nvae; 4465 } 4466 switch (alt37) { 4467 case 1 : 4468 // smaliTreeWalker.g:744:5: CLASS_DESCRIPTOR 4469 { 4470 CLASS_DESCRIPTOR110=(CommonTree)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_verification_error_reference1908); 4471 4472 reference = new ImmutableTypeReference((CLASS_DESCRIPTOR110!=null?CLASS_DESCRIPTOR110.getText():null)); 4473 4474 } 4475 break; 4476 case 2 : 4477 // smaliTreeWalker.g:748:5: field_reference 4478 { 4479 pushFollow(FOLLOW_field_reference_in_verification_error_reference1918); 4480 field_reference111=field_reference(); 4481 state._fsp--; 4482 4483 4484 reference = (field_reference111!=null?((smaliTreeWalker.field_reference_return)field_reference111).fieldReference:null); 4485 4486 } 4487 break; 4488 case 3 : 4489 // smaliTreeWalker.g:752:5: method_reference 4490 { 4491 pushFollow(FOLLOW_method_reference_in_verification_error_reference1928); 4492 method_reference112=method_reference(); 4493 state._fsp--; 4494 4495 4496 reference = method_reference112; 4497 4498 } 4499 break; 4500 4501 } 4502 } 4503 catch (RecognitionException re) { 4504 reportError(re); 4505 recover(input,re); 4506 } 4507 finally { 4508 // do for sure before leaving 4509 } 4510 return reference; 4511 } 4512 // $ANTLR end "verification_error_reference" 4513 4514 4515 4516 // $ANTLR start "verification_error_type" 4517 // smaliTreeWalker.g:757:1: verification_error_type returns [int verificationError] : VERIFICATION_ERROR_TYPE ; verification_error_type()4518 public final int verification_error_type() throws RecognitionException { 4519 int verificationError = 0; 4520 4521 4522 CommonTree VERIFICATION_ERROR_TYPE113=null; 4523 4524 try { 4525 // smaliTreeWalker.g:758:3: ( VERIFICATION_ERROR_TYPE ) 4526 // smaliTreeWalker.g:758:5: VERIFICATION_ERROR_TYPE 4527 { 4528 VERIFICATION_ERROR_TYPE113=(CommonTree)match(input,VERIFICATION_ERROR_TYPE,FOLLOW_VERIFICATION_ERROR_TYPE_in_verification_error_type1945); 4529 4530 verificationError = VerificationError.getVerificationError((VERIFICATION_ERROR_TYPE113!=null?VERIFICATION_ERROR_TYPE113.getText():null)); 4531 4532 } 4533 4534 } 4535 catch (RecognitionException re) { 4536 reportError(re); 4537 recover(input,re); 4538 } 4539 finally { 4540 // do for sure before leaving 4541 } 4542 return verificationError; 4543 } 4544 // $ANTLR end "verification_error_type" 4545 4546 4547 public static class instruction_return extends TreeRuleReturnScope { 4548 }; 4549 4550 4551 // $ANTLR start "instruction" 4552 // smaliTreeWalker.g:763:1: instruction : ( insn_format10t | insn_format10x | insn_format11n | insn_format11x | insn_format12x | insn_format20bc | insn_format20t | insn_format21c_field | insn_format21c_method_handle | insn_format21c_method_type | 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_call_site | insn_format35c_method | insn_format35c_type | insn_format3rc_call_site | insn_format3rc_method | insn_format3rc_type | insn_format45cc_method | insn_format4rcc_method | insn_format51l_type | insn_array_data_directive | insn_packed_switch_directive | insn_sparse_switch_directive ); instruction()4553 public final smaliTreeWalker.instruction_return instruction() throws RecognitionException { 4554 smaliTreeWalker.instruction_return retval = new smaliTreeWalker.instruction_return(); 4555 retval.start = input.LT(1); 4556 4557 try { 4558 // smaliTreeWalker.g:764:3: ( insn_format10t | insn_format10x | insn_format11n | insn_format11x | insn_format12x | insn_format20bc | insn_format20t | insn_format21c_field | insn_format21c_method_handle | insn_format21c_method_type | 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_call_site | insn_format35c_method | insn_format35c_type | insn_format3rc_call_site | insn_format3rc_method | insn_format3rc_type | insn_format45cc_method | insn_format4rcc_method | insn_format51l_type | insn_array_data_directive | insn_packed_switch_directive | insn_sparse_switch_directive ) 4559 int alt38=40; 4560 switch ( input.LA(1) ) { 4561 case I_STATEMENT_FORMAT10t: 4562 { 4563 alt38=1; 4564 } 4565 break; 4566 case I_STATEMENT_FORMAT10x: 4567 { 4568 alt38=2; 4569 } 4570 break; 4571 case I_STATEMENT_FORMAT11n: 4572 { 4573 alt38=3; 4574 } 4575 break; 4576 case I_STATEMENT_FORMAT11x: 4577 { 4578 alt38=4; 4579 } 4580 break; 4581 case I_STATEMENT_FORMAT12x: 4582 { 4583 alt38=5; 4584 } 4585 break; 4586 case I_STATEMENT_FORMAT20bc: 4587 { 4588 alt38=6; 4589 } 4590 break; 4591 case I_STATEMENT_FORMAT20t: 4592 { 4593 alt38=7; 4594 } 4595 break; 4596 case I_STATEMENT_FORMAT21c_FIELD: 4597 { 4598 alt38=8; 4599 } 4600 break; 4601 case I_STATEMENT_FORMAT21c_METHOD_HANDLE: 4602 { 4603 alt38=9; 4604 } 4605 break; 4606 case I_STATEMENT_FORMAT21c_METHOD_TYPE: 4607 { 4608 alt38=10; 4609 } 4610 break; 4611 case I_STATEMENT_FORMAT21c_STRING: 4612 { 4613 alt38=11; 4614 } 4615 break; 4616 case I_STATEMENT_FORMAT21c_TYPE: 4617 { 4618 alt38=12; 4619 } 4620 break; 4621 case I_STATEMENT_FORMAT21ih: 4622 { 4623 alt38=13; 4624 } 4625 break; 4626 case I_STATEMENT_FORMAT21lh: 4627 { 4628 alt38=14; 4629 } 4630 break; 4631 case I_STATEMENT_FORMAT21s: 4632 { 4633 alt38=15; 4634 } 4635 break; 4636 case I_STATEMENT_FORMAT21t: 4637 { 4638 alt38=16; 4639 } 4640 break; 4641 case I_STATEMENT_FORMAT22b: 4642 { 4643 alt38=17; 4644 } 4645 break; 4646 case I_STATEMENT_FORMAT22c_FIELD: 4647 { 4648 alt38=18; 4649 } 4650 break; 4651 case I_STATEMENT_FORMAT22c_TYPE: 4652 { 4653 alt38=19; 4654 } 4655 break; 4656 case I_STATEMENT_FORMAT22s: 4657 { 4658 alt38=20; 4659 } 4660 break; 4661 case I_STATEMENT_FORMAT22t: 4662 { 4663 alt38=21; 4664 } 4665 break; 4666 case I_STATEMENT_FORMAT22x: 4667 { 4668 alt38=22; 4669 } 4670 break; 4671 case I_STATEMENT_FORMAT23x: 4672 { 4673 alt38=23; 4674 } 4675 break; 4676 case I_STATEMENT_FORMAT30t: 4677 { 4678 alt38=24; 4679 } 4680 break; 4681 case I_STATEMENT_FORMAT31c: 4682 { 4683 alt38=25; 4684 } 4685 break; 4686 case I_STATEMENT_FORMAT31i: 4687 { 4688 alt38=26; 4689 } 4690 break; 4691 case I_STATEMENT_FORMAT31t: 4692 { 4693 alt38=27; 4694 } 4695 break; 4696 case I_STATEMENT_FORMAT32x: 4697 { 4698 alt38=28; 4699 } 4700 break; 4701 case I_STATEMENT_FORMAT35c_CALL_SITE: 4702 { 4703 alt38=29; 4704 } 4705 break; 4706 case I_STATEMENT_FORMAT35c_METHOD: 4707 { 4708 alt38=30; 4709 } 4710 break; 4711 case I_STATEMENT_FORMAT35c_TYPE: 4712 { 4713 alt38=31; 4714 } 4715 break; 4716 case I_STATEMENT_FORMAT3rc_CALL_SITE: 4717 { 4718 alt38=32; 4719 } 4720 break; 4721 case I_STATEMENT_FORMAT3rc_METHOD: 4722 { 4723 alt38=33; 4724 } 4725 break; 4726 case I_STATEMENT_FORMAT3rc_TYPE: 4727 { 4728 alt38=34; 4729 } 4730 break; 4731 case I_STATEMENT_FORMAT45cc_METHOD: 4732 { 4733 alt38=35; 4734 } 4735 break; 4736 case I_STATEMENT_FORMAT4rcc_METHOD: 4737 { 4738 alt38=36; 4739 } 4740 break; 4741 case I_STATEMENT_FORMAT51l: 4742 { 4743 alt38=37; 4744 } 4745 break; 4746 case I_STATEMENT_ARRAY_DATA: 4747 { 4748 alt38=38; 4749 } 4750 break; 4751 case I_STATEMENT_PACKED_SWITCH: 4752 { 4753 alt38=39; 4754 } 4755 break; 4756 case I_STATEMENT_SPARSE_SWITCH: 4757 { 4758 alt38=40; 4759 } 4760 break; 4761 default: 4762 NoViableAltException nvae = 4763 new NoViableAltException("", 38, 0, input); 4764 throw nvae; 4765 } 4766 switch (alt38) { 4767 case 1 : 4768 // smaliTreeWalker.g:764:5: insn_format10t 4769 { 4770 pushFollow(FOLLOW_insn_format10t_in_instruction1959); 4771 insn_format10t(); 4772 state._fsp--; 4773 4774 } 4775 break; 4776 case 2 : 4777 // smaliTreeWalker.g:765:5: insn_format10x 4778 { 4779 pushFollow(FOLLOW_insn_format10x_in_instruction1965); 4780 insn_format10x(); 4781 state._fsp--; 4782 4783 } 4784 break; 4785 case 3 : 4786 // smaliTreeWalker.g:766:5: insn_format11n 4787 { 4788 pushFollow(FOLLOW_insn_format11n_in_instruction1971); 4789 insn_format11n(); 4790 state._fsp--; 4791 4792 } 4793 break; 4794 case 4 : 4795 // smaliTreeWalker.g:767:5: insn_format11x 4796 { 4797 pushFollow(FOLLOW_insn_format11x_in_instruction1977); 4798 insn_format11x(); 4799 state._fsp--; 4800 4801 } 4802 break; 4803 case 5 : 4804 // smaliTreeWalker.g:768:5: insn_format12x 4805 { 4806 pushFollow(FOLLOW_insn_format12x_in_instruction1983); 4807 insn_format12x(); 4808 state._fsp--; 4809 4810 } 4811 break; 4812 case 6 : 4813 // smaliTreeWalker.g:769:5: insn_format20bc 4814 { 4815 pushFollow(FOLLOW_insn_format20bc_in_instruction1989); 4816 insn_format20bc(); 4817 state._fsp--; 4818 4819 } 4820 break; 4821 case 7 : 4822 // smaliTreeWalker.g:770:5: insn_format20t 4823 { 4824 pushFollow(FOLLOW_insn_format20t_in_instruction1995); 4825 insn_format20t(); 4826 state._fsp--; 4827 4828 } 4829 break; 4830 case 8 : 4831 // smaliTreeWalker.g:771:5: insn_format21c_field 4832 { 4833 pushFollow(FOLLOW_insn_format21c_field_in_instruction2001); 4834 insn_format21c_field(); 4835 state._fsp--; 4836 4837 } 4838 break; 4839 case 9 : 4840 // smaliTreeWalker.g:772:5: insn_format21c_method_handle 4841 { 4842 pushFollow(FOLLOW_insn_format21c_method_handle_in_instruction2007); 4843 insn_format21c_method_handle(); 4844 state._fsp--; 4845 4846 } 4847 break; 4848 case 10 : 4849 // smaliTreeWalker.g:773:5: insn_format21c_method_type 4850 { 4851 pushFollow(FOLLOW_insn_format21c_method_type_in_instruction2013); 4852 insn_format21c_method_type(); 4853 state._fsp--; 4854 4855 } 4856 break; 4857 case 11 : 4858 // smaliTreeWalker.g:774:5: insn_format21c_string 4859 { 4860 pushFollow(FOLLOW_insn_format21c_string_in_instruction2019); 4861 insn_format21c_string(); 4862 state._fsp--; 4863 4864 } 4865 break; 4866 case 12 : 4867 // smaliTreeWalker.g:775:5: insn_format21c_type 4868 { 4869 pushFollow(FOLLOW_insn_format21c_type_in_instruction2025); 4870 insn_format21c_type(); 4871 state._fsp--; 4872 4873 } 4874 break; 4875 case 13 : 4876 // smaliTreeWalker.g:776:5: insn_format21ih 4877 { 4878 pushFollow(FOLLOW_insn_format21ih_in_instruction2031); 4879 insn_format21ih(); 4880 state._fsp--; 4881 4882 } 4883 break; 4884 case 14 : 4885 // smaliTreeWalker.g:777:5: insn_format21lh 4886 { 4887 pushFollow(FOLLOW_insn_format21lh_in_instruction2037); 4888 insn_format21lh(); 4889 state._fsp--; 4890 4891 } 4892 break; 4893 case 15 : 4894 // smaliTreeWalker.g:778:5: insn_format21s 4895 { 4896 pushFollow(FOLLOW_insn_format21s_in_instruction2043); 4897 insn_format21s(); 4898 state._fsp--; 4899 4900 } 4901 break; 4902 case 16 : 4903 // smaliTreeWalker.g:779:5: insn_format21t 4904 { 4905 pushFollow(FOLLOW_insn_format21t_in_instruction2049); 4906 insn_format21t(); 4907 state._fsp--; 4908 4909 } 4910 break; 4911 case 17 : 4912 // smaliTreeWalker.g:780:5: insn_format22b 4913 { 4914 pushFollow(FOLLOW_insn_format22b_in_instruction2055); 4915 insn_format22b(); 4916 state._fsp--; 4917 4918 } 4919 break; 4920 case 18 : 4921 // smaliTreeWalker.g:781:5: insn_format22c_field 4922 { 4923 pushFollow(FOLLOW_insn_format22c_field_in_instruction2061); 4924 insn_format22c_field(); 4925 state._fsp--; 4926 4927 } 4928 break; 4929 case 19 : 4930 // smaliTreeWalker.g:782:5: insn_format22c_type 4931 { 4932 pushFollow(FOLLOW_insn_format22c_type_in_instruction2067); 4933 insn_format22c_type(); 4934 state._fsp--; 4935 4936 } 4937 break; 4938 case 20 : 4939 // smaliTreeWalker.g:783:5: insn_format22s 4940 { 4941 pushFollow(FOLLOW_insn_format22s_in_instruction2073); 4942 insn_format22s(); 4943 state._fsp--; 4944 4945 } 4946 break; 4947 case 21 : 4948 // smaliTreeWalker.g:784:5: insn_format22t 4949 { 4950 pushFollow(FOLLOW_insn_format22t_in_instruction2079); 4951 insn_format22t(); 4952 state._fsp--; 4953 4954 } 4955 break; 4956 case 22 : 4957 // smaliTreeWalker.g:785:5: insn_format22x 4958 { 4959 pushFollow(FOLLOW_insn_format22x_in_instruction2085); 4960 insn_format22x(); 4961 state._fsp--; 4962 4963 } 4964 break; 4965 case 23 : 4966 // smaliTreeWalker.g:786:5: insn_format23x 4967 { 4968 pushFollow(FOLLOW_insn_format23x_in_instruction2091); 4969 insn_format23x(); 4970 state._fsp--; 4971 4972 } 4973 break; 4974 case 24 : 4975 // smaliTreeWalker.g:787:5: insn_format30t 4976 { 4977 pushFollow(FOLLOW_insn_format30t_in_instruction2097); 4978 insn_format30t(); 4979 state._fsp--; 4980 4981 } 4982 break; 4983 case 25 : 4984 // smaliTreeWalker.g:788:5: insn_format31c 4985 { 4986 pushFollow(FOLLOW_insn_format31c_in_instruction2103); 4987 insn_format31c(); 4988 state._fsp--; 4989 4990 } 4991 break; 4992 case 26 : 4993 // smaliTreeWalker.g:789:5: insn_format31i 4994 { 4995 pushFollow(FOLLOW_insn_format31i_in_instruction2109); 4996 insn_format31i(); 4997 state._fsp--; 4998 4999 } 5000 break; 5001 case 27 : 5002 // smaliTreeWalker.g:790:5: insn_format31t 5003 { 5004 pushFollow(FOLLOW_insn_format31t_in_instruction2115); 5005 insn_format31t(); 5006 state._fsp--; 5007 5008 } 5009 break; 5010 case 28 : 5011 // smaliTreeWalker.g:791:5: insn_format32x 5012 { 5013 pushFollow(FOLLOW_insn_format32x_in_instruction2121); 5014 insn_format32x(); 5015 state._fsp--; 5016 5017 } 5018 break; 5019 case 29 : 5020 // smaliTreeWalker.g:792:5: insn_format35c_call_site 5021 { 5022 pushFollow(FOLLOW_insn_format35c_call_site_in_instruction2127); 5023 insn_format35c_call_site(); 5024 state._fsp--; 5025 5026 } 5027 break; 5028 case 30 : 5029 // smaliTreeWalker.g:793:5: insn_format35c_method 5030 { 5031 pushFollow(FOLLOW_insn_format35c_method_in_instruction2133); 5032 insn_format35c_method(); 5033 state._fsp--; 5034 5035 } 5036 break; 5037 case 31 : 5038 // smaliTreeWalker.g:794:5: insn_format35c_type 5039 { 5040 pushFollow(FOLLOW_insn_format35c_type_in_instruction2139); 5041 insn_format35c_type(); 5042 state._fsp--; 5043 5044 } 5045 break; 5046 case 32 : 5047 // smaliTreeWalker.g:795:5: insn_format3rc_call_site 5048 { 5049 pushFollow(FOLLOW_insn_format3rc_call_site_in_instruction2145); 5050 insn_format3rc_call_site(); 5051 state._fsp--; 5052 5053 } 5054 break; 5055 case 33 : 5056 // smaliTreeWalker.g:796:5: insn_format3rc_method 5057 { 5058 pushFollow(FOLLOW_insn_format3rc_method_in_instruction2151); 5059 insn_format3rc_method(); 5060 state._fsp--; 5061 5062 } 5063 break; 5064 case 34 : 5065 // smaliTreeWalker.g:797:5: insn_format3rc_type 5066 { 5067 pushFollow(FOLLOW_insn_format3rc_type_in_instruction2157); 5068 insn_format3rc_type(); 5069 state._fsp--; 5070 5071 } 5072 break; 5073 case 35 : 5074 // smaliTreeWalker.g:798:5: insn_format45cc_method 5075 { 5076 pushFollow(FOLLOW_insn_format45cc_method_in_instruction2163); 5077 insn_format45cc_method(); 5078 state._fsp--; 5079 5080 } 5081 break; 5082 case 36 : 5083 // smaliTreeWalker.g:799:5: insn_format4rcc_method 5084 { 5085 pushFollow(FOLLOW_insn_format4rcc_method_in_instruction2169); 5086 insn_format4rcc_method(); 5087 state._fsp--; 5088 5089 } 5090 break; 5091 case 37 : 5092 // smaliTreeWalker.g:800:5: insn_format51l_type 5093 { 5094 pushFollow(FOLLOW_insn_format51l_type_in_instruction2175); 5095 insn_format51l_type(); 5096 state._fsp--; 5097 5098 } 5099 break; 5100 case 38 : 5101 // smaliTreeWalker.g:801:5: insn_array_data_directive 5102 { 5103 pushFollow(FOLLOW_insn_array_data_directive_in_instruction2181); 5104 insn_array_data_directive(); 5105 state._fsp--; 5106 5107 } 5108 break; 5109 case 39 : 5110 // smaliTreeWalker.g:802:5: insn_packed_switch_directive 5111 { 5112 pushFollow(FOLLOW_insn_packed_switch_directive_in_instruction2187); 5113 insn_packed_switch_directive(); 5114 state._fsp--; 5115 5116 } 5117 break; 5118 case 40 : 5119 // smaliTreeWalker.g:803:5: insn_sparse_switch_directive 5120 { 5121 pushFollow(FOLLOW_insn_sparse_switch_directive_in_instruction2193); 5122 insn_sparse_switch_directive(); 5123 state._fsp--; 5124 5125 } 5126 break; 5127 5128 } 5129 } 5130 catch (Exception ex) { 5131 5132 reportError(new SemanticException(input, ((CommonTree)retval.start), ex.getMessage())); 5133 recover(input, null); 5134 5135 } 5136 5137 finally { 5138 // do for sure before leaving 5139 } 5140 return retval; 5141 } 5142 // $ANTLR end "instruction" 5143 5144 5145 5146 // $ANTLR start "insn_format10t" 5147 // smaliTreeWalker.g:809:1: insn_format10t : ^( I_STATEMENT_FORMAT10t INSTRUCTION_FORMAT10t label_ref ) ; insn_format10t()5148 public final void insn_format10t() throws RecognitionException { 5149 CommonTree INSTRUCTION_FORMAT10t114=null; 5150 Label label_ref115 =null; 5151 5152 try { 5153 // smaliTreeWalker.g:810:3: ( ^( I_STATEMENT_FORMAT10t INSTRUCTION_FORMAT10t label_ref ) ) 5154 // smaliTreeWalker.g:811:5: ^( I_STATEMENT_FORMAT10t INSTRUCTION_FORMAT10t label_ref ) 5155 { 5156 match(input,I_STATEMENT_FORMAT10t,FOLLOW_I_STATEMENT_FORMAT10t_in_insn_format10t2217); 5157 match(input, Token.DOWN, null); 5158 INSTRUCTION_FORMAT10t114=(CommonTree)match(input,INSTRUCTION_FORMAT10t,FOLLOW_INSTRUCTION_FORMAT10t_in_insn_format10t2219); 5159 pushFollow(FOLLOW_label_ref_in_insn_format10t2221); 5160 label_ref115=label_ref(); 5161 state._fsp--; 5162 5163 match(input, Token.UP, null); 5164 5165 5166 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT10t114!=null?INSTRUCTION_FORMAT10t114.getText():null)); 5167 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction10t(opcode, label_ref115)); 5168 5169 } 5170 5171 } 5172 catch (RecognitionException re) { 5173 reportError(re); 5174 recover(input,re); 5175 } 5176 finally { 5177 // do for sure before leaving 5178 } 5179 } 5180 // $ANTLR end "insn_format10t" 5181 5182 5183 5184 // $ANTLR start "insn_format10x" 5185 // smaliTreeWalker.g:817:1: insn_format10x : ^( I_STATEMENT_FORMAT10x INSTRUCTION_FORMAT10x ) ; insn_format10x()5186 public final void insn_format10x() throws RecognitionException { 5187 CommonTree INSTRUCTION_FORMAT10x116=null; 5188 5189 try { 5190 // smaliTreeWalker.g:818:3: ( ^( I_STATEMENT_FORMAT10x INSTRUCTION_FORMAT10x ) ) 5191 // smaliTreeWalker.g:819:5: ^( I_STATEMENT_FORMAT10x INSTRUCTION_FORMAT10x ) 5192 { 5193 match(input,I_STATEMENT_FORMAT10x,FOLLOW_I_STATEMENT_FORMAT10x_in_insn_format10x2244); 5194 match(input, Token.DOWN, null); 5195 INSTRUCTION_FORMAT10x116=(CommonTree)match(input,INSTRUCTION_FORMAT10x,FOLLOW_INSTRUCTION_FORMAT10x_in_insn_format10x2246); 5196 match(input, Token.UP, null); 5197 5198 5199 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT10x116!=null?INSTRUCTION_FORMAT10x116.getText():null)); 5200 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction10x(opcode)); 5201 5202 } 5203 5204 } 5205 catch (RecognitionException re) { 5206 reportError(re); 5207 recover(input,re); 5208 } 5209 finally { 5210 // do for sure before leaving 5211 } 5212 } 5213 // $ANTLR end "insn_format10x" 5214 5215 5216 5217 // $ANTLR start "insn_format11n" 5218 // smaliTreeWalker.g:825:1: insn_format11n : ^( I_STATEMENT_FORMAT11n INSTRUCTION_FORMAT11n REGISTER short_integral_literal ) ; insn_format11n()5219 public final void insn_format11n() throws RecognitionException { 5220 CommonTree INSTRUCTION_FORMAT11n117=null; 5221 CommonTree REGISTER118=null; 5222 short short_integral_literal119 =0; 5223 5224 try { 5225 // smaliTreeWalker.g:826:3: ( ^( I_STATEMENT_FORMAT11n INSTRUCTION_FORMAT11n REGISTER short_integral_literal ) ) 5226 // smaliTreeWalker.g:827:5: ^( I_STATEMENT_FORMAT11n INSTRUCTION_FORMAT11n REGISTER short_integral_literal ) 5227 { 5228 match(input,I_STATEMENT_FORMAT11n,FOLLOW_I_STATEMENT_FORMAT11n_in_insn_format11n2269); 5229 match(input, Token.DOWN, null); 5230 INSTRUCTION_FORMAT11n117=(CommonTree)match(input,INSTRUCTION_FORMAT11n,FOLLOW_INSTRUCTION_FORMAT11n_in_insn_format11n2271); 5231 REGISTER118=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format11n2273); 5232 pushFollow(FOLLOW_short_integral_literal_in_insn_format11n2275); 5233 short_integral_literal119=short_integral_literal(); 5234 state._fsp--; 5235 5236 match(input, Token.UP, null); 5237 5238 5239 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT11n117!=null?INSTRUCTION_FORMAT11n117.getText():null)); 5240 byte regA = parseRegister_nibble((REGISTER118!=null?REGISTER118.getText():null)); 5241 5242 short litB = short_integral_literal119; 5243 LiteralTools.checkNibble(litB); 5244 5245 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction11n(opcode, regA, litB)); 5246 5247 } 5248 5249 } 5250 catch (RecognitionException re) { 5251 reportError(re); 5252 recover(input,re); 5253 } 5254 finally { 5255 // do for sure before leaving 5256 } 5257 } 5258 // $ANTLR end "insn_format11n" 5259 5260 5261 5262 // $ANTLR start "insn_format11x" 5263 // smaliTreeWalker.g:838:1: insn_format11x : ^( I_STATEMENT_FORMAT11x INSTRUCTION_FORMAT11x REGISTER ) ; insn_format11x()5264 public final void insn_format11x() throws RecognitionException { 5265 CommonTree INSTRUCTION_FORMAT11x120=null; 5266 CommonTree REGISTER121=null; 5267 5268 try { 5269 // smaliTreeWalker.g:839:3: ( ^( I_STATEMENT_FORMAT11x INSTRUCTION_FORMAT11x REGISTER ) ) 5270 // smaliTreeWalker.g:840:5: ^( I_STATEMENT_FORMAT11x INSTRUCTION_FORMAT11x REGISTER ) 5271 { 5272 match(input,I_STATEMENT_FORMAT11x,FOLLOW_I_STATEMENT_FORMAT11x_in_insn_format11x2298); 5273 match(input, Token.DOWN, null); 5274 INSTRUCTION_FORMAT11x120=(CommonTree)match(input,INSTRUCTION_FORMAT11x,FOLLOW_INSTRUCTION_FORMAT11x_in_insn_format11x2300); 5275 REGISTER121=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format11x2302); 5276 match(input, Token.UP, null); 5277 5278 5279 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT11x120!=null?INSTRUCTION_FORMAT11x120.getText():null)); 5280 short regA = parseRegister_byte((REGISTER121!=null?REGISTER121.getText():null)); 5281 5282 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction11x(opcode, regA)); 5283 5284 } 5285 5286 } 5287 catch (RecognitionException re) { 5288 reportError(re); 5289 recover(input,re); 5290 } 5291 finally { 5292 // do for sure before leaving 5293 } 5294 } 5295 // $ANTLR end "insn_format11x" 5296 5297 5298 5299 // $ANTLR start "insn_format12x" 5300 // smaliTreeWalker.g:848:1: insn_format12x : ^( I_STATEMENT_FORMAT12x INSTRUCTION_FORMAT12x registerA= REGISTER registerB= REGISTER ) ; insn_format12x()5301 public final void insn_format12x() throws RecognitionException { 5302 CommonTree registerA=null; 5303 CommonTree registerB=null; 5304 CommonTree INSTRUCTION_FORMAT12x122=null; 5305 5306 try { 5307 // smaliTreeWalker.g:849:3: ( ^( I_STATEMENT_FORMAT12x INSTRUCTION_FORMAT12x registerA= REGISTER registerB= REGISTER ) ) 5308 // smaliTreeWalker.g:850:5: ^( I_STATEMENT_FORMAT12x INSTRUCTION_FORMAT12x registerA= REGISTER registerB= REGISTER ) 5309 { 5310 match(input,I_STATEMENT_FORMAT12x,FOLLOW_I_STATEMENT_FORMAT12x_in_insn_format12x2325); 5311 match(input, Token.DOWN, null); 5312 INSTRUCTION_FORMAT12x122=(CommonTree)match(input,INSTRUCTION_FORMAT12x,FOLLOW_INSTRUCTION_FORMAT12x_in_insn_format12x2327); 5313 registerA=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format12x2331); 5314 registerB=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format12x2335); 5315 match(input, Token.UP, null); 5316 5317 5318 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT12x122!=null?INSTRUCTION_FORMAT12x122.getText():null)); 5319 byte regA = parseRegister_nibble((registerA!=null?registerA.getText():null)); 5320 byte regB = parseRegister_nibble((registerB!=null?registerB.getText():null)); 5321 5322 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction12x(opcode, regA, regB)); 5323 5324 } 5325 5326 } 5327 catch (RecognitionException re) { 5328 reportError(re); 5329 recover(input,re); 5330 } 5331 finally { 5332 // do for sure before leaving 5333 } 5334 } 5335 // $ANTLR end "insn_format12x" 5336 5337 5338 5339 // $ANTLR start "insn_format20bc" 5340 // smaliTreeWalker.g:859:1: insn_format20bc : ^( I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc verification_error_type verification_error_reference ) ; insn_format20bc()5341 public final void insn_format20bc() throws RecognitionException { 5342 CommonTree INSTRUCTION_FORMAT20bc123=null; 5343 int verification_error_type124 =0; 5344 ImmutableReference verification_error_reference125 =null; 5345 5346 try { 5347 // smaliTreeWalker.g:860:3: ( ^( I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc verification_error_type verification_error_reference ) ) 5348 // smaliTreeWalker.g:861:5: ^( I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc verification_error_type verification_error_reference ) 5349 { 5350 match(input,I_STATEMENT_FORMAT20bc,FOLLOW_I_STATEMENT_FORMAT20bc_in_insn_format20bc2358); 5351 match(input, Token.DOWN, null); 5352 INSTRUCTION_FORMAT20bc123=(CommonTree)match(input,INSTRUCTION_FORMAT20bc,FOLLOW_INSTRUCTION_FORMAT20bc_in_insn_format20bc2360); 5353 pushFollow(FOLLOW_verification_error_type_in_insn_format20bc2362); 5354 verification_error_type124=verification_error_type(); 5355 state._fsp--; 5356 5357 pushFollow(FOLLOW_verification_error_reference_in_insn_format20bc2364); 5358 verification_error_reference125=verification_error_reference(); 5359 state._fsp--; 5360 5361 match(input, Token.UP, null); 5362 5363 5364 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT20bc123!=null?INSTRUCTION_FORMAT20bc123.getText():null)); 5365 5366 int verificationError = verification_error_type124; 5367 ImmutableReference referencedItem = verification_error_reference125; 5368 5369 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction20bc(opcode, verificationError, 5370 dexBuilder.internReference(referencedItem))); 5371 5372 } 5373 5374 } 5375 catch (RecognitionException re) { 5376 reportError(re); 5377 recover(input,re); 5378 } 5379 finally { 5380 // do for sure before leaving 5381 } 5382 } 5383 // $ANTLR end "insn_format20bc" 5384 5385 5386 5387 // $ANTLR start "insn_format20t" 5388 // smaliTreeWalker.g:872:1: insn_format20t : ^( I_STATEMENT_FORMAT20t INSTRUCTION_FORMAT20t label_ref ) ; insn_format20t()5389 public final void insn_format20t() throws RecognitionException { 5390 CommonTree INSTRUCTION_FORMAT20t126=null; 5391 Label label_ref127 =null; 5392 5393 try { 5394 // smaliTreeWalker.g:873:3: ( ^( I_STATEMENT_FORMAT20t INSTRUCTION_FORMAT20t label_ref ) ) 5395 // smaliTreeWalker.g:874:5: ^( I_STATEMENT_FORMAT20t INSTRUCTION_FORMAT20t label_ref ) 5396 { 5397 match(input,I_STATEMENT_FORMAT20t,FOLLOW_I_STATEMENT_FORMAT20t_in_insn_format20t2387); 5398 match(input, Token.DOWN, null); 5399 INSTRUCTION_FORMAT20t126=(CommonTree)match(input,INSTRUCTION_FORMAT20t,FOLLOW_INSTRUCTION_FORMAT20t_in_insn_format20t2389); 5400 pushFollow(FOLLOW_label_ref_in_insn_format20t2391); 5401 label_ref127=label_ref(); 5402 state._fsp--; 5403 5404 match(input, Token.UP, null); 5405 5406 5407 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT20t126!=null?INSTRUCTION_FORMAT20t126.getText():null)); 5408 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction20t(opcode, label_ref127)); 5409 5410 } 5411 5412 } 5413 catch (RecognitionException re) { 5414 reportError(re); 5415 recover(input,re); 5416 } 5417 finally { 5418 // do for sure before leaving 5419 } 5420 } 5421 // $ANTLR end "insn_format20t" 5422 5423 5424 5425 // $ANTLR start "insn_format21c_field" 5426 // smaliTreeWalker.g:880:1: insn_format21c_field : ^( I_STATEMENT_FORMAT21c_FIELD inst= ( INSTRUCTION_FORMAT21c_FIELD | INSTRUCTION_FORMAT21c_FIELD_ODEX ) REGISTER field_reference ) ; insn_format21c_field()5427 public final void insn_format21c_field() throws RecognitionException { 5428 CommonTree inst=null; 5429 CommonTree REGISTER128=null; 5430 TreeRuleReturnScope field_reference129 =null; 5431 5432 try { 5433 // smaliTreeWalker.g:881:3: ( ^( I_STATEMENT_FORMAT21c_FIELD inst= ( INSTRUCTION_FORMAT21c_FIELD | INSTRUCTION_FORMAT21c_FIELD_ODEX ) REGISTER field_reference ) ) 5434 // smaliTreeWalker.g:882:5: ^( I_STATEMENT_FORMAT21c_FIELD inst= ( INSTRUCTION_FORMAT21c_FIELD | INSTRUCTION_FORMAT21c_FIELD_ODEX ) REGISTER field_reference ) 5435 { 5436 match(input,I_STATEMENT_FORMAT21c_FIELD,FOLLOW_I_STATEMENT_FORMAT21c_FIELD_in_insn_format21c_field2414); 5437 match(input, Token.DOWN, null); 5438 inst=(CommonTree)input.LT(1); 5439 if ( (input.LA(1) >= INSTRUCTION_FORMAT21c_FIELD && input.LA(1) <= INSTRUCTION_FORMAT21c_FIELD_ODEX) ) { 5440 input.consume(); 5441 state.errorRecovery=false; 5442 } 5443 else { 5444 MismatchedSetException mse = new MismatchedSetException(null,input); 5445 throw mse; 5446 } 5447 REGISTER128=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_field2426); 5448 pushFollow(FOLLOW_field_reference_in_insn_format21c_field2428); 5449 field_reference129=field_reference(); 5450 state._fsp--; 5451 5452 match(input, Token.UP, null); 5453 5454 5455 Opcode opcode = opcodes.getOpcodeByName((inst!=null?inst.getText():null)); 5456 short regA = parseRegister_byte((REGISTER128!=null?REGISTER128.getText():null)); 5457 5458 ImmutableFieldReference fieldReference = (field_reference129!=null?((smaliTreeWalker.field_reference_return)field_reference129).fieldReference:null); 5459 5460 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction21c(opcode, regA, 5461 dexBuilder.internFieldReference(fieldReference))); 5462 5463 } 5464 5465 } 5466 catch (RecognitionException re) { 5467 reportError(re); 5468 recover(input,re); 5469 } 5470 finally { 5471 // do for sure before leaving 5472 } 5473 } 5474 // $ANTLR end "insn_format21c_field" 5475 5476 5477 5478 // $ANTLR start "insn_format21c_method_handle" 5479 // smaliTreeWalker.g:893:1: insn_format21c_method_handle : ^( I_STATEMENT_FORMAT21c_METHOD_HANDLE inst= ( INSTRUCTION_FORMAT21c_METHOD_HANDLE ) REGISTER method_handle_reference ) ; insn_format21c_method_handle()5480 public final void insn_format21c_method_handle() throws RecognitionException { 5481 CommonTree inst=null; 5482 CommonTree REGISTER130=null; 5483 ImmutableMethodHandleReference method_handle_reference131 =null; 5484 5485 try { 5486 // smaliTreeWalker.g:894:3: ( ^( I_STATEMENT_FORMAT21c_METHOD_HANDLE inst= ( INSTRUCTION_FORMAT21c_METHOD_HANDLE ) REGISTER method_handle_reference ) ) 5487 // smaliTreeWalker.g:895:5: ^( I_STATEMENT_FORMAT21c_METHOD_HANDLE inst= ( INSTRUCTION_FORMAT21c_METHOD_HANDLE ) REGISTER method_handle_reference ) 5488 { 5489 match(input,I_STATEMENT_FORMAT21c_METHOD_HANDLE,FOLLOW_I_STATEMENT_FORMAT21c_METHOD_HANDLE_in_insn_format21c_method_handle2451); 5490 match(input, Token.DOWN, null); 5491 // smaliTreeWalker.g:895:48: ( INSTRUCTION_FORMAT21c_METHOD_HANDLE ) 5492 // smaliTreeWalker.g:895:49: INSTRUCTION_FORMAT21c_METHOD_HANDLE 5493 { 5494 inst=(CommonTree)match(input,INSTRUCTION_FORMAT21c_METHOD_HANDLE,FOLLOW_INSTRUCTION_FORMAT21c_METHOD_HANDLE_in_insn_format21c_method_handle2456); 5495 } 5496 5497 REGISTER130=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_method_handle2459); 5498 pushFollow(FOLLOW_method_handle_reference_in_insn_format21c_method_handle2461); 5499 method_handle_reference131=method_handle_reference(); 5500 state._fsp--; 5501 5502 match(input, Token.UP, null); 5503 5504 5505 Opcode opcode = opcodes.getOpcodeByName((inst!=null?inst.getText():null)); 5506 short regA = parseRegister_byte((REGISTER130!=null?REGISTER130.getText():null)); 5507 5508 ImmutableMethodHandleReference methodHandleReference = method_handle_reference131; 5509 5510 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction21c(opcode, regA, 5511 dexBuilder.internMethodHandle(methodHandleReference))); 5512 5513 } 5514 5515 } 5516 catch (RecognitionException re) { 5517 reportError(re); 5518 recover(input,re); 5519 } 5520 finally { 5521 // do for sure before leaving 5522 } 5523 } 5524 // $ANTLR end "insn_format21c_method_handle" 5525 5526 5527 5528 // $ANTLR start "insn_format21c_method_type" 5529 // smaliTreeWalker.g:906:1: insn_format21c_method_type : ^( I_STATEMENT_FORMAT21c_METHOD_TYPE inst= ( INSTRUCTION_FORMAT21c_METHOD_TYPE ) REGISTER method_prototype ) ; insn_format21c_method_type()5530 public final void insn_format21c_method_type() throws RecognitionException { 5531 CommonTree inst=null; 5532 CommonTree REGISTER132=null; 5533 ImmutableMethodProtoReference method_prototype133 =null; 5534 5535 try { 5536 // smaliTreeWalker.g:907:3: ( ^( I_STATEMENT_FORMAT21c_METHOD_TYPE inst= ( INSTRUCTION_FORMAT21c_METHOD_TYPE ) REGISTER method_prototype ) ) 5537 // smaliTreeWalker.g:908:5: ^( I_STATEMENT_FORMAT21c_METHOD_TYPE inst= ( INSTRUCTION_FORMAT21c_METHOD_TYPE ) REGISTER method_prototype ) 5538 { 5539 match(input,I_STATEMENT_FORMAT21c_METHOD_TYPE,FOLLOW_I_STATEMENT_FORMAT21c_METHOD_TYPE_in_insn_format21c_method_type2484); 5540 match(input, Token.DOWN, null); 5541 // smaliTreeWalker.g:908:46: ( INSTRUCTION_FORMAT21c_METHOD_TYPE ) 5542 // smaliTreeWalker.g:908:47: INSTRUCTION_FORMAT21c_METHOD_TYPE 5543 { 5544 inst=(CommonTree)match(input,INSTRUCTION_FORMAT21c_METHOD_TYPE,FOLLOW_INSTRUCTION_FORMAT21c_METHOD_TYPE_in_insn_format21c_method_type2489); 5545 } 5546 5547 REGISTER132=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_method_type2492); 5548 pushFollow(FOLLOW_method_prototype_in_insn_format21c_method_type2494); 5549 method_prototype133=method_prototype(); 5550 state._fsp--; 5551 5552 match(input, Token.UP, null); 5553 5554 5555 Opcode opcode = opcodes.getOpcodeByName((inst!=null?inst.getText():null)); 5556 short regA = parseRegister_byte((REGISTER132!=null?REGISTER132.getText():null)); 5557 5558 ImmutableMethodProtoReference methodProtoReference = method_prototype133; 5559 5560 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction21c(opcode, regA, 5561 dexBuilder.internMethodProtoReference(methodProtoReference))); 5562 5563 } 5564 5565 } 5566 catch (RecognitionException re) { 5567 reportError(re); 5568 recover(input,re); 5569 } 5570 finally { 5571 // do for sure before leaving 5572 } 5573 } 5574 // $ANTLR end "insn_format21c_method_type" 5575 5576 5577 5578 // $ANTLR start "insn_format21c_string" 5579 // smaliTreeWalker.g:919:1: insn_format21c_string : ^( I_STATEMENT_FORMAT21c_STRING INSTRUCTION_FORMAT21c_STRING REGISTER string_literal ) ; insn_format21c_string()5580 public final void insn_format21c_string() throws RecognitionException { 5581 CommonTree INSTRUCTION_FORMAT21c_STRING134=null; 5582 CommonTree REGISTER135=null; 5583 String string_literal136 =null; 5584 5585 try { 5586 // smaliTreeWalker.g:920:3: ( ^( I_STATEMENT_FORMAT21c_STRING INSTRUCTION_FORMAT21c_STRING REGISTER string_literal ) ) 5587 // smaliTreeWalker.g:921:5: ^( I_STATEMENT_FORMAT21c_STRING INSTRUCTION_FORMAT21c_STRING REGISTER string_literal ) 5588 { 5589 match(input,I_STATEMENT_FORMAT21c_STRING,FOLLOW_I_STATEMENT_FORMAT21c_STRING_in_insn_format21c_string2517); 5590 match(input, Token.DOWN, null); 5591 INSTRUCTION_FORMAT21c_STRING134=(CommonTree)match(input,INSTRUCTION_FORMAT21c_STRING,FOLLOW_INSTRUCTION_FORMAT21c_STRING_in_insn_format21c_string2519); 5592 REGISTER135=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_string2521); 5593 pushFollow(FOLLOW_string_literal_in_insn_format21c_string2523); 5594 string_literal136=string_literal(); 5595 state._fsp--; 5596 5597 match(input, Token.UP, null); 5598 5599 5600 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT21c_STRING134!=null?INSTRUCTION_FORMAT21c_STRING134.getText():null)); 5601 short regA = parseRegister_byte((REGISTER135!=null?REGISTER135.getText():null)); 5602 5603 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction21c(opcode, regA, 5604 dexBuilder.internStringReference(string_literal136))); 5605 5606 } 5607 5608 } 5609 catch (RecognitionException re) { 5610 reportError(re); 5611 recover(input,re); 5612 } 5613 finally { 5614 // do for sure before leaving 5615 } 5616 } 5617 // $ANTLR end "insn_format21c_string" 5618 5619 5620 5621 // $ANTLR start "insn_format21c_type" 5622 // smaliTreeWalker.g:930:1: insn_format21c_type : ^( I_STATEMENT_FORMAT21c_TYPE INSTRUCTION_FORMAT21c_TYPE REGISTER nonvoid_type_descriptor ) ; insn_format21c_type()5623 public final void insn_format21c_type() throws RecognitionException { 5624 CommonTree INSTRUCTION_FORMAT21c_TYPE137=null; 5625 CommonTree REGISTER138=null; 5626 TreeRuleReturnScope nonvoid_type_descriptor139 =null; 5627 5628 try { 5629 // smaliTreeWalker.g:931:3: ( ^( I_STATEMENT_FORMAT21c_TYPE INSTRUCTION_FORMAT21c_TYPE REGISTER nonvoid_type_descriptor ) ) 5630 // smaliTreeWalker.g:932:5: ^( I_STATEMENT_FORMAT21c_TYPE INSTRUCTION_FORMAT21c_TYPE REGISTER nonvoid_type_descriptor ) 5631 { 5632 match(input,I_STATEMENT_FORMAT21c_TYPE,FOLLOW_I_STATEMENT_FORMAT21c_TYPE_in_insn_format21c_type2546); 5633 match(input, Token.DOWN, null); 5634 INSTRUCTION_FORMAT21c_TYPE137=(CommonTree)match(input,INSTRUCTION_FORMAT21c_TYPE,FOLLOW_INSTRUCTION_FORMAT21c_TYPE_in_insn_format21c_type2548); 5635 REGISTER138=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_type2550); 5636 pushFollow(FOLLOW_nonvoid_type_descriptor_in_insn_format21c_type2552); 5637 nonvoid_type_descriptor139=nonvoid_type_descriptor(); 5638 state._fsp--; 5639 5640 match(input, Token.UP, null); 5641 5642 5643 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT21c_TYPE137!=null?INSTRUCTION_FORMAT21c_TYPE137.getText():null)); 5644 short regA = parseRegister_byte((REGISTER138!=null?REGISTER138.getText():null)); 5645 5646 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction21c(opcode, regA, 5647 dexBuilder.internTypeReference((nonvoid_type_descriptor139!=null?((smaliTreeWalker.nonvoid_type_descriptor_return)nonvoid_type_descriptor139).type:null)))); 5648 5649 } 5650 5651 } 5652 catch (RecognitionException re) { 5653 reportError(re); 5654 recover(input,re); 5655 } 5656 finally { 5657 // do for sure before leaving 5658 } 5659 } 5660 // $ANTLR end "insn_format21c_type" 5661 5662 5663 5664 // $ANTLR start "insn_format21ih" 5665 // smaliTreeWalker.g:941:1: insn_format21ih : ^( I_STATEMENT_FORMAT21ih INSTRUCTION_FORMAT21ih REGISTER fixed_32bit_literal ) ; insn_format21ih()5666 public final void insn_format21ih() throws RecognitionException { 5667 CommonTree INSTRUCTION_FORMAT21ih140=null; 5668 CommonTree REGISTER141=null; 5669 int fixed_32bit_literal142 =0; 5670 5671 try { 5672 // smaliTreeWalker.g:942:3: ( ^( I_STATEMENT_FORMAT21ih INSTRUCTION_FORMAT21ih REGISTER fixed_32bit_literal ) ) 5673 // smaliTreeWalker.g:943:5: ^( I_STATEMENT_FORMAT21ih INSTRUCTION_FORMAT21ih REGISTER fixed_32bit_literal ) 5674 { 5675 match(input,I_STATEMENT_FORMAT21ih,FOLLOW_I_STATEMENT_FORMAT21ih_in_insn_format21ih2575); 5676 match(input, Token.DOWN, null); 5677 INSTRUCTION_FORMAT21ih140=(CommonTree)match(input,INSTRUCTION_FORMAT21ih,FOLLOW_INSTRUCTION_FORMAT21ih_in_insn_format21ih2577); 5678 REGISTER141=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21ih2579); 5679 pushFollow(FOLLOW_fixed_32bit_literal_in_insn_format21ih2581); 5680 fixed_32bit_literal142=fixed_32bit_literal(); 5681 state._fsp--; 5682 5683 match(input, Token.UP, null); 5684 5685 5686 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT21ih140!=null?INSTRUCTION_FORMAT21ih140.getText():null)); 5687 short regA = parseRegister_byte((REGISTER141!=null?REGISTER141.getText():null)); 5688 5689 int litB = fixed_32bit_literal142; 5690 5691 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction21ih(opcode, regA, litB)); 5692 5693 } 5694 5695 } 5696 catch (RecognitionException re) { 5697 reportError(re); 5698 recover(input,re); 5699 } 5700 finally { 5701 // do for sure before leaving 5702 } 5703 } 5704 // $ANTLR end "insn_format21ih" 5705 5706 5707 5708 // $ANTLR start "insn_format21lh" 5709 // smaliTreeWalker.g:953:1: insn_format21lh : ^( I_STATEMENT_FORMAT21lh INSTRUCTION_FORMAT21lh REGISTER fixed_64bit_literal ) ; insn_format21lh()5710 public final void insn_format21lh() throws RecognitionException { 5711 CommonTree INSTRUCTION_FORMAT21lh143=null; 5712 CommonTree REGISTER144=null; 5713 long fixed_64bit_literal145 =0; 5714 5715 try { 5716 // smaliTreeWalker.g:954:3: ( ^( I_STATEMENT_FORMAT21lh INSTRUCTION_FORMAT21lh REGISTER fixed_64bit_literal ) ) 5717 // smaliTreeWalker.g:955:5: ^( I_STATEMENT_FORMAT21lh INSTRUCTION_FORMAT21lh REGISTER fixed_64bit_literal ) 5718 { 5719 match(input,I_STATEMENT_FORMAT21lh,FOLLOW_I_STATEMENT_FORMAT21lh_in_insn_format21lh2604); 5720 match(input, Token.DOWN, null); 5721 INSTRUCTION_FORMAT21lh143=(CommonTree)match(input,INSTRUCTION_FORMAT21lh,FOLLOW_INSTRUCTION_FORMAT21lh_in_insn_format21lh2606); 5722 REGISTER144=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21lh2608); 5723 pushFollow(FOLLOW_fixed_64bit_literal_in_insn_format21lh2610); 5724 fixed_64bit_literal145=fixed_64bit_literal(); 5725 state._fsp--; 5726 5727 match(input, Token.UP, null); 5728 5729 5730 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT21lh143!=null?INSTRUCTION_FORMAT21lh143.getText():null)); 5731 short regA = parseRegister_byte((REGISTER144!=null?REGISTER144.getText():null)); 5732 5733 long litB = fixed_64bit_literal145; 5734 5735 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction21lh(opcode, regA, litB)); 5736 5737 } 5738 5739 } 5740 catch (RecognitionException re) { 5741 reportError(re); 5742 recover(input,re); 5743 } 5744 finally { 5745 // do for sure before leaving 5746 } 5747 } 5748 // $ANTLR end "insn_format21lh" 5749 5750 5751 5752 // $ANTLR start "insn_format21s" 5753 // smaliTreeWalker.g:965:1: insn_format21s : ^( I_STATEMENT_FORMAT21s INSTRUCTION_FORMAT21s REGISTER short_integral_literal ) ; insn_format21s()5754 public final void insn_format21s() throws RecognitionException { 5755 CommonTree INSTRUCTION_FORMAT21s146=null; 5756 CommonTree REGISTER147=null; 5757 short short_integral_literal148 =0; 5758 5759 try { 5760 // smaliTreeWalker.g:966:3: ( ^( I_STATEMENT_FORMAT21s INSTRUCTION_FORMAT21s REGISTER short_integral_literal ) ) 5761 // smaliTreeWalker.g:967:5: ^( I_STATEMENT_FORMAT21s INSTRUCTION_FORMAT21s REGISTER short_integral_literal ) 5762 { 5763 match(input,I_STATEMENT_FORMAT21s,FOLLOW_I_STATEMENT_FORMAT21s_in_insn_format21s2633); 5764 match(input, Token.DOWN, null); 5765 INSTRUCTION_FORMAT21s146=(CommonTree)match(input,INSTRUCTION_FORMAT21s,FOLLOW_INSTRUCTION_FORMAT21s_in_insn_format21s2635); 5766 REGISTER147=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21s2637); 5767 pushFollow(FOLLOW_short_integral_literal_in_insn_format21s2639); 5768 short_integral_literal148=short_integral_literal(); 5769 state._fsp--; 5770 5771 match(input, Token.UP, null); 5772 5773 5774 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT21s146!=null?INSTRUCTION_FORMAT21s146.getText():null)); 5775 short regA = parseRegister_byte((REGISTER147!=null?REGISTER147.getText():null)); 5776 5777 short litB = short_integral_literal148; 5778 5779 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction21s(opcode, regA, litB)); 5780 5781 } 5782 5783 } 5784 catch (RecognitionException re) { 5785 reportError(re); 5786 recover(input,re); 5787 } 5788 finally { 5789 // do for sure before leaving 5790 } 5791 } 5792 // $ANTLR end "insn_format21s" 5793 5794 5795 5796 // $ANTLR start "insn_format21t" 5797 // smaliTreeWalker.g:977:1: insn_format21t : ^( I_STATEMENT_FORMAT21t INSTRUCTION_FORMAT21t REGISTER label_ref ) ; insn_format21t()5798 public final void insn_format21t() throws RecognitionException { 5799 CommonTree INSTRUCTION_FORMAT21t149=null; 5800 CommonTree REGISTER150=null; 5801 Label label_ref151 =null; 5802 5803 try { 5804 // smaliTreeWalker.g:978:3: ( ^( I_STATEMENT_FORMAT21t INSTRUCTION_FORMAT21t REGISTER label_ref ) ) 5805 // smaliTreeWalker.g:979:5: ^( I_STATEMENT_FORMAT21t INSTRUCTION_FORMAT21t REGISTER label_ref ) 5806 { 5807 match(input,I_STATEMENT_FORMAT21t,FOLLOW_I_STATEMENT_FORMAT21t_in_insn_format21t2662); 5808 match(input, Token.DOWN, null); 5809 INSTRUCTION_FORMAT21t149=(CommonTree)match(input,INSTRUCTION_FORMAT21t,FOLLOW_INSTRUCTION_FORMAT21t_in_insn_format21t2664); 5810 REGISTER150=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21t2666); 5811 pushFollow(FOLLOW_label_ref_in_insn_format21t2668); 5812 label_ref151=label_ref(); 5813 state._fsp--; 5814 5815 match(input, Token.UP, null); 5816 5817 5818 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT21t149!=null?INSTRUCTION_FORMAT21t149.getText():null)); 5819 short regA = parseRegister_byte((REGISTER150!=null?REGISTER150.getText():null)); 5820 5821 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction21t(opcode, regA, label_ref151)); 5822 5823 } 5824 5825 } 5826 catch (RecognitionException re) { 5827 reportError(re); 5828 recover(input,re); 5829 } 5830 finally { 5831 // do for sure before leaving 5832 } 5833 } 5834 // $ANTLR end "insn_format21t" 5835 5836 5837 5838 // $ANTLR start "insn_format22b" 5839 // smaliTreeWalker.g:987:1: insn_format22b : ^( I_STATEMENT_FORMAT22b INSTRUCTION_FORMAT22b registerA= REGISTER registerB= REGISTER short_integral_literal ) ; insn_format22b()5840 public final void insn_format22b() throws RecognitionException { 5841 CommonTree registerA=null; 5842 CommonTree registerB=null; 5843 CommonTree INSTRUCTION_FORMAT22b152=null; 5844 short short_integral_literal153 =0; 5845 5846 try { 5847 // smaliTreeWalker.g:988:3: ( ^( I_STATEMENT_FORMAT22b INSTRUCTION_FORMAT22b registerA= REGISTER registerB= REGISTER short_integral_literal ) ) 5848 // smaliTreeWalker.g:989:5: ^( I_STATEMENT_FORMAT22b INSTRUCTION_FORMAT22b registerA= REGISTER registerB= REGISTER short_integral_literal ) 5849 { 5850 match(input,I_STATEMENT_FORMAT22b,FOLLOW_I_STATEMENT_FORMAT22b_in_insn_format22b2691); 5851 match(input, Token.DOWN, null); 5852 INSTRUCTION_FORMAT22b152=(CommonTree)match(input,INSTRUCTION_FORMAT22b,FOLLOW_INSTRUCTION_FORMAT22b_in_insn_format22b2693); 5853 registerA=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22b2697); 5854 registerB=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22b2701); 5855 pushFollow(FOLLOW_short_integral_literal_in_insn_format22b2703); 5856 short_integral_literal153=short_integral_literal(); 5857 state._fsp--; 5858 5859 match(input, Token.UP, null); 5860 5861 5862 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT22b152!=null?INSTRUCTION_FORMAT22b152.getText():null)); 5863 short regA = parseRegister_byte((registerA!=null?registerA.getText():null)); 5864 short regB = parseRegister_byte((registerB!=null?registerB.getText():null)); 5865 5866 short litC = short_integral_literal153; 5867 LiteralTools.checkByte(litC); 5868 5869 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction22b(opcode, regA, regB, litC)); 5870 5871 } 5872 5873 } 5874 catch (RecognitionException re) { 5875 reportError(re); 5876 recover(input,re); 5877 } 5878 finally { 5879 // do for sure before leaving 5880 } 5881 } 5882 // $ANTLR end "insn_format22b" 5883 5884 5885 5886 // $ANTLR start "insn_format22c_field" 5887 // smaliTreeWalker.g:1001:1: insn_format22c_field : ^( I_STATEMENT_FORMAT22c_FIELD inst= ( INSTRUCTION_FORMAT22c_FIELD | INSTRUCTION_FORMAT22c_FIELD_ODEX ) registerA= REGISTER registerB= REGISTER field_reference ) ; insn_format22c_field()5888 public final void insn_format22c_field() throws RecognitionException { 5889 CommonTree inst=null; 5890 CommonTree registerA=null; 5891 CommonTree registerB=null; 5892 TreeRuleReturnScope field_reference154 =null; 5893 5894 try { 5895 // smaliTreeWalker.g:1002:3: ( ^( I_STATEMENT_FORMAT22c_FIELD inst= ( INSTRUCTION_FORMAT22c_FIELD | INSTRUCTION_FORMAT22c_FIELD_ODEX ) registerA= REGISTER registerB= REGISTER field_reference ) ) 5896 // smaliTreeWalker.g:1003:5: ^( I_STATEMENT_FORMAT22c_FIELD inst= ( INSTRUCTION_FORMAT22c_FIELD | INSTRUCTION_FORMAT22c_FIELD_ODEX ) registerA= REGISTER registerB= REGISTER field_reference ) 5897 { 5898 match(input,I_STATEMENT_FORMAT22c_FIELD,FOLLOW_I_STATEMENT_FORMAT22c_FIELD_in_insn_format22c_field2726); 5899 match(input, Token.DOWN, null); 5900 inst=(CommonTree)input.LT(1); 5901 if ( (input.LA(1) >= INSTRUCTION_FORMAT22c_FIELD && input.LA(1) <= INSTRUCTION_FORMAT22c_FIELD_ODEX) ) { 5902 input.consume(); 5903 state.errorRecovery=false; 5904 } 5905 else { 5906 MismatchedSetException mse = new MismatchedSetException(null,input); 5907 throw mse; 5908 } 5909 registerA=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_field2740); 5910 registerB=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_field2744); 5911 pushFollow(FOLLOW_field_reference_in_insn_format22c_field2746); 5912 field_reference154=field_reference(); 5913 state._fsp--; 5914 5915 match(input, Token.UP, null); 5916 5917 5918 Opcode opcode = opcodes.getOpcodeByName((inst!=null?inst.getText():null)); 5919 byte regA = parseRegister_nibble((registerA!=null?registerA.getText():null)); 5920 byte regB = parseRegister_nibble((registerB!=null?registerB.getText():null)); 5921 5922 ImmutableFieldReference fieldReference = (field_reference154!=null?((smaliTreeWalker.field_reference_return)field_reference154).fieldReference:null); 5923 5924 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction22c(opcode, regA, regB, 5925 dexBuilder.internFieldReference(fieldReference))); 5926 5927 } 5928 5929 } 5930 catch (RecognitionException re) { 5931 reportError(re); 5932 recover(input,re); 5933 } 5934 finally { 5935 // do for sure before leaving 5936 } 5937 } 5938 // $ANTLR end "insn_format22c_field" 5939 5940 5941 5942 // $ANTLR start "insn_format22c_type" 5943 // smaliTreeWalker.g:1015:1: insn_format22c_type : ^( I_STATEMENT_FORMAT22c_TYPE INSTRUCTION_FORMAT22c_TYPE registerA= REGISTER registerB= REGISTER nonvoid_type_descriptor ) ; insn_format22c_type()5944 public final void insn_format22c_type() throws RecognitionException { 5945 CommonTree registerA=null; 5946 CommonTree registerB=null; 5947 CommonTree INSTRUCTION_FORMAT22c_TYPE155=null; 5948 TreeRuleReturnScope nonvoid_type_descriptor156 =null; 5949 5950 try { 5951 // smaliTreeWalker.g:1016:3: ( ^( I_STATEMENT_FORMAT22c_TYPE INSTRUCTION_FORMAT22c_TYPE registerA= REGISTER registerB= REGISTER nonvoid_type_descriptor ) ) 5952 // smaliTreeWalker.g:1017:5: ^( I_STATEMENT_FORMAT22c_TYPE INSTRUCTION_FORMAT22c_TYPE registerA= REGISTER registerB= REGISTER nonvoid_type_descriptor ) 5953 { 5954 match(input,I_STATEMENT_FORMAT22c_TYPE,FOLLOW_I_STATEMENT_FORMAT22c_TYPE_in_insn_format22c_type2769); 5955 match(input, Token.DOWN, null); 5956 INSTRUCTION_FORMAT22c_TYPE155=(CommonTree)match(input,INSTRUCTION_FORMAT22c_TYPE,FOLLOW_INSTRUCTION_FORMAT22c_TYPE_in_insn_format22c_type2771); 5957 registerA=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_type2775); 5958 registerB=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_type2779); 5959 pushFollow(FOLLOW_nonvoid_type_descriptor_in_insn_format22c_type2781); 5960 nonvoid_type_descriptor156=nonvoid_type_descriptor(); 5961 state._fsp--; 5962 5963 match(input, Token.UP, null); 5964 5965 5966 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT22c_TYPE155!=null?INSTRUCTION_FORMAT22c_TYPE155.getText():null)); 5967 byte regA = parseRegister_nibble((registerA!=null?registerA.getText():null)); 5968 byte regB = parseRegister_nibble((registerB!=null?registerB.getText():null)); 5969 5970 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction22c(opcode, regA, regB, 5971 dexBuilder.internTypeReference((nonvoid_type_descriptor156!=null?((smaliTreeWalker.nonvoid_type_descriptor_return)nonvoid_type_descriptor156).type:null)))); 5972 5973 } 5974 5975 } 5976 catch (RecognitionException re) { 5977 reportError(re); 5978 recover(input,re); 5979 } 5980 finally { 5981 // do for sure before leaving 5982 } 5983 } 5984 // $ANTLR end "insn_format22c_type" 5985 5986 5987 5988 // $ANTLR start "insn_format22s" 5989 // smaliTreeWalker.g:1027:1: insn_format22s : ^( I_STATEMENT_FORMAT22s INSTRUCTION_FORMAT22s registerA= REGISTER registerB= REGISTER short_integral_literal ) ; insn_format22s()5990 public final void insn_format22s() throws RecognitionException { 5991 CommonTree registerA=null; 5992 CommonTree registerB=null; 5993 CommonTree INSTRUCTION_FORMAT22s157=null; 5994 short short_integral_literal158 =0; 5995 5996 try { 5997 // smaliTreeWalker.g:1028:3: ( ^( I_STATEMENT_FORMAT22s INSTRUCTION_FORMAT22s registerA= REGISTER registerB= REGISTER short_integral_literal ) ) 5998 // smaliTreeWalker.g:1029:5: ^( I_STATEMENT_FORMAT22s INSTRUCTION_FORMAT22s registerA= REGISTER registerB= REGISTER short_integral_literal ) 5999 { 6000 match(input,I_STATEMENT_FORMAT22s,FOLLOW_I_STATEMENT_FORMAT22s_in_insn_format22s2804); 6001 match(input, Token.DOWN, null); 6002 INSTRUCTION_FORMAT22s157=(CommonTree)match(input,INSTRUCTION_FORMAT22s,FOLLOW_INSTRUCTION_FORMAT22s_in_insn_format22s2806); 6003 registerA=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22s2810); 6004 registerB=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22s2814); 6005 pushFollow(FOLLOW_short_integral_literal_in_insn_format22s2816); 6006 short_integral_literal158=short_integral_literal(); 6007 state._fsp--; 6008 6009 match(input, Token.UP, null); 6010 6011 6012 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT22s157!=null?INSTRUCTION_FORMAT22s157.getText():null)); 6013 byte regA = parseRegister_nibble((registerA!=null?registerA.getText():null)); 6014 byte regB = parseRegister_nibble((registerB!=null?registerB.getText():null)); 6015 6016 short litC = short_integral_literal158; 6017 6018 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction22s(opcode, regA, regB, litC)); 6019 6020 } 6021 6022 } 6023 catch (RecognitionException re) { 6024 reportError(re); 6025 recover(input,re); 6026 } 6027 finally { 6028 // do for sure before leaving 6029 } 6030 } 6031 // $ANTLR end "insn_format22s" 6032 6033 6034 6035 // $ANTLR start "insn_format22t" 6036 // smaliTreeWalker.g:1040:1: insn_format22t : ^( I_STATEMENT_FORMAT22t INSTRUCTION_FORMAT22t registerA= REGISTER registerB= REGISTER label_ref ) ; insn_format22t()6037 public final void insn_format22t() throws RecognitionException { 6038 CommonTree registerA=null; 6039 CommonTree registerB=null; 6040 CommonTree INSTRUCTION_FORMAT22t159=null; 6041 Label label_ref160 =null; 6042 6043 try { 6044 // smaliTreeWalker.g:1041:3: ( ^( I_STATEMENT_FORMAT22t INSTRUCTION_FORMAT22t registerA= REGISTER registerB= REGISTER label_ref ) ) 6045 // smaliTreeWalker.g:1042:5: ^( I_STATEMENT_FORMAT22t INSTRUCTION_FORMAT22t registerA= REGISTER registerB= REGISTER label_ref ) 6046 { 6047 match(input,I_STATEMENT_FORMAT22t,FOLLOW_I_STATEMENT_FORMAT22t_in_insn_format22t2839); 6048 match(input, Token.DOWN, null); 6049 INSTRUCTION_FORMAT22t159=(CommonTree)match(input,INSTRUCTION_FORMAT22t,FOLLOW_INSTRUCTION_FORMAT22t_in_insn_format22t2841); 6050 registerA=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22t2845); 6051 registerB=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22t2849); 6052 pushFollow(FOLLOW_label_ref_in_insn_format22t2851); 6053 label_ref160=label_ref(); 6054 state._fsp--; 6055 6056 match(input, Token.UP, null); 6057 6058 6059 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT22t159!=null?INSTRUCTION_FORMAT22t159.getText():null)); 6060 byte regA = parseRegister_nibble((registerA!=null?registerA.getText():null)); 6061 byte regB = parseRegister_nibble((registerB!=null?registerB.getText():null)); 6062 6063 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction22t(opcode, regA, regB, label_ref160)); 6064 6065 } 6066 6067 } 6068 catch (RecognitionException re) { 6069 reportError(re); 6070 recover(input,re); 6071 } 6072 finally { 6073 // do for sure before leaving 6074 } 6075 } 6076 // $ANTLR end "insn_format22t" 6077 6078 6079 6080 // $ANTLR start "insn_format22x" 6081 // smaliTreeWalker.g:1051:1: insn_format22x : ^( I_STATEMENT_FORMAT22x INSTRUCTION_FORMAT22x registerA= REGISTER registerB= REGISTER ) ; insn_format22x()6082 public final void insn_format22x() throws RecognitionException { 6083 CommonTree registerA=null; 6084 CommonTree registerB=null; 6085 CommonTree INSTRUCTION_FORMAT22x161=null; 6086 6087 try { 6088 // smaliTreeWalker.g:1052:3: ( ^( I_STATEMENT_FORMAT22x INSTRUCTION_FORMAT22x registerA= REGISTER registerB= REGISTER ) ) 6089 // smaliTreeWalker.g:1053:5: ^( I_STATEMENT_FORMAT22x INSTRUCTION_FORMAT22x registerA= REGISTER registerB= REGISTER ) 6090 { 6091 match(input,I_STATEMENT_FORMAT22x,FOLLOW_I_STATEMENT_FORMAT22x_in_insn_format22x2874); 6092 match(input, Token.DOWN, null); 6093 INSTRUCTION_FORMAT22x161=(CommonTree)match(input,INSTRUCTION_FORMAT22x,FOLLOW_INSTRUCTION_FORMAT22x_in_insn_format22x2876); 6094 registerA=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22x2880); 6095 registerB=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22x2884); 6096 match(input, Token.UP, null); 6097 6098 6099 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT22x161!=null?INSTRUCTION_FORMAT22x161.getText():null)); 6100 short regA = parseRegister_byte((registerA!=null?registerA.getText():null)); 6101 int regB = parseRegister_short((registerB!=null?registerB.getText():null)); 6102 6103 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction22x(opcode, regA, regB)); 6104 6105 } 6106 6107 } 6108 catch (RecognitionException re) { 6109 reportError(re); 6110 recover(input,re); 6111 } 6112 finally { 6113 // do for sure before leaving 6114 } 6115 } 6116 // $ANTLR end "insn_format22x" 6117 6118 6119 6120 // $ANTLR start "insn_format23x" 6121 // smaliTreeWalker.g:1062:1: insn_format23x : ^( I_STATEMENT_FORMAT23x INSTRUCTION_FORMAT23x registerA= REGISTER registerB= REGISTER registerC= REGISTER ) ; insn_format23x()6122 public final void insn_format23x() throws RecognitionException { 6123 CommonTree registerA=null; 6124 CommonTree registerB=null; 6125 CommonTree registerC=null; 6126 CommonTree INSTRUCTION_FORMAT23x162=null; 6127 6128 try { 6129 // smaliTreeWalker.g:1063:3: ( ^( I_STATEMENT_FORMAT23x INSTRUCTION_FORMAT23x registerA= REGISTER registerB= REGISTER registerC= REGISTER ) ) 6130 // smaliTreeWalker.g:1064:5: ^( I_STATEMENT_FORMAT23x INSTRUCTION_FORMAT23x registerA= REGISTER registerB= REGISTER registerC= REGISTER ) 6131 { 6132 match(input,I_STATEMENT_FORMAT23x,FOLLOW_I_STATEMENT_FORMAT23x_in_insn_format23x2907); 6133 match(input, Token.DOWN, null); 6134 INSTRUCTION_FORMAT23x162=(CommonTree)match(input,INSTRUCTION_FORMAT23x,FOLLOW_INSTRUCTION_FORMAT23x_in_insn_format23x2909); 6135 registerA=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format23x2913); 6136 registerB=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format23x2917); 6137 registerC=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format23x2921); 6138 match(input, Token.UP, null); 6139 6140 6141 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT23x162!=null?INSTRUCTION_FORMAT23x162.getText():null)); 6142 short regA = parseRegister_byte((registerA!=null?registerA.getText():null)); 6143 short regB = parseRegister_byte((registerB!=null?registerB.getText():null)); 6144 short regC = parseRegister_byte((registerC!=null?registerC.getText():null)); 6145 6146 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction23x(opcode, regA, regB, regC)); 6147 6148 } 6149 6150 } 6151 catch (RecognitionException re) { 6152 reportError(re); 6153 recover(input,re); 6154 } 6155 finally { 6156 // do for sure before leaving 6157 } 6158 } 6159 // $ANTLR end "insn_format23x" 6160 6161 6162 6163 // $ANTLR start "insn_format30t" 6164 // smaliTreeWalker.g:1074:1: insn_format30t : ^( I_STATEMENT_FORMAT30t INSTRUCTION_FORMAT30t label_ref ) ; insn_format30t()6165 public final void insn_format30t() throws RecognitionException { 6166 CommonTree INSTRUCTION_FORMAT30t163=null; 6167 Label label_ref164 =null; 6168 6169 try { 6170 // smaliTreeWalker.g:1075:3: ( ^( I_STATEMENT_FORMAT30t INSTRUCTION_FORMAT30t label_ref ) ) 6171 // smaliTreeWalker.g:1076:5: ^( I_STATEMENT_FORMAT30t INSTRUCTION_FORMAT30t label_ref ) 6172 { 6173 match(input,I_STATEMENT_FORMAT30t,FOLLOW_I_STATEMENT_FORMAT30t_in_insn_format30t2944); 6174 match(input, Token.DOWN, null); 6175 INSTRUCTION_FORMAT30t163=(CommonTree)match(input,INSTRUCTION_FORMAT30t,FOLLOW_INSTRUCTION_FORMAT30t_in_insn_format30t2946); 6176 pushFollow(FOLLOW_label_ref_in_insn_format30t2948); 6177 label_ref164=label_ref(); 6178 state._fsp--; 6179 6180 match(input, Token.UP, null); 6181 6182 6183 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT30t163!=null?INSTRUCTION_FORMAT30t163.getText():null)); 6184 6185 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction30t(opcode, label_ref164)); 6186 6187 } 6188 6189 } 6190 catch (RecognitionException re) { 6191 reportError(re); 6192 recover(input,re); 6193 } 6194 finally { 6195 // do for sure before leaving 6196 } 6197 } 6198 // $ANTLR end "insn_format30t" 6199 6200 6201 6202 // $ANTLR start "insn_format31c" 6203 // smaliTreeWalker.g:1083:1: insn_format31c : ^( I_STATEMENT_FORMAT31c INSTRUCTION_FORMAT31c REGISTER string_literal ) ; insn_format31c()6204 public final void insn_format31c() throws RecognitionException { 6205 CommonTree INSTRUCTION_FORMAT31c165=null; 6206 CommonTree REGISTER166=null; 6207 String string_literal167 =null; 6208 6209 try { 6210 // smaliTreeWalker.g:1084:3: ( ^( I_STATEMENT_FORMAT31c INSTRUCTION_FORMAT31c REGISTER string_literal ) ) 6211 // smaliTreeWalker.g:1085:5: ^( I_STATEMENT_FORMAT31c INSTRUCTION_FORMAT31c REGISTER string_literal ) 6212 { 6213 match(input,I_STATEMENT_FORMAT31c,FOLLOW_I_STATEMENT_FORMAT31c_in_insn_format31c2971); 6214 match(input, Token.DOWN, null); 6215 INSTRUCTION_FORMAT31c165=(CommonTree)match(input,INSTRUCTION_FORMAT31c,FOLLOW_INSTRUCTION_FORMAT31c_in_insn_format31c2973); 6216 REGISTER166=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format31c2975); 6217 pushFollow(FOLLOW_string_literal_in_insn_format31c2977); 6218 string_literal167=string_literal(); 6219 state._fsp--; 6220 6221 match(input, Token.UP, null); 6222 6223 6224 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT31c165!=null?INSTRUCTION_FORMAT31c165.getText():null)); 6225 short regA = parseRegister_byte((REGISTER166!=null?REGISTER166.getText():null)); 6226 6227 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction31c(opcode, regA, 6228 dexBuilder.internStringReference(string_literal167))); 6229 6230 } 6231 6232 } 6233 catch (RecognitionException re) { 6234 reportError(re); 6235 recover(input,re); 6236 } 6237 finally { 6238 // do for sure before leaving 6239 } 6240 } 6241 // $ANTLR end "insn_format31c" 6242 6243 6244 6245 // $ANTLR start "insn_format31i" 6246 // smaliTreeWalker.g:1094:1: insn_format31i : ^( I_STATEMENT_FORMAT31i INSTRUCTION_FORMAT31i REGISTER fixed_32bit_literal ) ; insn_format31i()6247 public final void insn_format31i() throws RecognitionException { 6248 CommonTree INSTRUCTION_FORMAT31i168=null; 6249 CommonTree REGISTER169=null; 6250 int fixed_32bit_literal170 =0; 6251 6252 try { 6253 // smaliTreeWalker.g:1095:3: ( ^( I_STATEMENT_FORMAT31i INSTRUCTION_FORMAT31i REGISTER fixed_32bit_literal ) ) 6254 // smaliTreeWalker.g:1096:5: ^( I_STATEMENT_FORMAT31i INSTRUCTION_FORMAT31i REGISTER fixed_32bit_literal ) 6255 { 6256 match(input,I_STATEMENT_FORMAT31i,FOLLOW_I_STATEMENT_FORMAT31i_in_insn_format31i3000); 6257 match(input, Token.DOWN, null); 6258 INSTRUCTION_FORMAT31i168=(CommonTree)match(input,INSTRUCTION_FORMAT31i,FOLLOW_INSTRUCTION_FORMAT31i_in_insn_format31i3002); 6259 REGISTER169=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format31i3004); 6260 pushFollow(FOLLOW_fixed_32bit_literal_in_insn_format31i3006); 6261 fixed_32bit_literal170=fixed_32bit_literal(); 6262 state._fsp--; 6263 6264 match(input, Token.UP, null); 6265 6266 6267 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT31i168!=null?INSTRUCTION_FORMAT31i168.getText():null)); 6268 short regA = parseRegister_byte((REGISTER169!=null?REGISTER169.getText():null)); 6269 6270 int litB = fixed_32bit_literal170; 6271 6272 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction31i(opcode, regA, litB)); 6273 6274 } 6275 6276 } 6277 catch (RecognitionException re) { 6278 reportError(re); 6279 recover(input,re); 6280 } 6281 finally { 6282 // do for sure before leaving 6283 } 6284 } 6285 // $ANTLR end "insn_format31i" 6286 6287 6288 6289 // $ANTLR start "insn_format31t" 6290 // smaliTreeWalker.g:1106:1: insn_format31t : ^( I_STATEMENT_FORMAT31t INSTRUCTION_FORMAT31t REGISTER label_ref ) ; insn_format31t()6291 public final void insn_format31t() throws RecognitionException { 6292 CommonTree INSTRUCTION_FORMAT31t171=null; 6293 CommonTree REGISTER172=null; 6294 Label label_ref173 =null; 6295 6296 try { 6297 // smaliTreeWalker.g:1107:3: ( ^( I_STATEMENT_FORMAT31t INSTRUCTION_FORMAT31t REGISTER label_ref ) ) 6298 // smaliTreeWalker.g:1108:5: ^( I_STATEMENT_FORMAT31t INSTRUCTION_FORMAT31t REGISTER label_ref ) 6299 { 6300 match(input,I_STATEMENT_FORMAT31t,FOLLOW_I_STATEMENT_FORMAT31t_in_insn_format31t3029); 6301 match(input, Token.DOWN, null); 6302 INSTRUCTION_FORMAT31t171=(CommonTree)match(input,INSTRUCTION_FORMAT31t,FOLLOW_INSTRUCTION_FORMAT31t_in_insn_format31t3031); 6303 REGISTER172=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format31t3033); 6304 pushFollow(FOLLOW_label_ref_in_insn_format31t3035); 6305 label_ref173=label_ref(); 6306 state._fsp--; 6307 6308 match(input, Token.UP, null); 6309 6310 6311 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT31t171!=null?INSTRUCTION_FORMAT31t171.getText():null)); 6312 6313 short regA = parseRegister_byte((REGISTER172!=null?REGISTER172.getText():null)); 6314 6315 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction31t(opcode, regA, label_ref173)); 6316 6317 } 6318 6319 } 6320 catch (RecognitionException re) { 6321 reportError(re); 6322 recover(input,re); 6323 } 6324 finally { 6325 // do for sure before leaving 6326 } 6327 } 6328 // $ANTLR end "insn_format31t" 6329 6330 6331 6332 // $ANTLR start "insn_format32x" 6333 // smaliTreeWalker.g:1117:1: insn_format32x : ^( I_STATEMENT_FORMAT32x INSTRUCTION_FORMAT32x registerA= REGISTER registerB= REGISTER ) ; insn_format32x()6334 public final void insn_format32x() throws RecognitionException { 6335 CommonTree registerA=null; 6336 CommonTree registerB=null; 6337 CommonTree INSTRUCTION_FORMAT32x174=null; 6338 6339 try { 6340 // smaliTreeWalker.g:1118:3: ( ^( I_STATEMENT_FORMAT32x INSTRUCTION_FORMAT32x registerA= REGISTER registerB= REGISTER ) ) 6341 // smaliTreeWalker.g:1119:5: ^( I_STATEMENT_FORMAT32x INSTRUCTION_FORMAT32x registerA= REGISTER registerB= REGISTER ) 6342 { 6343 match(input,I_STATEMENT_FORMAT32x,FOLLOW_I_STATEMENT_FORMAT32x_in_insn_format32x3058); 6344 match(input, Token.DOWN, null); 6345 INSTRUCTION_FORMAT32x174=(CommonTree)match(input,INSTRUCTION_FORMAT32x,FOLLOW_INSTRUCTION_FORMAT32x_in_insn_format32x3060); 6346 registerA=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format32x3064); 6347 registerB=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format32x3068); 6348 match(input, Token.UP, null); 6349 6350 6351 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT32x174!=null?INSTRUCTION_FORMAT32x174.getText():null)); 6352 int regA = parseRegister_short((registerA!=null?registerA.getText():null)); 6353 int regB = parseRegister_short((registerB!=null?registerB.getText():null)); 6354 6355 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction32x(opcode, regA, regB)); 6356 6357 } 6358 6359 } 6360 catch (RecognitionException re) { 6361 reportError(re); 6362 recover(input,re); 6363 } 6364 finally { 6365 // do for sure before leaving 6366 } 6367 } 6368 // $ANTLR end "insn_format32x" 6369 6370 6371 6372 // $ANTLR start "insn_format35c_call_site" 6373 // smaliTreeWalker.g:1128:1: insn_format35c_call_site : ^( I_STATEMENT_FORMAT35c_CALL_SITE INSTRUCTION_FORMAT35c_CALL_SITE register_list call_site_reference ) ; insn_format35c_call_site()6374 public final void insn_format35c_call_site() throws RecognitionException { 6375 CommonTree INSTRUCTION_FORMAT35c_CALL_SITE175=null; 6376 TreeRuleReturnScope register_list176 =null; 6377 ImmutableCallSiteReference call_site_reference177 =null; 6378 6379 try { 6380 // smaliTreeWalker.g:1129:3: ( ^( I_STATEMENT_FORMAT35c_CALL_SITE INSTRUCTION_FORMAT35c_CALL_SITE register_list call_site_reference ) ) 6381 // smaliTreeWalker.g:1131:5: ^( I_STATEMENT_FORMAT35c_CALL_SITE INSTRUCTION_FORMAT35c_CALL_SITE register_list call_site_reference ) 6382 { 6383 match(input,I_STATEMENT_FORMAT35c_CALL_SITE,FOLLOW_I_STATEMENT_FORMAT35c_CALL_SITE_in_insn_format35c_call_site3096); 6384 match(input, Token.DOWN, null); 6385 INSTRUCTION_FORMAT35c_CALL_SITE175=(CommonTree)match(input,INSTRUCTION_FORMAT35c_CALL_SITE,FOLLOW_INSTRUCTION_FORMAT35c_CALL_SITE_in_insn_format35c_call_site3098); 6386 pushFollow(FOLLOW_register_list_in_insn_format35c_call_site3100); 6387 register_list176=register_list(); 6388 state._fsp--; 6389 6390 pushFollow(FOLLOW_call_site_reference_in_insn_format35c_call_site3102); 6391 call_site_reference177=call_site_reference(); 6392 state._fsp--; 6393 6394 match(input, Token.UP, null); 6395 6396 6397 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT35c_CALL_SITE175!=null?INSTRUCTION_FORMAT35c_CALL_SITE175.getText():null)); 6398 6399 //this depends on the fact that register_list returns a byte[5] 6400 byte[] registers = (register_list176!=null?((smaliTreeWalker.register_list_return)register_list176).registers:null); 6401 byte registerCount = (register_list176!=null?((smaliTreeWalker.register_list_return)register_list176).registerCount:0); 6402 6403 ImmutableCallSiteReference callSiteReference = call_site_reference177; 6404 6405 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction35c(opcode, registerCount, registers[0], 6406 registers[1], registers[2], registers[3], registers[4], dexBuilder.internCallSite(callSiteReference))); 6407 6408 } 6409 6410 } 6411 catch (RecognitionException re) { 6412 reportError(re); 6413 recover(input,re); 6414 } 6415 finally { 6416 // do for sure before leaving 6417 } 6418 } 6419 // $ANTLR end "insn_format35c_call_site" 6420 6421 6422 6423 // $ANTLR start "insn_format35c_method" 6424 // smaliTreeWalker.g:1145:1: insn_format35c_method : ^( I_STATEMENT_FORMAT35c_METHOD INSTRUCTION_FORMAT35c_METHOD register_list method_reference ) ; insn_format35c_method()6425 public final void insn_format35c_method() throws RecognitionException { 6426 CommonTree INSTRUCTION_FORMAT35c_METHOD178=null; 6427 TreeRuleReturnScope register_list179 =null; 6428 ImmutableMethodReference method_reference180 =null; 6429 6430 try { 6431 // smaliTreeWalker.g:1146:3: ( ^( I_STATEMENT_FORMAT35c_METHOD INSTRUCTION_FORMAT35c_METHOD register_list method_reference ) ) 6432 // smaliTreeWalker.g:1147:5: ^( I_STATEMENT_FORMAT35c_METHOD INSTRUCTION_FORMAT35c_METHOD register_list method_reference ) 6433 { 6434 match(input,I_STATEMENT_FORMAT35c_METHOD,FOLLOW_I_STATEMENT_FORMAT35c_METHOD_in_insn_format35c_method3125); 6435 match(input, Token.DOWN, null); 6436 INSTRUCTION_FORMAT35c_METHOD178=(CommonTree)match(input,INSTRUCTION_FORMAT35c_METHOD,FOLLOW_INSTRUCTION_FORMAT35c_METHOD_in_insn_format35c_method3127); 6437 pushFollow(FOLLOW_register_list_in_insn_format35c_method3129); 6438 register_list179=register_list(); 6439 state._fsp--; 6440 6441 pushFollow(FOLLOW_method_reference_in_insn_format35c_method3131); 6442 method_reference180=method_reference(); 6443 state._fsp--; 6444 6445 match(input, Token.UP, null); 6446 6447 6448 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT35c_METHOD178!=null?INSTRUCTION_FORMAT35c_METHOD178.getText():null)); 6449 6450 //this depends on the fact that register_list returns a byte[5] 6451 byte[] registers = (register_list179!=null?((smaliTreeWalker.register_list_return)register_list179).registers:null); 6452 byte registerCount = (register_list179!=null?((smaliTreeWalker.register_list_return)register_list179).registerCount:0); 6453 6454 ImmutableMethodReference methodReference = method_reference180; 6455 6456 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction35c(opcode, registerCount, registers[0], registers[1], 6457 registers[2], registers[3], registers[4], dexBuilder.internMethodReference(methodReference))); 6458 6459 } 6460 6461 } 6462 catch (RecognitionException re) { 6463 reportError(re); 6464 recover(input,re); 6465 } 6466 finally { 6467 // do for sure before leaving 6468 } 6469 } 6470 // $ANTLR end "insn_format35c_method" 6471 6472 6473 6474 // $ANTLR start "insn_format35c_type" 6475 // smaliTreeWalker.g:1161:1: insn_format35c_type : ^( I_STATEMENT_FORMAT35c_TYPE INSTRUCTION_FORMAT35c_TYPE register_list nonvoid_type_descriptor ) ; insn_format35c_type()6476 public final void insn_format35c_type() throws RecognitionException { 6477 CommonTree INSTRUCTION_FORMAT35c_TYPE181=null; 6478 TreeRuleReturnScope register_list182 =null; 6479 TreeRuleReturnScope nonvoid_type_descriptor183 =null; 6480 6481 try { 6482 // smaliTreeWalker.g:1162:3: ( ^( I_STATEMENT_FORMAT35c_TYPE INSTRUCTION_FORMAT35c_TYPE register_list nonvoid_type_descriptor ) ) 6483 // smaliTreeWalker.g:1163:5: ^( I_STATEMENT_FORMAT35c_TYPE INSTRUCTION_FORMAT35c_TYPE register_list nonvoid_type_descriptor ) 6484 { 6485 match(input,I_STATEMENT_FORMAT35c_TYPE,FOLLOW_I_STATEMENT_FORMAT35c_TYPE_in_insn_format35c_type3154); 6486 match(input, Token.DOWN, null); 6487 INSTRUCTION_FORMAT35c_TYPE181=(CommonTree)match(input,INSTRUCTION_FORMAT35c_TYPE,FOLLOW_INSTRUCTION_FORMAT35c_TYPE_in_insn_format35c_type3156); 6488 pushFollow(FOLLOW_register_list_in_insn_format35c_type3158); 6489 register_list182=register_list(); 6490 state._fsp--; 6491 6492 pushFollow(FOLLOW_nonvoid_type_descriptor_in_insn_format35c_type3160); 6493 nonvoid_type_descriptor183=nonvoid_type_descriptor(); 6494 state._fsp--; 6495 6496 match(input, Token.UP, null); 6497 6498 6499 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT35c_TYPE181!=null?INSTRUCTION_FORMAT35c_TYPE181.getText():null)); 6500 6501 //this depends on the fact that register_list returns a byte[5] 6502 byte[] registers = (register_list182!=null?((smaliTreeWalker.register_list_return)register_list182).registers:null); 6503 byte registerCount = (register_list182!=null?((smaliTreeWalker.register_list_return)register_list182).registerCount:0); 6504 6505 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction35c(opcode, registerCount, registers[0], registers[1], 6506 registers[2], registers[3], registers[4], dexBuilder.internTypeReference((nonvoid_type_descriptor183!=null?((smaliTreeWalker.nonvoid_type_descriptor_return)nonvoid_type_descriptor183).type:null)))); 6507 6508 } 6509 6510 } 6511 catch (RecognitionException re) { 6512 reportError(re); 6513 recover(input,re); 6514 } 6515 finally { 6516 // do for sure before leaving 6517 } 6518 } 6519 // $ANTLR end "insn_format35c_type" 6520 6521 6522 6523 // $ANTLR start "insn_format3rc_call_site" 6524 // smaliTreeWalker.g:1175:1: insn_format3rc_call_site : ^( I_STATEMENT_FORMAT3rc_CALL_SITE INSTRUCTION_FORMAT3rc_CALL_SITE register_range call_site_reference ) ; insn_format3rc_call_site()6525 public final void insn_format3rc_call_site() throws RecognitionException { 6526 CommonTree INSTRUCTION_FORMAT3rc_CALL_SITE184=null; 6527 TreeRuleReturnScope register_range185 =null; 6528 ImmutableCallSiteReference call_site_reference186 =null; 6529 6530 try { 6531 // smaliTreeWalker.g:1176:3: ( ^( I_STATEMENT_FORMAT3rc_CALL_SITE INSTRUCTION_FORMAT3rc_CALL_SITE register_range call_site_reference ) ) 6532 // smaliTreeWalker.g:1178:5: ^( I_STATEMENT_FORMAT3rc_CALL_SITE INSTRUCTION_FORMAT3rc_CALL_SITE register_range call_site_reference ) 6533 { 6534 match(input,I_STATEMENT_FORMAT3rc_CALL_SITE,FOLLOW_I_STATEMENT_FORMAT3rc_CALL_SITE_in_insn_format3rc_call_site3188); 6535 match(input, Token.DOWN, null); 6536 INSTRUCTION_FORMAT3rc_CALL_SITE184=(CommonTree)match(input,INSTRUCTION_FORMAT3rc_CALL_SITE,FOLLOW_INSTRUCTION_FORMAT3rc_CALL_SITE_in_insn_format3rc_call_site3190); 6537 pushFollow(FOLLOW_register_range_in_insn_format3rc_call_site3192); 6538 register_range185=register_range(); 6539 state._fsp--; 6540 6541 pushFollow(FOLLOW_call_site_reference_in_insn_format3rc_call_site3194); 6542 call_site_reference186=call_site_reference(); 6543 state._fsp--; 6544 6545 match(input, Token.UP, null); 6546 6547 6548 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT3rc_CALL_SITE184!=null?INSTRUCTION_FORMAT3rc_CALL_SITE184.getText():null)); 6549 int startRegister = (register_range185!=null?((smaliTreeWalker.register_range_return)register_range185).startRegister:0); 6550 int endRegister = (register_range185!=null?((smaliTreeWalker.register_range_return)register_range185).endRegister:0); 6551 6552 int registerCount = endRegister - startRegister + 1; 6553 6554 ImmutableCallSiteReference callSiteReference = call_site_reference186; 6555 6556 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction3rc(opcode, startRegister, registerCount, 6557 dexBuilder.internCallSite(callSiteReference))); 6558 6559 } 6560 6561 } 6562 catch (RecognitionException re) { 6563 reportError(re); 6564 recover(input,re); 6565 } 6566 finally { 6567 // do for sure before leaving 6568 } 6569 } 6570 // $ANTLR end "insn_format3rc_call_site" 6571 6572 6573 6574 // $ANTLR start "insn_format3rc_method" 6575 // smaliTreeWalker.g:1192:1: insn_format3rc_method : ^( I_STATEMENT_FORMAT3rc_METHOD INSTRUCTION_FORMAT3rc_METHOD register_range method_reference ) ; insn_format3rc_method()6576 public final void insn_format3rc_method() throws RecognitionException { 6577 CommonTree INSTRUCTION_FORMAT3rc_METHOD187=null; 6578 TreeRuleReturnScope register_range188 =null; 6579 ImmutableMethodReference method_reference189 =null; 6580 6581 try { 6582 // smaliTreeWalker.g:1193:3: ( ^( I_STATEMENT_FORMAT3rc_METHOD INSTRUCTION_FORMAT3rc_METHOD register_range method_reference ) ) 6583 // smaliTreeWalker.g:1194:5: ^( I_STATEMENT_FORMAT3rc_METHOD INSTRUCTION_FORMAT3rc_METHOD register_range method_reference ) 6584 { 6585 match(input,I_STATEMENT_FORMAT3rc_METHOD,FOLLOW_I_STATEMENT_FORMAT3rc_METHOD_in_insn_format3rc_method3217); 6586 match(input, Token.DOWN, null); 6587 INSTRUCTION_FORMAT3rc_METHOD187=(CommonTree)match(input,INSTRUCTION_FORMAT3rc_METHOD,FOLLOW_INSTRUCTION_FORMAT3rc_METHOD_in_insn_format3rc_method3219); 6588 pushFollow(FOLLOW_register_range_in_insn_format3rc_method3221); 6589 register_range188=register_range(); 6590 state._fsp--; 6591 6592 pushFollow(FOLLOW_method_reference_in_insn_format3rc_method3223); 6593 method_reference189=method_reference(); 6594 state._fsp--; 6595 6596 match(input, Token.UP, null); 6597 6598 6599 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT3rc_METHOD187!=null?INSTRUCTION_FORMAT3rc_METHOD187.getText():null)); 6600 int startRegister = (register_range188!=null?((smaliTreeWalker.register_range_return)register_range188).startRegister:0); 6601 int endRegister = (register_range188!=null?((smaliTreeWalker.register_range_return)register_range188).endRegister:0); 6602 6603 int registerCount = endRegister-startRegister+1; 6604 6605 ImmutableMethodReference methodReference = method_reference189; 6606 6607 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction3rc(opcode, startRegister, registerCount, 6608 dexBuilder.internMethodReference(methodReference))); 6609 6610 } 6611 6612 } 6613 catch (RecognitionException re) { 6614 reportError(re); 6615 recover(input,re); 6616 } 6617 finally { 6618 // do for sure before leaving 6619 } 6620 } 6621 // $ANTLR end "insn_format3rc_method" 6622 6623 6624 6625 // $ANTLR start "insn_format3rc_type" 6626 // smaliTreeWalker.g:1208:1: insn_format3rc_type : ^( I_STATEMENT_FORMAT3rc_TYPE INSTRUCTION_FORMAT3rc_TYPE register_range nonvoid_type_descriptor ) ; insn_format3rc_type()6627 public final void insn_format3rc_type() throws RecognitionException { 6628 CommonTree INSTRUCTION_FORMAT3rc_TYPE190=null; 6629 TreeRuleReturnScope register_range191 =null; 6630 TreeRuleReturnScope nonvoid_type_descriptor192 =null; 6631 6632 try { 6633 // smaliTreeWalker.g:1209:3: ( ^( I_STATEMENT_FORMAT3rc_TYPE INSTRUCTION_FORMAT3rc_TYPE register_range nonvoid_type_descriptor ) ) 6634 // smaliTreeWalker.g:1210:5: ^( I_STATEMENT_FORMAT3rc_TYPE INSTRUCTION_FORMAT3rc_TYPE register_range nonvoid_type_descriptor ) 6635 { 6636 match(input,I_STATEMENT_FORMAT3rc_TYPE,FOLLOW_I_STATEMENT_FORMAT3rc_TYPE_in_insn_format3rc_type3246); 6637 match(input, Token.DOWN, null); 6638 INSTRUCTION_FORMAT3rc_TYPE190=(CommonTree)match(input,INSTRUCTION_FORMAT3rc_TYPE,FOLLOW_INSTRUCTION_FORMAT3rc_TYPE_in_insn_format3rc_type3248); 6639 pushFollow(FOLLOW_register_range_in_insn_format3rc_type3250); 6640 register_range191=register_range(); 6641 state._fsp--; 6642 6643 pushFollow(FOLLOW_nonvoid_type_descriptor_in_insn_format3rc_type3252); 6644 nonvoid_type_descriptor192=nonvoid_type_descriptor(); 6645 state._fsp--; 6646 6647 match(input, Token.UP, null); 6648 6649 6650 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT3rc_TYPE190!=null?INSTRUCTION_FORMAT3rc_TYPE190.getText():null)); 6651 int startRegister = (register_range191!=null?((smaliTreeWalker.register_range_return)register_range191).startRegister:0); 6652 int endRegister = (register_range191!=null?((smaliTreeWalker.register_range_return)register_range191).endRegister:0); 6653 6654 int registerCount = endRegister-startRegister+1; 6655 6656 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction3rc(opcode, startRegister, registerCount, 6657 dexBuilder.internTypeReference((nonvoid_type_descriptor192!=null?((smaliTreeWalker.nonvoid_type_descriptor_return)nonvoid_type_descriptor192).type:null)))); 6658 6659 } 6660 6661 } 6662 catch (RecognitionException re) { 6663 reportError(re); 6664 recover(input,re); 6665 } 6666 finally { 6667 // do for sure before leaving 6668 } 6669 } 6670 // $ANTLR end "insn_format3rc_type" 6671 6672 6673 6674 // $ANTLR start "insn_format45cc_method" 6675 // smaliTreeWalker.g:1222:1: insn_format45cc_method : ^( I_STATEMENT_FORMAT45cc_METHOD INSTRUCTION_FORMAT45cc_METHOD register_list method_reference method_prototype ) ; insn_format45cc_method()6676 public final void insn_format45cc_method() throws RecognitionException { 6677 CommonTree INSTRUCTION_FORMAT45cc_METHOD193=null; 6678 TreeRuleReturnScope register_list194 =null; 6679 ImmutableMethodReference method_reference195 =null; 6680 ImmutableMethodProtoReference method_prototype196 =null; 6681 6682 try { 6683 // smaliTreeWalker.g:1223:3: ( ^( I_STATEMENT_FORMAT45cc_METHOD INSTRUCTION_FORMAT45cc_METHOD register_list method_reference method_prototype ) ) 6684 // smaliTreeWalker.g:1224:5: ^( I_STATEMENT_FORMAT45cc_METHOD INSTRUCTION_FORMAT45cc_METHOD register_list method_reference method_prototype ) 6685 { 6686 match(input,I_STATEMENT_FORMAT45cc_METHOD,FOLLOW_I_STATEMENT_FORMAT45cc_METHOD_in_insn_format45cc_method3275); 6687 match(input, Token.DOWN, null); 6688 INSTRUCTION_FORMAT45cc_METHOD193=(CommonTree)match(input,INSTRUCTION_FORMAT45cc_METHOD,FOLLOW_INSTRUCTION_FORMAT45cc_METHOD_in_insn_format45cc_method3277); 6689 pushFollow(FOLLOW_register_list_in_insn_format45cc_method3279); 6690 register_list194=register_list(); 6691 state._fsp--; 6692 6693 pushFollow(FOLLOW_method_reference_in_insn_format45cc_method3281); 6694 method_reference195=method_reference(); 6695 state._fsp--; 6696 6697 pushFollow(FOLLOW_method_prototype_in_insn_format45cc_method3283); 6698 method_prototype196=method_prototype(); 6699 state._fsp--; 6700 6701 match(input, Token.UP, null); 6702 6703 6704 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT45cc_METHOD193!=null?INSTRUCTION_FORMAT45cc_METHOD193.getText():null)); 6705 6706 //this depends on the fact that register_list returns a byte[5] 6707 byte[] registers = (register_list194!=null?((smaliTreeWalker.register_list_return)register_list194).registers:null); 6708 byte registerCount = (register_list194!=null?((smaliTreeWalker.register_list_return)register_list194).registerCount:0); 6709 6710 ImmutableMethodReference methodReference = method_reference195; 6711 6712 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction45cc(opcode, registerCount, registers[0], registers[1], 6713 registers[2], registers[3], registers[4], 6714 dexBuilder.internMethodReference(methodReference), 6715 dexBuilder.internMethodProtoReference(method_prototype196))); 6716 6717 } 6718 6719 } 6720 catch (RecognitionException re) { 6721 reportError(re); 6722 recover(input,re); 6723 } 6724 finally { 6725 // do for sure before leaving 6726 } 6727 } 6728 // $ANTLR end "insn_format45cc_method" 6729 6730 6731 6732 // $ANTLR start "insn_format4rcc_method" 6733 // smaliTreeWalker.g:1240:1: insn_format4rcc_method : ^( I_STATEMENT_FORMAT4rcc_METHOD INSTRUCTION_FORMAT4rcc_METHOD register_range method_reference method_prototype ) ; insn_format4rcc_method()6734 public final void insn_format4rcc_method() throws RecognitionException { 6735 CommonTree INSTRUCTION_FORMAT4rcc_METHOD197=null; 6736 TreeRuleReturnScope register_range198 =null; 6737 ImmutableMethodReference method_reference199 =null; 6738 ImmutableMethodProtoReference method_prototype200 =null; 6739 6740 try { 6741 // smaliTreeWalker.g:1241:3: ( ^( I_STATEMENT_FORMAT4rcc_METHOD INSTRUCTION_FORMAT4rcc_METHOD register_range method_reference method_prototype ) ) 6742 // smaliTreeWalker.g:1242:5: ^( I_STATEMENT_FORMAT4rcc_METHOD INSTRUCTION_FORMAT4rcc_METHOD register_range method_reference method_prototype ) 6743 { 6744 match(input,I_STATEMENT_FORMAT4rcc_METHOD,FOLLOW_I_STATEMENT_FORMAT4rcc_METHOD_in_insn_format4rcc_method3306); 6745 match(input, Token.DOWN, null); 6746 INSTRUCTION_FORMAT4rcc_METHOD197=(CommonTree)match(input,INSTRUCTION_FORMAT4rcc_METHOD,FOLLOW_INSTRUCTION_FORMAT4rcc_METHOD_in_insn_format4rcc_method3308); 6747 pushFollow(FOLLOW_register_range_in_insn_format4rcc_method3310); 6748 register_range198=register_range(); 6749 state._fsp--; 6750 6751 pushFollow(FOLLOW_method_reference_in_insn_format4rcc_method3312); 6752 method_reference199=method_reference(); 6753 state._fsp--; 6754 6755 pushFollow(FOLLOW_method_prototype_in_insn_format4rcc_method3314); 6756 method_prototype200=method_prototype(); 6757 state._fsp--; 6758 6759 match(input, Token.UP, null); 6760 6761 6762 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT4rcc_METHOD197!=null?INSTRUCTION_FORMAT4rcc_METHOD197.getText():null)); 6763 int startRegister = (register_range198!=null?((smaliTreeWalker.register_range_return)register_range198).startRegister:0); 6764 int endRegister = (register_range198!=null?((smaliTreeWalker.register_range_return)register_range198).endRegister:0); 6765 6766 int registerCount = endRegister-startRegister+1; 6767 6768 ImmutableMethodReference methodReference = method_reference199; 6769 6770 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction4rcc(opcode, startRegister, registerCount, 6771 dexBuilder.internMethodReference(methodReference), 6772 dexBuilder.internMethodProtoReference(method_prototype200))); 6773 6774 } 6775 6776 } 6777 catch (RecognitionException re) { 6778 reportError(re); 6779 recover(input,re); 6780 } 6781 finally { 6782 // do for sure before leaving 6783 } 6784 } 6785 // $ANTLR end "insn_format4rcc_method" 6786 6787 6788 6789 // $ANTLR start "insn_format51l_type" 6790 // smaliTreeWalker.g:1257:1: insn_format51l_type : ^( I_STATEMENT_FORMAT51l INSTRUCTION_FORMAT51l REGISTER fixed_64bit_literal ) ; insn_format51l_type()6791 public final void insn_format51l_type() throws RecognitionException { 6792 CommonTree INSTRUCTION_FORMAT51l201=null; 6793 CommonTree REGISTER202=null; 6794 long fixed_64bit_literal203 =0; 6795 6796 try { 6797 // smaliTreeWalker.g:1258:3: ( ^( I_STATEMENT_FORMAT51l INSTRUCTION_FORMAT51l REGISTER fixed_64bit_literal ) ) 6798 // smaliTreeWalker.g:1259:5: ^( I_STATEMENT_FORMAT51l INSTRUCTION_FORMAT51l REGISTER fixed_64bit_literal ) 6799 { 6800 match(input,I_STATEMENT_FORMAT51l,FOLLOW_I_STATEMENT_FORMAT51l_in_insn_format51l_type3337); 6801 match(input, Token.DOWN, null); 6802 INSTRUCTION_FORMAT51l201=(CommonTree)match(input,INSTRUCTION_FORMAT51l,FOLLOW_INSTRUCTION_FORMAT51l_in_insn_format51l_type3339); 6803 REGISTER202=(CommonTree)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format51l_type3341); 6804 pushFollow(FOLLOW_fixed_64bit_literal_in_insn_format51l_type3343); 6805 fixed_64bit_literal203=fixed_64bit_literal(); 6806 state._fsp--; 6807 6808 match(input, Token.UP, null); 6809 6810 6811 Opcode opcode = opcodes.getOpcodeByName((INSTRUCTION_FORMAT51l201!=null?INSTRUCTION_FORMAT51l201.getText():null)); 6812 short regA = parseRegister_byte((REGISTER202!=null?REGISTER202.getText():null)); 6813 6814 long litB = fixed_64bit_literal203; 6815 6816 method_stack.peek().methodBuilder.addInstruction(new BuilderInstruction51l(opcode, regA, litB)); 6817 6818 } 6819 6820 } 6821 catch (RecognitionException re) { 6822 reportError(re); 6823 recover(input,re); 6824 } 6825 finally { 6826 // do for sure before leaving 6827 } 6828 } 6829 // $ANTLR end "insn_format51l_type" 6830 6831 6832 6833 // $ANTLR start "insn_array_data_directive" 6834 // smaliTreeWalker.g:1269:1: insn_array_data_directive : ^( I_STATEMENT_ARRAY_DATA ^( I_ARRAY_ELEMENT_SIZE short_integral_literal ) array_elements ) ; insn_array_data_directive()6835 public final void insn_array_data_directive() throws RecognitionException { 6836 short short_integral_literal204 =0; 6837 List<Number> array_elements205 =null; 6838 6839 try { 6840 // smaliTreeWalker.g:1270:3: ( ^( I_STATEMENT_ARRAY_DATA ^( I_ARRAY_ELEMENT_SIZE short_integral_literal ) array_elements ) ) 6841 // smaliTreeWalker.g:1271:5: ^( I_STATEMENT_ARRAY_DATA ^( I_ARRAY_ELEMENT_SIZE short_integral_literal ) array_elements ) 6842 { 6843 match(input,I_STATEMENT_ARRAY_DATA,FOLLOW_I_STATEMENT_ARRAY_DATA_in_insn_array_data_directive3366); 6844 match(input, Token.DOWN, null); 6845 match(input,I_ARRAY_ELEMENT_SIZE,FOLLOW_I_ARRAY_ELEMENT_SIZE_in_insn_array_data_directive3369); 6846 match(input, Token.DOWN, null); 6847 pushFollow(FOLLOW_short_integral_literal_in_insn_array_data_directive3371); 6848 short_integral_literal204=short_integral_literal(); 6849 state._fsp--; 6850 6851 match(input, Token.UP, null); 6852 6853 pushFollow(FOLLOW_array_elements_in_insn_array_data_directive3374); 6854 array_elements205=array_elements(); 6855 state._fsp--; 6856 6857 match(input, Token.UP, null); 6858 6859 6860 int elementWidth = short_integral_literal204; 6861 List<Number> elements = array_elements205; 6862 6863 method_stack.peek().methodBuilder.addInstruction(new BuilderArrayPayload(elementWidth, array_elements205)); 6864 6865 } 6866 6867 } 6868 catch (RecognitionException re) { 6869 reportError(re); 6870 recover(input,re); 6871 } 6872 finally { 6873 // do for sure before leaving 6874 } 6875 } 6876 // $ANTLR end "insn_array_data_directive" 6877 6878 6879 6880 // $ANTLR start "insn_packed_switch_directive" 6881 // smaliTreeWalker.g:1279:1: insn_packed_switch_directive : ^( I_STATEMENT_PACKED_SWITCH ^( I_PACKED_SWITCH_START_KEY fixed_32bit_literal ) packed_switch_elements ) ; insn_packed_switch_directive()6882 public final void insn_packed_switch_directive() throws RecognitionException { 6883 int fixed_32bit_literal206 =0; 6884 List<Label> packed_switch_elements207 =null; 6885 6886 try { 6887 // smaliTreeWalker.g:1280:3: ( ^( I_STATEMENT_PACKED_SWITCH ^( I_PACKED_SWITCH_START_KEY fixed_32bit_literal ) packed_switch_elements ) ) 6888 // smaliTreeWalker.g:1281:5: ^( I_STATEMENT_PACKED_SWITCH ^( I_PACKED_SWITCH_START_KEY fixed_32bit_literal ) packed_switch_elements ) 6889 { 6890 match(input,I_STATEMENT_PACKED_SWITCH,FOLLOW_I_STATEMENT_PACKED_SWITCH_in_insn_packed_switch_directive3396); 6891 match(input, Token.DOWN, null); 6892 match(input,I_PACKED_SWITCH_START_KEY,FOLLOW_I_PACKED_SWITCH_START_KEY_in_insn_packed_switch_directive3399); 6893 match(input, Token.DOWN, null); 6894 pushFollow(FOLLOW_fixed_32bit_literal_in_insn_packed_switch_directive3401); 6895 fixed_32bit_literal206=fixed_32bit_literal(); 6896 state._fsp--; 6897 6898 match(input, Token.UP, null); 6899 6900 pushFollow(FOLLOW_packed_switch_elements_in_insn_packed_switch_directive3404); 6901 packed_switch_elements207=packed_switch_elements(); 6902 state._fsp--; 6903 6904 match(input, Token.UP, null); 6905 6906 6907 int startKey = fixed_32bit_literal206; 6908 method_stack.peek().methodBuilder.addInstruction(new BuilderPackedSwitchPayload(startKey, 6909 packed_switch_elements207)); 6910 6911 } 6912 6913 } 6914 catch (RecognitionException re) { 6915 reportError(re); 6916 recover(input,re); 6917 } 6918 finally { 6919 // do for sure before leaving 6920 } 6921 } 6922 // $ANTLR end "insn_packed_switch_directive" 6923 6924 6925 6926 // $ANTLR start "insn_sparse_switch_directive" 6927 // smaliTreeWalker.g:1288:1: insn_sparse_switch_directive : ^( I_STATEMENT_SPARSE_SWITCH sparse_switch_elements ) ; insn_sparse_switch_directive()6928 public final void insn_sparse_switch_directive() throws RecognitionException { 6929 List<SwitchLabelElement> sparse_switch_elements208 =null; 6930 6931 try { 6932 // smaliTreeWalker.g:1289:3: ( ^( I_STATEMENT_SPARSE_SWITCH sparse_switch_elements ) ) 6933 // smaliTreeWalker.g:1290:5: ^( I_STATEMENT_SPARSE_SWITCH sparse_switch_elements ) 6934 { 6935 match(input,I_STATEMENT_SPARSE_SWITCH,FOLLOW_I_STATEMENT_SPARSE_SWITCH_in_insn_sparse_switch_directive3428); 6936 match(input, Token.DOWN, null); 6937 pushFollow(FOLLOW_sparse_switch_elements_in_insn_sparse_switch_directive3430); 6938 sparse_switch_elements208=sparse_switch_elements(); 6939 state._fsp--; 6940 6941 match(input, Token.UP, null); 6942 6943 6944 method_stack.peek().methodBuilder.addInstruction(new BuilderSparseSwitchPayload(sparse_switch_elements208)); 6945 6946 } 6947 6948 } 6949 catch (RecognitionException re) { 6950 reportError(re); 6951 recover(input,re); 6952 } 6953 finally { 6954 // do for sure before leaving 6955 } 6956 } 6957 // $ANTLR end "insn_sparse_switch_directive" 6958 6959 6960 6961 // $ANTLR start "array_descriptor" 6962 // smaliTreeWalker.g:1295:1: array_descriptor returns [String type] : ARRAY_TYPE_PREFIX ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR ) ; array_descriptor()6963 public final String array_descriptor() throws RecognitionException { 6964 String type = null; 6965 6966 6967 CommonTree ARRAY_TYPE_PREFIX209=null; 6968 CommonTree PRIMITIVE_TYPE210=null; 6969 CommonTree CLASS_DESCRIPTOR211=null; 6970 6971 try { 6972 // smaliTreeWalker.g:1296:3: ( ARRAY_TYPE_PREFIX ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR ) ) 6973 // smaliTreeWalker.g:1296:5: ARRAY_TYPE_PREFIX ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR ) 6974 { 6975 ARRAY_TYPE_PREFIX209=(CommonTree)match(input,ARRAY_TYPE_PREFIX,FOLLOW_ARRAY_TYPE_PREFIX_in_array_descriptor3451); 6976 // smaliTreeWalker.g:1296:23: ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR ) 6977 int alt39=2; 6978 int LA39_0 = input.LA(1); 6979 if ( (LA39_0==PRIMITIVE_TYPE) ) { 6980 alt39=1; 6981 } 6982 else if ( (LA39_0==CLASS_DESCRIPTOR) ) { 6983 alt39=2; 6984 } 6985 6986 else { 6987 NoViableAltException nvae = 6988 new NoViableAltException("", 39, 0, input); 6989 throw nvae; 6990 } 6991 6992 switch (alt39) { 6993 case 1 : 6994 // smaliTreeWalker.g:1296:25: PRIMITIVE_TYPE 6995 { 6996 PRIMITIVE_TYPE210=(CommonTree)match(input,PRIMITIVE_TYPE,FOLLOW_PRIMITIVE_TYPE_in_array_descriptor3455); 6997 type = (ARRAY_TYPE_PREFIX209!=null?ARRAY_TYPE_PREFIX209.getText():null) + (PRIMITIVE_TYPE210!=null?PRIMITIVE_TYPE210.getText():null); 6998 } 6999 break; 7000 case 2 : 7001 // smaliTreeWalker.g:1297:25: CLASS_DESCRIPTOR 7002 { 7003 CLASS_DESCRIPTOR211=(CommonTree)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_array_descriptor3483); 7004 type = (ARRAY_TYPE_PREFIX209!=null?ARRAY_TYPE_PREFIX209.getText():null) + (CLASS_DESCRIPTOR211!=null?CLASS_DESCRIPTOR211.getText():null); 7005 } 7006 break; 7007 7008 } 7009 7010 } 7011 7012 } 7013 catch (RecognitionException re) { 7014 reportError(re); 7015 recover(input,re); 7016 } 7017 finally { 7018 // do for sure before leaving 7019 } 7020 return type; 7021 } 7022 // $ANTLR end "array_descriptor" 7023 7024 7025 public static class nonvoid_type_descriptor_return extends TreeRuleReturnScope { 7026 public String type; 7027 }; 7028 7029 7030 // $ANTLR start "nonvoid_type_descriptor" 7031 // smaliTreeWalker.g:1299:1: nonvoid_type_descriptor returns [String type] : ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR | array_descriptor ) ; nonvoid_type_descriptor()7032 public final smaliTreeWalker.nonvoid_type_descriptor_return nonvoid_type_descriptor() throws RecognitionException { 7033 smaliTreeWalker.nonvoid_type_descriptor_return retval = new smaliTreeWalker.nonvoid_type_descriptor_return(); 7034 retval.start = input.LT(1); 7035 7036 String array_descriptor212 =null; 7037 7038 try { 7039 // smaliTreeWalker.g:1300:3: ( ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR | array_descriptor ) ) 7040 // smaliTreeWalker.g:1300:5: ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR | array_descriptor ) 7041 { 7042 // smaliTreeWalker.g:1300:5: ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR | array_descriptor ) 7043 int alt40=3; 7044 switch ( input.LA(1) ) { 7045 case PRIMITIVE_TYPE: 7046 { 7047 alt40=1; 7048 } 7049 break; 7050 case CLASS_DESCRIPTOR: 7051 { 7052 alt40=2; 7053 } 7054 break; 7055 case ARRAY_TYPE_PREFIX: 7056 { 7057 alt40=3; 7058 } 7059 break; 7060 default: 7061 NoViableAltException nvae = 7062 new NoViableAltException("", 40, 0, input); 7063 throw nvae; 7064 } 7065 switch (alt40) { 7066 case 1 : 7067 // smaliTreeWalker.g:1300:6: PRIMITIVE_TYPE 7068 { 7069 match(input,PRIMITIVE_TYPE,FOLLOW_PRIMITIVE_TYPE_in_nonvoid_type_descriptor3501); 7070 retval.type = input.getTokenStream().toString(input.getTreeAdaptor().getTokenStartIndex(retval.start),input.getTreeAdaptor().getTokenStopIndex(retval.start)); 7071 } 7072 break; 7073 case 2 : 7074 // smaliTreeWalker.g:1301:5: CLASS_DESCRIPTOR 7075 { 7076 match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_nonvoid_type_descriptor3509); 7077 retval.type = input.getTokenStream().toString(input.getTreeAdaptor().getTokenStartIndex(retval.start),input.getTreeAdaptor().getTokenStopIndex(retval.start)); 7078 } 7079 break; 7080 case 3 : 7081 // smaliTreeWalker.g:1302:5: array_descriptor 7082 { 7083 pushFollow(FOLLOW_array_descriptor_in_nonvoid_type_descriptor3517); 7084 array_descriptor212=array_descriptor(); 7085 state._fsp--; 7086 7087 retval.type = array_descriptor212; 7088 } 7089 break; 7090 7091 } 7092 7093 } 7094 7095 } 7096 catch (RecognitionException re) { 7097 reportError(re); 7098 recover(input,re); 7099 } 7100 finally { 7101 // do for sure before leaving 7102 } 7103 return retval; 7104 } 7105 // $ANTLR end "nonvoid_type_descriptor" 7106 7107 7108 public static class reference_type_descriptor_return extends TreeRuleReturnScope { 7109 public String type; 7110 }; 7111 7112 7113 // $ANTLR start "reference_type_descriptor" 7114 // smaliTreeWalker.g:1305:1: reference_type_descriptor returns [String type] : ( CLASS_DESCRIPTOR | array_descriptor ) ; reference_type_descriptor()7115 public final smaliTreeWalker.reference_type_descriptor_return reference_type_descriptor() throws RecognitionException { 7116 smaliTreeWalker.reference_type_descriptor_return retval = new smaliTreeWalker.reference_type_descriptor_return(); 7117 retval.start = input.LT(1); 7118 7119 String array_descriptor213 =null; 7120 7121 try { 7122 // smaliTreeWalker.g:1306:3: ( ( CLASS_DESCRIPTOR | array_descriptor ) ) 7123 // smaliTreeWalker.g:1306:5: ( CLASS_DESCRIPTOR | array_descriptor ) 7124 { 7125 // smaliTreeWalker.g:1306:5: ( CLASS_DESCRIPTOR | array_descriptor ) 7126 int alt41=2; 7127 int LA41_0 = input.LA(1); 7128 if ( (LA41_0==CLASS_DESCRIPTOR) ) { 7129 alt41=1; 7130 } 7131 else if ( (LA41_0==ARRAY_TYPE_PREFIX) ) { 7132 alt41=2; 7133 } 7134 7135 else { 7136 NoViableAltException nvae = 7137 new NoViableAltException("", 41, 0, input); 7138 throw nvae; 7139 } 7140 7141 switch (alt41) { 7142 case 1 : 7143 // smaliTreeWalker.g:1306:6: CLASS_DESCRIPTOR 7144 { 7145 match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_reference_type_descriptor3538); 7146 retval.type = input.getTokenStream().toString(input.getTreeAdaptor().getTokenStartIndex(retval.start),input.getTreeAdaptor().getTokenStopIndex(retval.start)); 7147 } 7148 break; 7149 case 2 : 7150 // smaliTreeWalker.g:1307:5: array_descriptor 7151 { 7152 pushFollow(FOLLOW_array_descriptor_in_reference_type_descriptor3546); 7153 array_descriptor213=array_descriptor(); 7154 state._fsp--; 7155 7156 retval.type = array_descriptor213; 7157 } 7158 break; 7159 7160 } 7161 7162 } 7163 7164 } 7165 catch (RecognitionException re) { 7166 reportError(re); 7167 recover(input,re); 7168 } 7169 finally { 7170 // do for sure before leaving 7171 } 7172 return retval; 7173 } 7174 // $ANTLR end "reference_type_descriptor" 7175 7176 7177 7178 // $ANTLR start "type_descriptor" 7179 // smaliTreeWalker.g:1310:1: type_descriptor returns [String type] : ( VOID_TYPE | nonvoid_type_descriptor ); type_descriptor()7180 public final String type_descriptor() throws RecognitionException { 7181 String type = null; 7182 7183 7184 TreeRuleReturnScope nonvoid_type_descriptor214 =null; 7185 7186 try { 7187 // smaliTreeWalker.g:1311:3: ( VOID_TYPE | nonvoid_type_descriptor ) 7188 int alt42=2; 7189 int LA42_0 = input.LA(1); 7190 if ( (LA42_0==VOID_TYPE) ) { 7191 alt42=1; 7192 } 7193 else if ( (LA42_0==ARRAY_TYPE_PREFIX||LA42_0==CLASS_DESCRIPTOR||LA42_0==PRIMITIVE_TYPE) ) { 7194 alt42=2; 7195 } 7196 7197 else { 7198 NoViableAltException nvae = 7199 new NoViableAltException("", 42, 0, input); 7200 throw nvae; 7201 } 7202 7203 switch (alt42) { 7204 case 1 : 7205 // smaliTreeWalker.g:1311:5: VOID_TYPE 7206 { 7207 match(input,VOID_TYPE,FOLLOW_VOID_TYPE_in_type_descriptor3566); 7208 type = "V"; 7209 } 7210 break; 7211 case 2 : 7212 // smaliTreeWalker.g:1312:5: nonvoid_type_descriptor 7213 { 7214 pushFollow(FOLLOW_nonvoid_type_descriptor_in_type_descriptor3574); 7215 nonvoid_type_descriptor214=nonvoid_type_descriptor(); 7216 state._fsp--; 7217 7218 type = (nonvoid_type_descriptor214!=null?((smaliTreeWalker.nonvoid_type_descriptor_return)nonvoid_type_descriptor214).type:null); 7219 } 7220 break; 7221 7222 } 7223 } 7224 catch (RecognitionException re) { 7225 reportError(re); 7226 recover(input,re); 7227 } 7228 finally { 7229 // do for sure before leaving 7230 } 7231 return type; 7232 } 7233 // $ANTLR end "type_descriptor" 7234 7235 7236 7237 // $ANTLR start "short_integral_literal" 7238 // smaliTreeWalker.g:1315:1: short_integral_literal returns [short value] : ( long_literal | integer_literal | short_literal | char_literal | byte_literal ); short_integral_literal()7239 public final short short_integral_literal() throws RecognitionException { 7240 short value = 0; 7241 7242 7243 long long_literal215 =0; 7244 int integer_literal216 =0; 7245 short short_literal217 =0; 7246 char char_literal218 =0; 7247 byte byte_literal219 =0; 7248 7249 try { 7250 // smaliTreeWalker.g:1316:3: ( long_literal | integer_literal | short_literal | char_literal | byte_literal ) 7251 int alt43=5; 7252 switch ( input.LA(1) ) { 7253 case LONG_LITERAL: 7254 { 7255 alt43=1; 7256 } 7257 break; 7258 case INTEGER_LITERAL: 7259 { 7260 alt43=2; 7261 } 7262 break; 7263 case SHORT_LITERAL: 7264 { 7265 alt43=3; 7266 } 7267 break; 7268 case CHAR_LITERAL: 7269 { 7270 alt43=4; 7271 } 7272 break; 7273 case BYTE_LITERAL: 7274 { 7275 alt43=5; 7276 } 7277 break; 7278 default: 7279 NoViableAltException nvae = 7280 new NoViableAltException("", 43, 0, input); 7281 throw nvae; 7282 } 7283 switch (alt43) { 7284 case 1 : 7285 // smaliTreeWalker.g:1316:5: long_literal 7286 { 7287 pushFollow(FOLLOW_long_literal_in_short_integral_literal3592); 7288 long_literal215=long_literal(); 7289 state._fsp--; 7290 7291 7292 LiteralTools.checkShort(long_literal215); 7293 value = (short)long_literal215; 7294 7295 } 7296 break; 7297 case 2 : 7298 // smaliTreeWalker.g:1321:5: integer_literal 7299 { 7300 pushFollow(FOLLOW_integer_literal_in_short_integral_literal3604); 7301 integer_literal216=integer_literal(); 7302 state._fsp--; 7303 7304 7305 LiteralTools.checkShort(integer_literal216); 7306 value = (short)integer_literal216; 7307 7308 } 7309 break; 7310 case 3 : 7311 // smaliTreeWalker.g:1326:5: short_literal 7312 { 7313 pushFollow(FOLLOW_short_literal_in_short_integral_literal3616); 7314 short_literal217=short_literal(); 7315 state._fsp--; 7316 7317 value = short_literal217; 7318 } 7319 break; 7320 case 4 : 7321 // smaliTreeWalker.g:1327:5: char_literal 7322 { 7323 pushFollow(FOLLOW_char_literal_in_short_integral_literal3624); 7324 char_literal218=char_literal(); 7325 state._fsp--; 7326 7327 value = (short)char_literal218; 7328 } 7329 break; 7330 case 5 : 7331 // smaliTreeWalker.g:1328:5: byte_literal 7332 { 7333 pushFollow(FOLLOW_byte_literal_in_short_integral_literal3632); 7334 byte_literal219=byte_literal(); 7335 state._fsp--; 7336 7337 value = byte_literal219; 7338 } 7339 break; 7340 7341 } 7342 } 7343 catch (RecognitionException re) { 7344 reportError(re); 7345 recover(input,re); 7346 } 7347 finally { 7348 // do for sure before leaving 7349 } 7350 return value; 7351 } 7352 // $ANTLR end "short_integral_literal" 7353 7354 7355 7356 // $ANTLR start "integral_literal" 7357 // smaliTreeWalker.g:1330:1: integral_literal returns [int value] : ( long_literal | integer_literal | short_literal | byte_literal ); integral_literal()7358 public final int integral_literal() throws RecognitionException { 7359 int value = 0; 7360 7361 7362 long long_literal220 =0; 7363 int integer_literal221 =0; 7364 short short_literal222 =0; 7365 byte byte_literal223 =0; 7366 7367 try { 7368 // smaliTreeWalker.g:1331:3: ( long_literal | integer_literal | short_literal | byte_literal ) 7369 int alt44=4; 7370 switch ( input.LA(1) ) { 7371 case LONG_LITERAL: 7372 { 7373 alt44=1; 7374 } 7375 break; 7376 case INTEGER_LITERAL: 7377 { 7378 alt44=2; 7379 } 7380 break; 7381 case SHORT_LITERAL: 7382 { 7383 alt44=3; 7384 } 7385 break; 7386 case BYTE_LITERAL: 7387 { 7388 alt44=4; 7389 } 7390 break; 7391 default: 7392 NoViableAltException nvae = 7393 new NoViableAltException("", 44, 0, input); 7394 throw nvae; 7395 } 7396 switch (alt44) { 7397 case 1 : 7398 // smaliTreeWalker.g:1331:5: long_literal 7399 { 7400 pushFollow(FOLLOW_long_literal_in_integral_literal3647); 7401 long_literal220=long_literal(); 7402 state._fsp--; 7403 7404 7405 LiteralTools.checkInt(long_literal220); 7406 value = (int)long_literal220; 7407 7408 } 7409 break; 7410 case 2 : 7411 // smaliTreeWalker.g:1336:5: integer_literal 7412 { 7413 pushFollow(FOLLOW_integer_literal_in_integral_literal3659); 7414 integer_literal221=integer_literal(); 7415 state._fsp--; 7416 7417 value = integer_literal221; 7418 } 7419 break; 7420 case 3 : 7421 // smaliTreeWalker.g:1337:5: short_literal 7422 { 7423 pushFollow(FOLLOW_short_literal_in_integral_literal3667); 7424 short_literal222=short_literal(); 7425 state._fsp--; 7426 7427 value = short_literal222; 7428 } 7429 break; 7430 case 4 : 7431 // smaliTreeWalker.g:1338:5: byte_literal 7432 { 7433 pushFollow(FOLLOW_byte_literal_in_integral_literal3675); 7434 byte_literal223=byte_literal(); 7435 state._fsp--; 7436 7437 value = byte_literal223; 7438 } 7439 break; 7440 7441 } 7442 } 7443 catch (RecognitionException re) { 7444 reportError(re); 7445 recover(input,re); 7446 } 7447 finally { 7448 // do for sure before leaving 7449 } 7450 return value; 7451 } 7452 // $ANTLR end "integral_literal" 7453 7454 7455 7456 // $ANTLR start "integer_literal" 7457 // smaliTreeWalker.g:1341:1: integer_literal returns [int value] : INTEGER_LITERAL ; integer_literal()7458 public final int integer_literal() throws RecognitionException { 7459 int value = 0; 7460 7461 7462 CommonTree INTEGER_LITERAL224=null; 7463 7464 try { 7465 // smaliTreeWalker.g:1342:3: ( INTEGER_LITERAL ) 7466 // smaliTreeWalker.g:1342:5: INTEGER_LITERAL 7467 { 7468 INTEGER_LITERAL224=(CommonTree)match(input,INTEGER_LITERAL,FOLLOW_INTEGER_LITERAL_in_integer_literal3691); 7469 value = LiteralTools.parseInt((INTEGER_LITERAL224!=null?INTEGER_LITERAL224.getText():null)); 7470 } 7471 7472 } 7473 catch (RecognitionException re) { 7474 reportError(re); 7475 recover(input,re); 7476 } 7477 finally { 7478 // do for sure before leaving 7479 } 7480 return value; 7481 } 7482 // $ANTLR end "integer_literal" 7483 7484 7485 7486 // $ANTLR start "long_literal" 7487 // smaliTreeWalker.g:1344:1: long_literal returns [long value] : LONG_LITERAL ; long_literal()7488 public final long long_literal() throws RecognitionException { 7489 long value = 0; 7490 7491 7492 CommonTree LONG_LITERAL225=null; 7493 7494 try { 7495 // smaliTreeWalker.g:1345:3: ( LONG_LITERAL ) 7496 // smaliTreeWalker.g:1345:5: LONG_LITERAL 7497 { 7498 LONG_LITERAL225=(CommonTree)match(input,LONG_LITERAL,FOLLOW_LONG_LITERAL_in_long_literal3706); 7499 value = LiteralTools.parseLong((LONG_LITERAL225!=null?LONG_LITERAL225.getText():null)); 7500 } 7501 7502 } 7503 catch (RecognitionException re) { 7504 reportError(re); 7505 recover(input,re); 7506 } 7507 finally { 7508 // do for sure before leaving 7509 } 7510 return value; 7511 } 7512 // $ANTLR end "long_literal" 7513 7514 7515 7516 // $ANTLR start "short_literal" 7517 // smaliTreeWalker.g:1347:1: short_literal returns [short value] : SHORT_LITERAL ; short_literal()7518 public final short short_literal() throws RecognitionException { 7519 short value = 0; 7520 7521 7522 CommonTree SHORT_LITERAL226=null; 7523 7524 try { 7525 // smaliTreeWalker.g:1348:3: ( SHORT_LITERAL ) 7526 // smaliTreeWalker.g:1348:5: SHORT_LITERAL 7527 { 7528 SHORT_LITERAL226=(CommonTree)match(input,SHORT_LITERAL,FOLLOW_SHORT_LITERAL_in_short_literal3721); 7529 value = LiteralTools.parseShort((SHORT_LITERAL226!=null?SHORT_LITERAL226.getText():null)); 7530 } 7531 7532 } 7533 catch (RecognitionException re) { 7534 reportError(re); 7535 recover(input,re); 7536 } 7537 finally { 7538 // do for sure before leaving 7539 } 7540 return value; 7541 } 7542 // $ANTLR end "short_literal" 7543 7544 7545 7546 // $ANTLR start "byte_literal" 7547 // smaliTreeWalker.g:1350:1: byte_literal returns [byte value] : BYTE_LITERAL ; byte_literal()7548 public final byte byte_literal() throws RecognitionException { 7549 byte value = 0; 7550 7551 7552 CommonTree BYTE_LITERAL227=null; 7553 7554 try { 7555 // smaliTreeWalker.g:1351:3: ( BYTE_LITERAL ) 7556 // smaliTreeWalker.g:1351:5: BYTE_LITERAL 7557 { 7558 BYTE_LITERAL227=(CommonTree)match(input,BYTE_LITERAL,FOLLOW_BYTE_LITERAL_in_byte_literal3736); 7559 value = LiteralTools.parseByte((BYTE_LITERAL227!=null?BYTE_LITERAL227.getText():null)); 7560 } 7561 7562 } 7563 catch (RecognitionException re) { 7564 reportError(re); 7565 recover(input,re); 7566 } 7567 finally { 7568 // do for sure before leaving 7569 } 7570 return value; 7571 } 7572 // $ANTLR end "byte_literal" 7573 7574 7575 7576 // $ANTLR start "float_literal" 7577 // smaliTreeWalker.g:1353:1: float_literal returns [float value] : FLOAT_LITERAL ; float_literal()7578 public final float float_literal() throws RecognitionException { 7579 float value = 0.0f; 7580 7581 7582 CommonTree FLOAT_LITERAL228=null; 7583 7584 try { 7585 // smaliTreeWalker.g:1354:3: ( FLOAT_LITERAL ) 7586 // smaliTreeWalker.g:1354:5: FLOAT_LITERAL 7587 { 7588 FLOAT_LITERAL228=(CommonTree)match(input,FLOAT_LITERAL,FOLLOW_FLOAT_LITERAL_in_float_literal3751); 7589 value = LiteralTools.parseFloat((FLOAT_LITERAL228!=null?FLOAT_LITERAL228.getText():null)); 7590 } 7591 7592 } 7593 catch (RecognitionException re) { 7594 reportError(re); 7595 recover(input,re); 7596 } 7597 finally { 7598 // do for sure before leaving 7599 } 7600 return value; 7601 } 7602 // $ANTLR end "float_literal" 7603 7604 7605 7606 // $ANTLR start "double_literal" 7607 // smaliTreeWalker.g:1356:1: double_literal returns [double value] : DOUBLE_LITERAL ; double_literal()7608 public final double double_literal() throws RecognitionException { 7609 double value = 0.0; 7610 7611 7612 CommonTree DOUBLE_LITERAL229=null; 7613 7614 try { 7615 // smaliTreeWalker.g:1357:3: ( DOUBLE_LITERAL ) 7616 // smaliTreeWalker.g:1357:5: DOUBLE_LITERAL 7617 { 7618 DOUBLE_LITERAL229=(CommonTree)match(input,DOUBLE_LITERAL,FOLLOW_DOUBLE_LITERAL_in_double_literal3766); 7619 value = LiteralTools.parseDouble((DOUBLE_LITERAL229!=null?DOUBLE_LITERAL229.getText():null)); 7620 } 7621 7622 } 7623 catch (RecognitionException re) { 7624 reportError(re); 7625 recover(input,re); 7626 } 7627 finally { 7628 // do for sure before leaving 7629 } 7630 return value; 7631 } 7632 // $ANTLR end "double_literal" 7633 7634 7635 7636 // $ANTLR start "char_literal" 7637 // smaliTreeWalker.g:1359:1: char_literal returns [char value] : CHAR_LITERAL ; char_literal()7638 public final char char_literal() throws RecognitionException { 7639 char value = 0; 7640 7641 7642 CommonTree CHAR_LITERAL230=null; 7643 7644 try { 7645 // smaliTreeWalker.g:1360:3: ( CHAR_LITERAL ) 7646 // smaliTreeWalker.g:1360:5: CHAR_LITERAL 7647 { 7648 CHAR_LITERAL230=(CommonTree)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_char_literal3781); 7649 value = (CHAR_LITERAL230!=null?CHAR_LITERAL230.getText():null).charAt(1); 7650 } 7651 7652 } 7653 catch (RecognitionException re) { 7654 reportError(re); 7655 recover(input,re); 7656 } 7657 finally { 7658 // do for sure before leaving 7659 } 7660 return value; 7661 } 7662 // $ANTLR end "char_literal" 7663 7664 7665 7666 // $ANTLR start "string_literal" 7667 // smaliTreeWalker.g:1362:1: string_literal returns [String value] : STRING_LITERAL ; string_literal()7668 public final String string_literal() throws RecognitionException { 7669 String value = null; 7670 7671 7672 CommonTree STRING_LITERAL231=null; 7673 7674 try { 7675 // smaliTreeWalker.g:1363:3: ( STRING_LITERAL ) 7676 // smaliTreeWalker.g:1363:5: STRING_LITERAL 7677 { 7678 STRING_LITERAL231=(CommonTree)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_string_literal3796); 7679 7680 value = (STRING_LITERAL231!=null?STRING_LITERAL231.getText():null); 7681 value = value.substring(1,value.length()-1); 7682 7683 } 7684 7685 } 7686 catch (RecognitionException re) { 7687 reportError(re); 7688 recover(input,re); 7689 } 7690 finally { 7691 // do for sure before leaving 7692 } 7693 return value; 7694 } 7695 // $ANTLR end "string_literal" 7696 7697 7698 7699 // $ANTLR start "bool_literal" 7700 // smaliTreeWalker.g:1369:1: bool_literal returns [boolean value] : BOOL_LITERAL ; bool_literal()7701 public final boolean bool_literal() throws RecognitionException { 7702 boolean value = false; 7703 7704 7705 CommonTree BOOL_LITERAL232=null; 7706 7707 try { 7708 // smaliTreeWalker.g:1370:3: ( BOOL_LITERAL ) 7709 // smaliTreeWalker.g:1370:5: BOOL_LITERAL 7710 { 7711 BOOL_LITERAL232=(CommonTree)match(input,BOOL_LITERAL,FOLLOW_BOOL_LITERAL_in_bool_literal3815); 7712 value = Boolean.parseBoolean((BOOL_LITERAL232!=null?BOOL_LITERAL232.getText():null)); 7713 } 7714 7715 } 7716 catch (RecognitionException re) { 7717 reportError(re); 7718 recover(input,re); 7719 } 7720 finally { 7721 // do for sure before leaving 7722 } 7723 return value; 7724 } 7725 // $ANTLR end "bool_literal" 7726 7727 7728 7729 // $ANTLR start "array_literal" 7730 // smaliTreeWalker.g:1372:1: array_literal returns [List<EncodedValue> elements] : ^( I_ENCODED_ARRAY ( literal )* ) ; array_literal()7731 public final List<EncodedValue> array_literal() throws RecognitionException { 7732 List<EncodedValue> elements = null; 7733 7734 7735 ImmutableEncodedValue literal233 =null; 7736 7737 try { 7738 // smaliTreeWalker.g:1373:3: ( ^( I_ENCODED_ARRAY ( literal )* ) ) 7739 // smaliTreeWalker.g:1373:5: ^( I_ENCODED_ARRAY ( literal )* ) 7740 { 7741 elements = Lists.newArrayList(); 7742 match(input,I_ENCODED_ARRAY,FOLLOW_I_ENCODED_ARRAY_in_array_literal3837); 7743 if ( input.LA(1)==Token.DOWN ) { 7744 match(input, Token.DOWN, null); 7745 // smaliTreeWalker.g:1374:23: ( literal )* 7746 loop45: 7747 while (true) { 7748 int alt45=2; 7749 int LA45_0 = input.LA(1); 7750 if ( (LA45_0==ARRAY_TYPE_PREFIX||(LA45_0 >= BOOL_LITERAL && LA45_0 <= BYTE_LITERAL)||(LA45_0 >= CHAR_LITERAL && LA45_0 <= CLASS_DESCRIPTOR)||LA45_0==DOUBLE_LITERAL||LA45_0==FLOAT_LITERAL||LA45_0==INTEGER_LITERAL||(LA45_0 >= I_ENCODED_ARRAY && LA45_0 <= I_ENCODED_METHOD_HANDLE)||LA45_0==I_METHOD_PROTOTYPE||LA45_0==I_SUBANNOTATION||LA45_0==LONG_LITERAL||LA45_0==NULL_LITERAL||LA45_0==PRIMITIVE_TYPE||LA45_0==SHORT_LITERAL||LA45_0==STRING_LITERAL||LA45_0==VOID_TYPE) ) { 7751 alt45=1; 7752 } 7753 7754 switch (alt45) { 7755 case 1 : 7756 // smaliTreeWalker.g:1374:24: literal 7757 { 7758 pushFollow(FOLLOW_literal_in_array_literal3840); 7759 literal233=literal(); 7760 state._fsp--; 7761 7762 elements.add(literal233); 7763 } 7764 break; 7765 7766 default : 7767 break loop45; 7768 } 7769 } 7770 7771 match(input, Token.UP, null); 7772 } 7773 7774 } 7775 7776 } 7777 catch (RecognitionException re) { 7778 reportError(re); 7779 recover(input,re); 7780 } 7781 finally { 7782 // do for sure before leaving 7783 } 7784 return elements; 7785 } 7786 // $ANTLR end "array_literal" 7787 7788 7789 7790 // $ANTLR start "annotations" 7791 // smaliTreeWalker.g:1376:1: annotations returns [Set<Annotation> annotations] : ^( I_ANNOTATIONS ( annotation )* ) ; annotations()7792 public final Set<Annotation> annotations() throws RecognitionException { 7793 Set<Annotation> annotations = null; 7794 7795 7796 Annotation annotation234 =null; 7797 7798 try { 7799 // smaliTreeWalker.g:1377:3: ( ^( I_ANNOTATIONS ( annotation )* ) ) 7800 // smaliTreeWalker.g:1377:5: ^( I_ANNOTATIONS ( annotation )* ) 7801 { 7802 HashMap<String, Annotation> annotationMap = Maps.newHashMap(); 7803 match(input,I_ANNOTATIONS,FOLLOW_I_ANNOTATIONS_in_annotations3865); 7804 if ( input.LA(1)==Token.DOWN ) { 7805 match(input, Token.DOWN, null); 7806 // smaliTreeWalker.g:1378:21: ( annotation )* 7807 loop46: 7808 while (true) { 7809 int alt46=2; 7810 int LA46_0 = input.LA(1); 7811 if ( (LA46_0==I_ANNOTATION) ) { 7812 alt46=1; 7813 } 7814 7815 switch (alt46) { 7816 case 1 : 7817 // smaliTreeWalker.g:1378:22: annotation 7818 { 7819 pushFollow(FOLLOW_annotation_in_annotations3868); 7820 annotation234=annotation(); 7821 state._fsp--; 7822 7823 7824 Annotation anno = annotation234; 7825 Annotation old = annotationMap.put(anno.getType(), anno); 7826 if (old != null) { 7827 throw new SemanticException(input, "Multiple annotations of type %s", anno.getType()); 7828 } 7829 7830 } 7831 break; 7832 7833 default : 7834 break loop46; 7835 } 7836 } 7837 7838 match(input, Token.UP, null); 7839 } 7840 7841 7842 annotations = ImmutableSet.copyOf(annotationMap.values()); 7843 7844 } 7845 7846 } 7847 catch (RecognitionException re) { 7848 reportError(re); 7849 recover(input,re); 7850 } 7851 finally { 7852 // do for sure before leaving 7853 } 7854 return annotations; 7855 } 7856 // $ANTLR end "annotations" 7857 7858 7859 7860 // $ANTLR start "annotation" 7861 // smaliTreeWalker.g:1390:1: annotation returns [Annotation annotation] : ^( I_ANNOTATION ANNOTATION_VISIBILITY subannotation ) ; annotation()7862 public final Annotation annotation() throws RecognitionException { 7863 Annotation annotation = null; 7864 7865 7866 CommonTree ANNOTATION_VISIBILITY235=null; 7867 TreeRuleReturnScope subannotation236 =null; 7868 7869 try { 7870 // smaliTreeWalker.g:1391:3: ( ^( I_ANNOTATION ANNOTATION_VISIBILITY subannotation ) ) 7871 // smaliTreeWalker.g:1391:5: ^( I_ANNOTATION ANNOTATION_VISIBILITY subannotation ) 7872 { 7873 match(input,I_ANNOTATION,FOLLOW_I_ANNOTATION_in_annotation3897); 7874 match(input, Token.DOWN, null); 7875 ANNOTATION_VISIBILITY235=(CommonTree)match(input,ANNOTATION_VISIBILITY,FOLLOW_ANNOTATION_VISIBILITY_in_annotation3899); 7876 pushFollow(FOLLOW_subannotation_in_annotation3901); 7877 subannotation236=subannotation(); 7878 state._fsp--; 7879 7880 match(input, Token.UP, null); 7881 7882 7883 int visibility = AnnotationVisibility.getVisibility((ANNOTATION_VISIBILITY235!=null?ANNOTATION_VISIBILITY235.getText():null)); 7884 annotation = new ImmutableAnnotation(visibility, (subannotation236!=null?((smaliTreeWalker.subannotation_return)subannotation236).annotationType:null), (subannotation236!=null?((smaliTreeWalker.subannotation_return)subannotation236).elements:null)); 7885 7886 } 7887 7888 } 7889 catch (RecognitionException re) { 7890 reportError(re); 7891 recover(input,re); 7892 } 7893 finally { 7894 // do for sure before leaving 7895 } 7896 return annotation; 7897 } 7898 // $ANTLR end "annotation" 7899 7900 7901 7902 // $ANTLR start "annotation_element" 7903 // smaliTreeWalker.g:1397:1: annotation_element returns [AnnotationElement element] : ^( I_ANNOTATION_ELEMENT SIMPLE_NAME literal ) ; annotation_element()7904 public final AnnotationElement annotation_element() throws RecognitionException { 7905 AnnotationElement element = null; 7906 7907 7908 CommonTree SIMPLE_NAME237=null; 7909 ImmutableEncodedValue literal238 =null; 7910 7911 try { 7912 // smaliTreeWalker.g:1398:3: ( ^( I_ANNOTATION_ELEMENT SIMPLE_NAME literal ) ) 7913 // smaliTreeWalker.g:1398:5: ^( I_ANNOTATION_ELEMENT SIMPLE_NAME literal ) 7914 { 7915 match(input,I_ANNOTATION_ELEMENT,FOLLOW_I_ANNOTATION_ELEMENT_in_annotation_element3922); 7916 match(input, Token.DOWN, null); 7917 SIMPLE_NAME237=(CommonTree)match(input,SIMPLE_NAME,FOLLOW_SIMPLE_NAME_in_annotation_element3924); 7918 pushFollow(FOLLOW_literal_in_annotation_element3926); 7919 literal238=literal(); 7920 state._fsp--; 7921 7922 match(input, Token.UP, null); 7923 7924 7925 element = new ImmutableAnnotationElement((SIMPLE_NAME237!=null?SIMPLE_NAME237.getText():null), literal238); 7926 7927 } 7928 7929 } 7930 catch (RecognitionException re) { 7931 reportError(re); 7932 recover(input,re); 7933 } 7934 finally { 7935 // do for sure before leaving 7936 } 7937 return element; 7938 } 7939 // $ANTLR end "annotation_element" 7940 7941 7942 public static class subannotation_return extends TreeRuleReturnScope { 7943 public String annotationType; 7944 public List<AnnotationElement> elements; 7945 }; 7946 7947 7948 // $ANTLR start "subannotation" 7949 // smaliTreeWalker.g:1403:1: subannotation returns [String annotationType, List<AnnotationElement> elements] : ^( I_SUBANNOTATION CLASS_DESCRIPTOR ( annotation_element )* ) ; subannotation()7950 public final smaliTreeWalker.subannotation_return subannotation() throws RecognitionException { 7951 smaliTreeWalker.subannotation_return retval = new smaliTreeWalker.subannotation_return(); 7952 retval.start = input.LT(1); 7953 7954 CommonTree CLASS_DESCRIPTOR240=null; 7955 AnnotationElement annotation_element239 =null; 7956 7957 try { 7958 // smaliTreeWalker.g:1404:3: ( ^( I_SUBANNOTATION CLASS_DESCRIPTOR ( annotation_element )* ) ) 7959 // smaliTreeWalker.g:1404:5: ^( I_SUBANNOTATION CLASS_DESCRIPTOR ( annotation_element )* ) 7960 { 7961 ArrayList<AnnotationElement> elements = Lists.newArrayList(); 7962 match(input,I_SUBANNOTATION,FOLLOW_I_SUBANNOTATION_in_subannotation3953); 7963 match(input, Token.DOWN, null); 7964 CLASS_DESCRIPTOR240=(CommonTree)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_subannotation3963); 7965 // smaliTreeWalker.g:1407:9: ( annotation_element )* 7966 loop47: 7967 while (true) { 7968 int alt47=2; 7969 int LA47_0 = input.LA(1); 7970 if ( (LA47_0==I_ANNOTATION_ELEMENT) ) { 7971 alt47=1; 7972 } 7973 7974 switch (alt47) { 7975 case 1 : 7976 // smaliTreeWalker.g:1407:10: annotation_element 7977 { 7978 pushFollow(FOLLOW_annotation_element_in_subannotation3974); 7979 annotation_element239=annotation_element(); 7980 state._fsp--; 7981 7982 7983 elements.add(annotation_element239); 7984 7985 } 7986 break; 7987 7988 default : 7989 break loop47; 7990 } 7991 } 7992 7993 match(input, Token.UP, null); 7994 7995 7996 retval.annotationType = (CLASS_DESCRIPTOR240!=null?CLASS_DESCRIPTOR240.getText():null); 7997 retval.elements = elements; 7998 7999 } 8000 8001 } 8002 catch (RecognitionException re) { 8003 reportError(re); 8004 recover(input,re); 8005 } 8006 finally { 8007 // do for sure before leaving 8008 } 8009 return retval; 8010 } 8011 // $ANTLR end "subannotation" 8012 8013 8014 8015 // $ANTLR start "field_literal" 8016 // smaliTreeWalker.g:1417:1: field_literal returns [ImmutableFieldReference value] : ^( I_ENCODED_FIELD field_reference ) ; field_literal()8017 public final ImmutableFieldReference field_literal() throws RecognitionException { 8018 ImmutableFieldReference value = null; 8019 8020 8021 TreeRuleReturnScope field_reference241 =null; 8022 8023 try { 8024 // smaliTreeWalker.g:1418:3: ( ^( I_ENCODED_FIELD field_reference ) ) 8025 // smaliTreeWalker.g:1418:5: ^( I_ENCODED_FIELD field_reference ) 8026 { 8027 match(input,I_ENCODED_FIELD,FOLLOW_I_ENCODED_FIELD_in_field_literal4013); 8028 match(input, Token.DOWN, null); 8029 pushFollow(FOLLOW_field_reference_in_field_literal4015); 8030 field_reference241=field_reference(); 8031 state._fsp--; 8032 8033 match(input, Token.UP, null); 8034 8035 8036 value = (field_reference241!=null?((smaliTreeWalker.field_reference_return)field_reference241).fieldReference:null); 8037 8038 } 8039 8040 } 8041 catch (RecognitionException re) { 8042 reportError(re); 8043 recover(input,re); 8044 } 8045 finally { 8046 // do for sure before leaving 8047 } 8048 return value; 8049 } 8050 // $ANTLR end "field_literal" 8051 8052 8053 8054 // $ANTLR start "method_literal" 8055 // smaliTreeWalker.g:1423:1: method_literal returns [ImmutableMethodReference value] : ^( I_ENCODED_METHOD method_reference ) ; method_literal()8056 public final ImmutableMethodReference method_literal() throws RecognitionException { 8057 ImmutableMethodReference value = null; 8058 8059 8060 ImmutableMethodReference method_reference242 =null; 8061 8062 try { 8063 // smaliTreeWalker.g:1424:3: ( ^( I_ENCODED_METHOD method_reference ) ) 8064 // smaliTreeWalker.g:1424:5: ^( I_ENCODED_METHOD method_reference ) 8065 { 8066 match(input,I_ENCODED_METHOD,FOLLOW_I_ENCODED_METHOD_in_method_literal4036); 8067 match(input, Token.DOWN, null); 8068 pushFollow(FOLLOW_method_reference_in_method_literal4038); 8069 method_reference242=method_reference(); 8070 state._fsp--; 8071 8072 match(input, Token.UP, null); 8073 8074 8075 value = method_reference242; 8076 8077 } 8078 8079 } 8080 catch (RecognitionException re) { 8081 reportError(re); 8082 recover(input,re); 8083 } 8084 finally { 8085 // do for sure before leaving 8086 } 8087 return value; 8088 } 8089 // $ANTLR end "method_literal" 8090 8091 8092 8093 // $ANTLR start "enum_literal" 8094 // smaliTreeWalker.g:1429:1: enum_literal returns [ImmutableFieldReference value] : ^( I_ENCODED_ENUM field_reference ) ; enum_literal()8095 public final ImmutableFieldReference enum_literal() throws RecognitionException { 8096 ImmutableFieldReference value = null; 8097 8098 8099 TreeRuleReturnScope field_reference243 =null; 8100 8101 try { 8102 // smaliTreeWalker.g:1430:3: ( ^( I_ENCODED_ENUM field_reference ) ) 8103 // smaliTreeWalker.g:1430:5: ^( I_ENCODED_ENUM field_reference ) 8104 { 8105 match(input,I_ENCODED_ENUM,FOLLOW_I_ENCODED_ENUM_in_enum_literal4059); 8106 match(input, Token.DOWN, null); 8107 pushFollow(FOLLOW_field_reference_in_enum_literal4061); 8108 field_reference243=field_reference(); 8109 state._fsp--; 8110 8111 match(input, Token.UP, null); 8112 8113 8114 value = (field_reference243!=null?((smaliTreeWalker.field_reference_return)field_reference243).fieldReference:null); 8115 8116 } 8117 8118 } 8119 catch (RecognitionException re) { 8120 reportError(re); 8121 recover(input,re); 8122 } 8123 finally { 8124 // do for sure before leaving 8125 } 8126 return value; 8127 } 8128 // $ANTLR end "enum_literal" 8129 8130 // Delegated rules 8131 8132 8133 8134 public static final BitSet FOLLOW_I_CLASS_DEF_in_smali_file52 = new BitSet(new long[]{0x0000000000000004L}); 8135 public static final BitSet FOLLOW_header_in_smali_file54 = new BitSet(new long[]{0x0000000000000000L,0x2000000000000000L}); 8136 public static final BitSet FOLLOW_methods_in_smali_file56 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L}); 8137 public static final BitSet FOLLOW_fields_in_smali_file58 = new BitSet(new long[]{0x0000000000000000L,0x0000000400000000L}); 8138 public static final BitSet FOLLOW_annotations_in_smali_file60 = new BitSet(new long[]{0x0000000000000008L}); 8139 public static final BitSet FOLLOW_class_spec_in_header85 = new BitSet(new long[]{0x0000000000000000L,0x0080000000000000L,0x0040000000000800L}); 8140 public static final BitSet FOLLOW_super_spec_in_header87 = new BitSet(new long[]{0x0000000000000000L,0x0080000000000000L,0x0000000000000800L}); 8141 public static final BitSet FOLLOW_implements_list_in_header90 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000800L}); 8142 public static final BitSet FOLLOW_source_spec_in_header92 = new BitSet(new long[]{0x0000000000000002L}); 8143 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_class_spec110 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L}); 8144 public static final BitSet FOLLOW_access_list_in_class_spec112 = new BitSet(new long[]{0x0000000000000002L}); 8145 public static final BitSet FOLLOW_I_SUPER_in_super_spec130 = new BitSet(new long[]{0x0000000000000004L}); 8146 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_super_spec132 = new BitSet(new long[]{0x0000000000000008L}); 8147 public static final BitSet FOLLOW_I_IMPLEMENTS_in_implements_spec152 = new BitSet(new long[]{0x0000000000000004L}); 8148 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_implements_spec154 = new BitSet(new long[]{0x0000000000000008L}); 8149 public static final BitSet FOLLOW_implements_spec_in_implements_list184 = new BitSet(new long[]{0x0000000000000002L,0x0080000000000000L}); 8150 public static final BitSet FOLLOW_I_SOURCE_in_source_spec213 = new BitSet(new long[]{0x0000000000000004L}); 8151 public static final BitSet FOLLOW_string_literal_in_source_spec215 = new BitSet(new long[]{0x0000000000000008L}); 8152 public static final BitSet FOLLOW_I_ACCESS_LIST_in_access_list248 = new BitSet(new long[]{0x0000000000000004L}); 8153 public static final BitSet FOLLOW_ACCESS_SPEC_in_access_list266 = new BitSet(new long[]{0x0000000000000018L}); 8154 public static final BitSet FOLLOW_I_FIELDS_in_fields308 = new BitSet(new long[]{0x0000000000000004L}); 8155 public static final BitSet FOLLOW_field_in_fields317 = new BitSet(new long[]{0x0000000000000008L,0x0008000000000000L}); 8156 public static final BitSet FOLLOW_I_METHODS_in_methods349 = new BitSet(new long[]{0x0000000000000004L}); 8157 public static final BitSet FOLLOW_method_in_methods358 = new BitSet(new long[]{0x0000000000000008L,0x1000000000000000L}); 8158 public static final BitSet FOLLOW_I_FIELD_in_field383 = new BitSet(new long[]{0x0000000000000004L}); 8159 public static final BitSet FOLLOW_SIMPLE_NAME_in_field385 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L}); 8160 public static final BitSet FOLLOW_access_list_in_field387 = new BitSet(new long[]{0x0000000000000000L,0x0040000000000000L}); 8161 public static final BitSet FOLLOW_I_FIELD_TYPE_in_field390 = new BitSet(new long[]{0x0000000000000004L}); 8162 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_field392 = new BitSet(new long[]{0x0000000000000008L}); 8163 public static final BitSet FOLLOW_field_initial_value_in_field395 = new BitSet(new long[]{0x0000000000000008L,0x0000000400000000L}); 8164 public static final BitSet FOLLOW_annotations_in_field397 = new BitSet(new long[]{0x0000000000000008L}); 8165 public static final BitSet FOLLOW_I_FIELD_INITIAL_VALUE_in_field_initial_value418 = new BitSet(new long[]{0x0000000000000004L}); 8166 public static final BitSet FOLLOW_literal_in_field_initial_value420 = new BitSet(new long[]{0x0000000000000008L}); 8167 public static final BitSet FOLLOW_integer_literal_in_literal442 = new BitSet(new long[]{0x0000000000000002L}); 8168 public static final BitSet FOLLOW_long_literal_in_literal450 = new BitSet(new long[]{0x0000000000000002L}); 8169 public static final BitSet FOLLOW_short_literal_in_literal458 = new BitSet(new long[]{0x0000000000000002L}); 8170 public static final BitSet FOLLOW_byte_literal_in_literal466 = new BitSet(new long[]{0x0000000000000002L}); 8171 public static final BitSet FOLLOW_float_literal_in_literal474 = new BitSet(new long[]{0x0000000000000002L}); 8172 public static final BitSet FOLLOW_double_literal_in_literal482 = new BitSet(new long[]{0x0000000000000002L}); 8173 public static final BitSet FOLLOW_char_literal_in_literal490 = new BitSet(new long[]{0x0000000000000002L}); 8174 public static final BitSet FOLLOW_string_literal_in_literal498 = new BitSet(new long[]{0x0000000000000002L}); 8175 public static final BitSet FOLLOW_bool_literal_in_literal506 = new BitSet(new long[]{0x0000000000000002L}); 8176 public static final BitSet FOLLOW_NULL_LITERAL_in_literal514 = new BitSet(new long[]{0x0000000000000002L}); 8177 public static final BitSet FOLLOW_type_descriptor_in_literal522 = new BitSet(new long[]{0x0000000000000002L}); 8178 public static final BitSet FOLLOW_array_literal_in_literal530 = new BitSet(new long[]{0x0000000000000002L}); 8179 public static final BitSet FOLLOW_subannotation_in_literal538 = new BitSet(new long[]{0x0000000000000002L}); 8180 public static final BitSet FOLLOW_field_literal_in_literal546 = new BitSet(new long[]{0x0000000000000002L}); 8181 public static final BitSet FOLLOW_method_literal_in_literal554 = new BitSet(new long[]{0x0000000000000002L}); 8182 public static final BitSet FOLLOW_enum_literal_in_literal562 = new BitSet(new long[]{0x0000000000000002L}); 8183 public static final BitSet FOLLOW_method_handle_literal_in_literal570 = new BitSet(new long[]{0x0000000000000002L}); 8184 public static final BitSet FOLLOW_method_prototype_in_literal578 = new BitSet(new long[]{0x0000000000000002L}); 8185 public static final BitSet FOLLOW_integer_literal_in_fixed_64bit_literal_number594 = new BitSet(new long[]{0x0000000000000002L}); 8186 public static final BitSet FOLLOW_long_literal_in_fixed_64bit_literal_number602 = new BitSet(new long[]{0x0000000000000002L}); 8187 public static final BitSet FOLLOW_short_literal_in_fixed_64bit_literal_number610 = new BitSet(new long[]{0x0000000000000002L}); 8188 public static final BitSet FOLLOW_byte_literal_in_fixed_64bit_literal_number618 = new BitSet(new long[]{0x0000000000000002L}); 8189 public static final BitSet FOLLOW_float_literal_in_fixed_64bit_literal_number626 = new BitSet(new long[]{0x0000000000000002L}); 8190 public static final BitSet FOLLOW_double_literal_in_fixed_64bit_literal_number634 = new BitSet(new long[]{0x0000000000000002L}); 8191 public static final BitSet FOLLOW_char_literal_in_fixed_64bit_literal_number642 = new BitSet(new long[]{0x0000000000000002L}); 8192 public static final BitSet FOLLOW_bool_literal_in_fixed_64bit_literal_number650 = new BitSet(new long[]{0x0000000000000002L}); 8193 public static final BitSet FOLLOW_integer_literal_in_fixed_64bit_literal665 = new BitSet(new long[]{0x0000000000000002L}); 8194 public static final BitSet FOLLOW_long_literal_in_fixed_64bit_literal673 = new BitSet(new long[]{0x0000000000000002L}); 8195 public static final BitSet FOLLOW_short_literal_in_fixed_64bit_literal681 = new BitSet(new long[]{0x0000000000000002L}); 8196 public static final BitSet FOLLOW_byte_literal_in_fixed_64bit_literal689 = new BitSet(new long[]{0x0000000000000002L}); 8197 public static final BitSet FOLLOW_float_literal_in_fixed_64bit_literal697 = new BitSet(new long[]{0x0000000000000002L}); 8198 public static final BitSet FOLLOW_double_literal_in_fixed_64bit_literal705 = new BitSet(new long[]{0x0000000000000002L}); 8199 public static final BitSet FOLLOW_char_literal_in_fixed_64bit_literal713 = new BitSet(new long[]{0x0000000000000002L}); 8200 public static final BitSet FOLLOW_bool_literal_in_fixed_64bit_literal721 = new BitSet(new long[]{0x0000000000000002L}); 8201 public static final BitSet FOLLOW_integer_literal_in_fixed_32bit_literal738 = new BitSet(new long[]{0x0000000000000002L}); 8202 public static final BitSet FOLLOW_long_literal_in_fixed_32bit_literal746 = new BitSet(new long[]{0x0000000000000002L}); 8203 public static final BitSet FOLLOW_short_literal_in_fixed_32bit_literal754 = new BitSet(new long[]{0x0000000000000002L}); 8204 public static final BitSet FOLLOW_byte_literal_in_fixed_32bit_literal762 = new BitSet(new long[]{0x0000000000000002L}); 8205 public static final BitSet FOLLOW_float_literal_in_fixed_32bit_literal770 = new BitSet(new long[]{0x0000000000000002L}); 8206 public static final BitSet FOLLOW_char_literal_in_fixed_32bit_literal778 = new BitSet(new long[]{0x0000000000000002L}); 8207 public static final BitSet FOLLOW_bool_literal_in_fixed_32bit_literal786 = new BitSet(new long[]{0x0000000000000002L}); 8208 public static final BitSet FOLLOW_I_ARRAY_ELEMENTS_in_array_elements808 = new BitSet(new long[]{0x0000000000000004L}); 8209 public static final BitSet FOLLOW_fixed_64bit_literal_number_in_array_elements817 = new BitSet(new long[]{0x0000008000809808L,0x0000000040000000L,0x0800000000000000L,0x0000000000002000L}); 8210 public static final BitSet FOLLOW_I_PACKED_SWITCH_ELEMENTS_in_packed_switch_elements853 = new BitSet(new long[]{0x0000000000000004L}); 8211 public static final BitSet FOLLOW_label_ref_in_packed_switch_elements862 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 8212 public static final BitSet FOLLOW_I_SPARSE_SWITCH_ELEMENTS_in_sparse_switch_elements897 = new BitSet(new long[]{0x0000000000000004L}); 8213 public static final BitSet FOLLOW_fixed_32bit_literal_in_sparse_switch_elements907 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 8214 public static final BitSet FOLLOW_label_ref_in_sparse_switch_elements909 = new BitSet(new long[]{0x0000008000009808L,0x0000000040000000L,0x0800000000000000L,0x0000000000002000L}); 8215 public static final BitSet FOLLOW_I_METHOD_in_method961 = new BitSet(new long[]{0x0000000000000004L}); 8216 public static final BitSet FOLLOW_method_name_and_prototype_in_method969 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L}); 8217 public static final BitSet FOLLOW_access_list_in_method977 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L,0x0000000000000081L}); 8218 public static final BitSet FOLLOW_registers_directive_in_method1004 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000001L}); 8219 public static final BitSet FOLLOW_ordered_method_items_in_method1061 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L}); 8220 public static final BitSet FOLLOW_catches_in_method1069 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000010L}); 8221 public static final BitSet FOLLOW_parameters_in_method1077 = new BitSet(new long[]{0x0000000000000000L,0x0000000400000000L}); 8222 public static final BitSet FOLLOW_annotations_in_method1086 = new BitSet(new long[]{0x0000000000000008L}); 8223 public static final BitSet FOLLOW_I_METHOD_PROTOTYPE_in_method_prototype1110 = new BitSet(new long[]{0x0000000000000004L}); 8224 public static final BitSet FOLLOW_I_METHOD_RETURN_TYPE_in_method_prototype1113 = new BitSet(new long[]{0x0000000000000004L}); 8225 public static final BitSet FOLLOW_type_descriptor_in_method_prototype1115 = new BitSet(new long[]{0x0000000000000008L}); 8226 public static final BitSet FOLLOW_method_type_list_in_method_prototype1118 = new BitSet(new long[]{0x0000000000000008L}); 8227 public static final BitSet FOLLOW_SIMPLE_NAME_in_method_name_and_prototype1136 = new BitSet(new long[]{0x0000000000000000L,0x4000000000000000L}); 8228 public static final BitSet FOLLOW_method_prototype_in_method_name_and_prototype1138 = new BitSet(new long[]{0x0000000000000002L}); 8229 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_method_type_list1172 = new BitSet(new long[]{0x0000000000010102L,0x0000000000000000L,0x0000000000000000L,0x0000000000000100L}); 8230 public static final BitSet FOLLOW_I_CALL_SITE_REFERENCE_in_call_site_reference1203 = new BitSet(new long[]{0x0000000000000004L}); 8231 public static final BitSet FOLLOW_SIMPLE_NAME_in_call_site_reference1207 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L}); 8232 public static final BitSet FOLLOW_string_literal_in_call_site_reference1211 = new BitSet(new long[]{0x0000000000000000L,0x4000000000000000L}); 8233 public static final BitSet FOLLOW_method_prototype_in_call_site_reference1213 = new BitSet(new long[]{0x0000000000000000L,0x0000004000000000L}); 8234 public static final BitSet FOLLOW_call_site_extra_arguments_in_call_site_reference1223 = new BitSet(new long[]{0x0000000000010100L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 8235 public static final BitSet FOLLOW_method_reference_in_call_site_reference1225 = new BitSet(new long[]{0x0000000000000008L}); 8236 public static final BitSet FOLLOW_set_in_method_handle_type1245 = new BitSet(new long[]{0x0000000000000002L}); 8237 public static final BitSet FOLLOW_method_handle_type_in_method_handle_reference1270 = new BitSet(new long[]{0x0000000000010100L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 8238 public static final BitSet FOLLOW_field_reference_in_method_handle_reference1273 = new BitSet(new long[]{0x0000000000000002L}); 8239 public static final BitSet FOLLOW_method_reference_in_method_handle_reference1277 = new BitSet(new long[]{0x0000000000000002L}); 8240 public static final BitSet FOLLOW_I_ENCODED_METHOD_HANDLE_in_method_handle_literal1294 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L,0xC000000000000000L}); 8241 public static final BitSet FOLLOW_method_handle_reference_in_method_handle_literal1296 = new BitSet(new long[]{0x0000000000000002L}); 8242 public static final BitSet FOLLOW_reference_type_descriptor_in_method_reference1312 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 8243 public static final BitSet FOLLOW_SIMPLE_NAME_in_method_reference1315 = new BitSet(new long[]{0x0000000000000000L,0x4000000000000000L}); 8244 public static final BitSet FOLLOW_method_prototype_in_method_reference1317 = new BitSet(new long[]{0x0000000000000002L}); 8245 public static final BitSet FOLLOW_reference_type_descriptor_in_field_reference1334 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 8246 public static final BitSet FOLLOW_SIMPLE_NAME_in_field_reference1337 = new BitSet(new long[]{0x0000000000010100L,0x0000000000000000L,0x0000000000000000L,0x0000000000000100L}); 8247 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_field_reference1339 = new BitSet(new long[]{0x0000000000000002L}); 8248 public static final BitSet FOLLOW_I_REGISTERS_in_registers_directive1365 = new BitSet(new long[]{0x0000000000000004L}); 8249 public static final BitSet FOLLOW_I_LOCALS_in_registers_directive1377 = new BitSet(new long[]{0x0000000000000004L}); 8250 public static final BitSet FOLLOW_short_integral_literal_in_registers_directive1395 = new BitSet(new long[]{0x0000000000000008L}); 8251 public static final BitSet FOLLOW_I_LABEL_in_label_def1415 = new BitSet(new long[]{0x0000000000000004L}); 8252 public static final BitSet FOLLOW_SIMPLE_NAME_in_label_def1417 = new BitSet(new long[]{0x0000000000000008L}); 8253 public static final BitSet FOLLOW_I_CATCHES_in_catches1443 = new BitSet(new long[]{0x0000000000000004L}); 8254 public static final BitSet FOLLOW_catch_directive_in_catches1445 = new BitSet(new long[]{0x0000000000000008L,0x0000030000000000L}); 8255 public static final BitSet FOLLOW_catchall_directive_in_catches1448 = new BitSet(new long[]{0x0000000000000008L,0x0000020000000000L}); 8256 public static final BitSet FOLLOW_I_CATCH_in_catch_directive1461 = new BitSet(new long[]{0x0000000000000004L}); 8257 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_catch_directive1463 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 8258 public static final BitSet FOLLOW_label_ref_in_catch_directive1467 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 8259 public static final BitSet FOLLOW_label_ref_in_catch_directive1471 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 8260 public static final BitSet FOLLOW_label_ref_in_catch_directive1475 = new BitSet(new long[]{0x0000000000000008L}); 8261 public static final BitSet FOLLOW_I_CATCHALL_in_catchall_directive1491 = new BitSet(new long[]{0x0000000000000004L}); 8262 public static final BitSet FOLLOW_label_ref_in_catchall_directive1495 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 8263 public static final BitSet FOLLOW_label_ref_in_catchall_directive1499 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 8264 public static final BitSet FOLLOW_label_ref_in_catchall_directive1503 = new BitSet(new long[]{0x0000000000000008L}); 8265 public static final BitSet FOLLOW_I_PARAMETERS_in_parameters1520 = new BitSet(new long[]{0x0000000000000004L}); 8266 public static final BitSet FOLLOW_parameter_in_parameters1523 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000000L,0x0000000000000008L}); 8267 public static final BitSet FOLLOW_I_PARAMETER_in_parameter1539 = new BitSet(new long[]{0x0000000000000004L}); 8268 public static final BitSet FOLLOW_REGISTER_in_parameter1541 = new BitSet(new long[]{0x0000000000000000L,0x0000000400000000L,0x0000000000000000L,0x0000000000020000L}); 8269 public static final BitSet FOLLOW_string_literal_in_parameter1543 = new BitSet(new long[]{0x0000000000000000L,0x0000000400000000L}); 8270 public static final BitSet FOLLOW_annotations_in_parameter1546 = new BitSet(new long[]{0x0000000000000008L}); 8271 public static final BitSet FOLLOW_line_in_debug_directive1563 = new BitSet(new long[]{0x0000000000000002L}); 8272 public static final BitSet FOLLOW_local_in_debug_directive1569 = new BitSet(new long[]{0x0000000000000002L}); 8273 public static final BitSet FOLLOW_end_local_in_debug_directive1575 = new BitSet(new long[]{0x0000000000000002L}); 8274 public static final BitSet FOLLOW_restart_local_in_debug_directive1581 = new BitSet(new long[]{0x0000000000000002L}); 8275 public static final BitSet FOLLOW_prologue_in_debug_directive1587 = new BitSet(new long[]{0x0000000000000002L}); 8276 public static final BitSet FOLLOW_epilogue_in_debug_directive1593 = new BitSet(new long[]{0x0000000000000002L}); 8277 public static final BitSet FOLLOW_source_in_debug_directive1599 = new BitSet(new long[]{0x0000000000000002L}); 8278 public static final BitSet FOLLOW_I_LINE_in_line1610 = new BitSet(new long[]{0x0000000000000004L}); 8279 public static final BitSet FOLLOW_integral_literal_in_line1612 = new BitSet(new long[]{0x0000000000000008L}); 8280 public static final BitSet FOLLOW_I_LOCAL_in_local1630 = new BitSet(new long[]{0x0000000000000004L}); 8281 public static final BitSet FOLLOW_REGISTER_in_local1632 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000000L,0x0000000000000000L,0x0000000000020002L}); 8282 public static final BitSet FOLLOW_NULL_LITERAL_in_local1636 = new BitSet(new long[]{0x0000000000010108L,0x0000000000000000L,0x0000000000000000L,0x0000000000020100L}); 8283 public static final BitSet FOLLOW_string_literal_in_local1642 = new BitSet(new long[]{0x0000000000010108L,0x0000000000000000L,0x0000000000000000L,0x0000000000020100L}); 8284 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_local1645 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L}); 8285 public static final BitSet FOLLOW_string_literal_in_local1650 = new BitSet(new long[]{0x0000000000000008L}); 8286 public static final BitSet FOLLOW_I_END_LOCAL_in_end_local1671 = new BitSet(new long[]{0x0000000000000004L}); 8287 public static final BitSet FOLLOW_REGISTER_in_end_local1673 = new BitSet(new long[]{0x0000000000000008L}); 8288 public static final BitSet FOLLOW_I_RESTART_LOCAL_in_restart_local1691 = new BitSet(new long[]{0x0000000000000004L}); 8289 public static final BitSet FOLLOW_REGISTER_in_restart_local1693 = new BitSet(new long[]{0x0000000000000008L}); 8290 public static final BitSet FOLLOW_I_PROLOGUE_in_prologue1710 = new BitSet(new long[]{0x0000000000000002L}); 8291 public static final BitSet FOLLOW_I_EPILOGUE_in_epilogue1726 = new BitSet(new long[]{0x0000000000000002L}); 8292 public static final BitSet FOLLOW_I_SOURCE_in_source1743 = new BitSet(new long[]{0x0000000000000004L}); 8293 public static final BitSet FOLLOW_string_literal_in_source1745 = new BitSet(new long[]{0x0000000000000008L}); 8294 public static final BitSet FOLLOW_I_CALL_SITE_EXTRA_ARGUMENTS_in_call_site_extra_arguments1771 = new BitSet(new long[]{0x0000000000000004L}); 8295 public static final BitSet FOLLOW_literal_in_call_site_extra_arguments1774 = new BitSet(new long[]{0x0000008000819908L,0x4001F00040000000L,0x0820000000000000L,0x0000000000222102L}); 8296 public static final BitSet FOLLOW_I_ORDERED_METHOD_ITEMS_in_ordered_method_items1790 = new BitSet(new long[]{0x0000000000000004L}); 8297 public static final BitSet FOLLOW_label_def_in_ordered_method_items1793 = new BitSet(new long[]{0x0000000000000008L,0x0706000000000000L,0x001FFFFFFFFFEC40L}); 8298 public static final BitSet FOLLOW_instruction_in_ordered_method_items1797 = new BitSet(new long[]{0x0000000000000008L,0x0706000000000000L,0x001FFFFFFFFFEC40L}); 8299 public static final BitSet FOLLOW_debug_directive_in_ordered_method_items1801 = new BitSet(new long[]{0x0000000000000008L,0x0706000000000000L,0x001FFFFFFFFFEC40L}); 8300 public static final BitSet FOLLOW_SIMPLE_NAME_in_label_ref1817 = new BitSet(new long[]{0x0000000000000002L}); 8301 public static final BitSet FOLLOW_I_REGISTER_LIST_in_register_list1842 = new BitSet(new long[]{0x0000000000000004L}); 8302 public static final BitSet FOLLOW_REGISTER_in_register_list1851 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8303 public static final BitSet FOLLOW_I_REGISTER_RANGE_in_register_range1876 = new BitSet(new long[]{0x0000000000000004L}); 8304 public static final BitSet FOLLOW_REGISTER_in_register_range1881 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8305 public static final BitSet FOLLOW_REGISTER_in_register_range1885 = new BitSet(new long[]{0x0000000000000008L}); 8306 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_verification_error_reference1908 = new BitSet(new long[]{0x0000000000000002L}); 8307 public static final BitSet FOLLOW_field_reference_in_verification_error_reference1918 = new BitSet(new long[]{0x0000000000000002L}); 8308 public static final BitSet FOLLOW_method_reference_in_verification_error_reference1928 = new BitSet(new long[]{0x0000000000000002L}); 8309 public static final BitSet FOLLOW_VERIFICATION_ERROR_TYPE_in_verification_error_type1945 = new BitSet(new long[]{0x0000000000000002L}); 8310 public static final BitSet FOLLOW_insn_format10t_in_instruction1959 = new BitSet(new long[]{0x0000000000000002L}); 8311 public static final BitSet FOLLOW_insn_format10x_in_instruction1965 = new BitSet(new long[]{0x0000000000000002L}); 8312 public static final BitSet FOLLOW_insn_format11n_in_instruction1971 = new BitSet(new long[]{0x0000000000000002L}); 8313 public static final BitSet FOLLOW_insn_format11x_in_instruction1977 = new BitSet(new long[]{0x0000000000000002L}); 8314 public static final BitSet FOLLOW_insn_format12x_in_instruction1983 = new BitSet(new long[]{0x0000000000000002L}); 8315 public static final BitSet FOLLOW_insn_format20bc_in_instruction1989 = new BitSet(new long[]{0x0000000000000002L}); 8316 public static final BitSet FOLLOW_insn_format20t_in_instruction1995 = new BitSet(new long[]{0x0000000000000002L}); 8317 public static final BitSet FOLLOW_insn_format21c_field_in_instruction2001 = new BitSet(new long[]{0x0000000000000002L}); 8318 public static final BitSet FOLLOW_insn_format21c_method_handle_in_instruction2007 = new BitSet(new long[]{0x0000000000000002L}); 8319 public static final BitSet FOLLOW_insn_format21c_method_type_in_instruction2013 = new BitSet(new long[]{0x0000000000000002L}); 8320 public static final BitSet FOLLOW_insn_format21c_string_in_instruction2019 = new BitSet(new long[]{0x0000000000000002L}); 8321 public static final BitSet FOLLOW_insn_format21c_type_in_instruction2025 = new BitSet(new long[]{0x0000000000000002L}); 8322 public static final BitSet FOLLOW_insn_format21ih_in_instruction2031 = new BitSet(new long[]{0x0000000000000002L}); 8323 public static final BitSet FOLLOW_insn_format21lh_in_instruction2037 = new BitSet(new long[]{0x0000000000000002L}); 8324 public static final BitSet FOLLOW_insn_format21s_in_instruction2043 = new BitSet(new long[]{0x0000000000000002L}); 8325 public static final BitSet FOLLOW_insn_format21t_in_instruction2049 = new BitSet(new long[]{0x0000000000000002L}); 8326 public static final BitSet FOLLOW_insn_format22b_in_instruction2055 = new BitSet(new long[]{0x0000000000000002L}); 8327 public static final BitSet FOLLOW_insn_format22c_field_in_instruction2061 = new BitSet(new long[]{0x0000000000000002L}); 8328 public static final BitSet FOLLOW_insn_format22c_type_in_instruction2067 = new BitSet(new long[]{0x0000000000000002L}); 8329 public static final BitSet FOLLOW_insn_format22s_in_instruction2073 = new BitSet(new long[]{0x0000000000000002L}); 8330 public static final BitSet FOLLOW_insn_format22t_in_instruction2079 = new BitSet(new long[]{0x0000000000000002L}); 8331 public static final BitSet FOLLOW_insn_format22x_in_instruction2085 = new BitSet(new long[]{0x0000000000000002L}); 8332 public static final BitSet FOLLOW_insn_format23x_in_instruction2091 = new BitSet(new long[]{0x0000000000000002L}); 8333 public static final BitSet FOLLOW_insn_format30t_in_instruction2097 = new BitSet(new long[]{0x0000000000000002L}); 8334 public static final BitSet FOLLOW_insn_format31c_in_instruction2103 = new BitSet(new long[]{0x0000000000000002L}); 8335 public static final BitSet FOLLOW_insn_format31i_in_instruction2109 = new BitSet(new long[]{0x0000000000000002L}); 8336 public static final BitSet FOLLOW_insn_format31t_in_instruction2115 = new BitSet(new long[]{0x0000000000000002L}); 8337 public static final BitSet FOLLOW_insn_format32x_in_instruction2121 = new BitSet(new long[]{0x0000000000000002L}); 8338 public static final BitSet FOLLOW_insn_format35c_call_site_in_instruction2127 = new BitSet(new long[]{0x0000000000000002L}); 8339 public static final BitSet FOLLOW_insn_format35c_method_in_instruction2133 = new BitSet(new long[]{0x0000000000000002L}); 8340 public static final BitSet FOLLOW_insn_format35c_type_in_instruction2139 = new BitSet(new long[]{0x0000000000000002L}); 8341 public static final BitSet FOLLOW_insn_format3rc_call_site_in_instruction2145 = new BitSet(new long[]{0x0000000000000002L}); 8342 public static final BitSet FOLLOW_insn_format3rc_method_in_instruction2151 = new BitSet(new long[]{0x0000000000000002L}); 8343 public static final BitSet FOLLOW_insn_format3rc_type_in_instruction2157 = new BitSet(new long[]{0x0000000000000002L}); 8344 public static final BitSet FOLLOW_insn_format45cc_method_in_instruction2163 = new BitSet(new long[]{0x0000000000000002L}); 8345 public static final BitSet FOLLOW_insn_format4rcc_method_in_instruction2169 = new BitSet(new long[]{0x0000000000000002L}); 8346 public static final BitSet FOLLOW_insn_format51l_type_in_instruction2175 = new BitSet(new long[]{0x0000000000000002L}); 8347 public static final BitSet FOLLOW_insn_array_data_directive_in_instruction2181 = new BitSet(new long[]{0x0000000000000002L}); 8348 public static final BitSet FOLLOW_insn_packed_switch_directive_in_instruction2187 = new BitSet(new long[]{0x0000000000000002L}); 8349 public static final BitSet FOLLOW_insn_sparse_switch_directive_in_instruction2193 = new BitSet(new long[]{0x0000000000000002L}); 8350 public static final BitSet FOLLOW_I_STATEMENT_FORMAT10t_in_insn_format10t2217 = new BitSet(new long[]{0x0000000000000004L}); 8351 public static final BitSet FOLLOW_INSTRUCTION_FORMAT10t_in_insn_format10t2219 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 8352 public static final BitSet FOLLOW_label_ref_in_insn_format10t2221 = new BitSet(new long[]{0x0000000000000008L}); 8353 public static final BitSet FOLLOW_I_STATEMENT_FORMAT10x_in_insn_format10x2244 = new BitSet(new long[]{0x0000000000000004L}); 8354 public static final BitSet FOLLOW_INSTRUCTION_FORMAT10x_in_insn_format10x2246 = new BitSet(new long[]{0x0000000000000008L}); 8355 public static final BitSet FOLLOW_I_STATEMENT_FORMAT11n_in_insn_format11n2269 = new BitSet(new long[]{0x0000000000000004L}); 8356 public static final BitSet FOLLOW_INSTRUCTION_FORMAT11n_in_insn_format11n2271 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8357 public static final BitSet FOLLOW_REGISTER_in_insn_format11n2273 = new BitSet(new long[]{0x0000000000009000L,0x0000000040000000L,0x0800000000000000L,0x0000000000002000L}); 8358 public static final BitSet FOLLOW_short_integral_literal_in_insn_format11n2275 = new BitSet(new long[]{0x0000000000000008L}); 8359 public static final BitSet FOLLOW_I_STATEMENT_FORMAT11x_in_insn_format11x2298 = new BitSet(new long[]{0x0000000000000004L}); 8360 public static final BitSet FOLLOW_INSTRUCTION_FORMAT11x_in_insn_format11x2300 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8361 public static final BitSet FOLLOW_REGISTER_in_insn_format11x2302 = new BitSet(new long[]{0x0000000000000008L}); 8362 public static final BitSet FOLLOW_I_STATEMENT_FORMAT12x_in_insn_format12x2325 = new BitSet(new long[]{0x0000000000000004L}); 8363 public static final BitSet FOLLOW_INSTRUCTION_FORMAT12x_in_insn_format12x2327 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8364 public static final BitSet FOLLOW_REGISTER_in_insn_format12x2331 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8365 public static final BitSet FOLLOW_REGISTER_in_insn_format12x2335 = new BitSet(new long[]{0x0000000000000008L}); 8366 public static final BitSet FOLLOW_I_STATEMENT_FORMAT20bc_in_insn_format20bc2358 = new BitSet(new long[]{0x0000000000000004L}); 8367 public static final BitSet FOLLOW_INSTRUCTION_FORMAT20bc_in_insn_format20bc2360 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000100000L}); 8368 public static final BitSet FOLLOW_verification_error_type_in_insn_format20bc2362 = new BitSet(new long[]{0x0000000000010100L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 8369 public static final BitSet FOLLOW_verification_error_reference_in_insn_format20bc2364 = new BitSet(new long[]{0x0000000000000008L}); 8370 public static final BitSet FOLLOW_I_STATEMENT_FORMAT20t_in_insn_format20t2387 = new BitSet(new long[]{0x0000000000000004L}); 8371 public static final BitSet FOLLOW_INSTRUCTION_FORMAT20t_in_insn_format20t2389 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 8372 public static final BitSet FOLLOW_label_ref_in_insn_format20t2391 = new BitSet(new long[]{0x0000000000000008L}); 8373 public static final BitSet FOLLOW_I_STATEMENT_FORMAT21c_FIELD_in_insn_format21c_field2414 = new BitSet(new long[]{0x0000000000000004L}); 8374 public static final BitSet FOLLOW_set_in_insn_format21c_field2418 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8375 public static final BitSet FOLLOW_REGISTER_in_insn_format21c_field2426 = new BitSet(new long[]{0x0000000000010100L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 8376 public static final BitSet FOLLOW_field_reference_in_insn_format21c_field2428 = new BitSet(new long[]{0x0000000000000008L}); 8377 public static final BitSet FOLLOW_I_STATEMENT_FORMAT21c_METHOD_HANDLE_in_insn_format21c_method_handle2451 = new BitSet(new long[]{0x0000000000000004L}); 8378 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_METHOD_HANDLE_in_insn_format21c_method_handle2456 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8379 public static final BitSet FOLLOW_REGISTER_in_insn_format21c_method_handle2459 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L,0xC000000000000000L}); 8380 public static final BitSet FOLLOW_method_handle_reference_in_insn_format21c_method_handle2461 = new BitSet(new long[]{0x0000000000000008L}); 8381 public static final BitSet FOLLOW_I_STATEMENT_FORMAT21c_METHOD_TYPE_in_insn_format21c_method_type2484 = new BitSet(new long[]{0x0000000000000004L}); 8382 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_METHOD_TYPE_in_insn_format21c_method_type2489 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8383 public static final BitSet FOLLOW_REGISTER_in_insn_format21c_method_type2492 = new BitSet(new long[]{0x0000000000000000L,0x4000000000000000L}); 8384 public static final BitSet FOLLOW_method_prototype_in_insn_format21c_method_type2494 = new BitSet(new long[]{0x0000000000000008L}); 8385 public static final BitSet FOLLOW_I_STATEMENT_FORMAT21c_STRING_in_insn_format21c_string2517 = new BitSet(new long[]{0x0000000000000004L}); 8386 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_STRING_in_insn_format21c_string2519 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8387 public static final BitSet FOLLOW_REGISTER_in_insn_format21c_string2521 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L}); 8388 public static final BitSet FOLLOW_string_literal_in_insn_format21c_string2523 = new BitSet(new long[]{0x0000000000000008L}); 8389 public static final BitSet FOLLOW_I_STATEMENT_FORMAT21c_TYPE_in_insn_format21c_type2546 = new BitSet(new long[]{0x0000000000000004L}); 8390 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_TYPE_in_insn_format21c_type2548 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8391 public static final BitSet FOLLOW_REGISTER_in_insn_format21c_type2550 = new BitSet(new long[]{0x0000000000010100L,0x0000000000000000L,0x0000000000000000L,0x0000000000000100L}); 8392 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_insn_format21c_type2552 = new BitSet(new long[]{0x0000000000000008L}); 8393 public static final BitSet FOLLOW_I_STATEMENT_FORMAT21ih_in_insn_format21ih2575 = new BitSet(new long[]{0x0000000000000004L}); 8394 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21ih_in_insn_format21ih2577 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8395 public static final BitSet FOLLOW_REGISTER_in_insn_format21ih2579 = new BitSet(new long[]{0x0000008000009800L,0x0000000040000000L,0x0800000000000000L,0x0000000000002000L}); 8396 public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_format21ih2581 = new BitSet(new long[]{0x0000000000000008L}); 8397 public static final BitSet FOLLOW_I_STATEMENT_FORMAT21lh_in_insn_format21lh2604 = new BitSet(new long[]{0x0000000000000004L}); 8398 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21lh_in_insn_format21lh2606 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8399 public static final BitSet FOLLOW_REGISTER_in_insn_format21lh2608 = new BitSet(new long[]{0x0000008000809800L,0x0000000040000000L,0x0800000000000000L,0x0000000000002000L}); 8400 public static final BitSet FOLLOW_fixed_64bit_literal_in_insn_format21lh2610 = new BitSet(new long[]{0x0000000000000008L}); 8401 public static final BitSet FOLLOW_I_STATEMENT_FORMAT21s_in_insn_format21s2633 = new BitSet(new long[]{0x0000000000000004L}); 8402 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21s_in_insn_format21s2635 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8403 public static final BitSet FOLLOW_REGISTER_in_insn_format21s2637 = new BitSet(new long[]{0x0000000000009000L,0x0000000040000000L,0x0800000000000000L,0x0000000000002000L}); 8404 public static final BitSet FOLLOW_short_integral_literal_in_insn_format21s2639 = new BitSet(new long[]{0x0000000000000008L}); 8405 public static final BitSet FOLLOW_I_STATEMENT_FORMAT21t_in_insn_format21t2662 = new BitSet(new long[]{0x0000000000000004L}); 8406 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21t_in_insn_format21t2664 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8407 public static final BitSet FOLLOW_REGISTER_in_insn_format21t2666 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 8408 public static final BitSet FOLLOW_label_ref_in_insn_format21t2668 = new BitSet(new long[]{0x0000000000000008L}); 8409 public static final BitSet FOLLOW_I_STATEMENT_FORMAT22b_in_insn_format22b2691 = new BitSet(new long[]{0x0000000000000004L}); 8410 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22b_in_insn_format22b2693 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8411 public static final BitSet FOLLOW_REGISTER_in_insn_format22b2697 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8412 public static final BitSet FOLLOW_REGISTER_in_insn_format22b2701 = new BitSet(new long[]{0x0000000000009000L,0x0000000040000000L,0x0800000000000000L,0x0000000000002000L}); 8413 public static final BitSet FOLLOW_short_integral_literal_in_insn_format22b2703 = new BitSet(new long[]{0x0000000000000008L}); 8414 public static final BitSet FOLLOW_I_STATEMENT_FORMAT22c_FIELD_in_insn_format22c_field2726 = new BitSet(new long[]{0x0000000000000004L}); 8415 public static final BitSet FOLLOW_set_in_insn_format22c_field2730 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8416 public static final BitSet FOLLOW_REGISTER_in_insn_format22c_field2740 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8417 public static final BitSet FOLLOW_REGISTER_in_insn_format22c_field2744 = new BitSet(new long[]{0x0000000000010100L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 8418 public static final BitSet FOLLOW_field_reference_in_insn_format22c_field2746 = new BitSet(new long[]{0x0000000000000008L}); 8419 public static final BitSet FOLLOW_I_STATEMENT_FORMAT22c_TYPE_in_insn_format22c_type2769 = new BitSet(new long[]{0x0000000000000004L}); 8420 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_TYPE_in_insn_format22c_type2771 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8421 public static final BitSet FOLLOW_REGISTER_in_insn_format22c_type2775 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8422 public static final BitSet FOLLOW_REGISTER_in_insn_format22c_type2779 = new BitSet(new long[]{0x0000000000010100L,0x0000000000000000L,0x0000000000000000L,0x0000000000000100L}); 8423 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_insn_format22c_type2781 = new BitSet(new long[]{0x0000000000000008L}); 8424 public static final BitSet FOLLOW_I_STATEMENT_FORMAT22s_in_insn_format22s2804 = new BitSet(new long[]{0x0000000000000004L}); 8425 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22s_in_insn_format22s2806 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8426 public static final BitSet FOLLOW_REGISTER_in_insn_format22s2810 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8427 public static final BitSet FOLLOW_REGISTER_in_insn_format22s2814 = new BitSet(new long[]{0x0000000000009000L,0x0000000040000000L,0x0800000000000000L,0x0000000000002000L}); 8428 public static final BitSet FOLLOW_short_integral_literal_in_insn_format22s2816 = new BitSet(new long[]{0x0000000000000008L}); 8429 public static final BitSet FOLLOW_I_STATEMENT_FORMAT22t_in_insn_format22t2839 = new BitSet(new long[]{0x0000000000000004L}); 8430 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22t_in_insn_format22t2841 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8431 public static final BitSet FOLLOW_REGISTER_in_insn_format22t2845 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8432 public static final BitSet FOLLOW_REGISTER_in_insn_format22t2849 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 8433 public static final BitSet FOLLOW_label_ref_in_insn_format22t2851 = new BitSet(new long[]{0x0000000000000008L}); 8434 public static final BitSet FOLLOW_I_STATEMENT_FORMAT22x_in_insn_format22x2874 = new BitSet(new long[]{0x0000000000000004L}); 8435 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22x_in_insn_format22x2876 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8436 public static final BitSet FOLLOW_REGISTER_in_insn_format22x2880 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8437 public static final BitSet FOLLOW_REGISTER_in_insn_format22x2884 = new BitSet(new long[]{0x0000000000000008L}); 8438 public static final BitSet FOLLOW_I_STATEMENT_FORMAT23x_in_insn_format23x2907 = new BitSet(new long[]{0x0000000000000004L}); 8439 public static final BitSet FOLLOW_INSTRUCTION_FORMAT23x_in_insn_format23x2909 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8440 public static final BitSet FOLLOW_REGISTER_in_insn_format23x2913 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8441 public static final BitSet FOLLOW_REGISTER_in_insn_format23x2917 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8442 public static final BitSet FOLLOW_REGISTER_in_insn_format23x2921 = new BitSet(new long[]{0x0000000000000008L}); 8443 public static final BitSet FOLLOW_I_STATEMENT_FORMAT30t_in_insn_format30t2944 = new BitSet(new long[]{0x0000000000000004L}); 8444 public static final BitSet FOLLOW_INSTRUCTION_FORMAT30t_in_insn_format30t2946 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 8445 public static final BitSet FOLLOW_label_ref_in_insn_format30t2948 = new BitSet(new long[]{0x0000000000000008L}); 8446 public static final BitSet FOLLOW_I_STATEMENT_FORMAT31c_in_insn_format31c2971 = new BitSet(new long[]{0x0000000000000004L}); 8447 public static final BitSet FOLLOW_INSTRUCTION_FORMAT31c_in_insn_format31c2973 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8448 public static final BitSet FOLLOW_REGISTER_in_insn_format31c2975 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L}); 8449 public static final BitSet FOLLOW_string_literal_in_insn_format31c2977 = new BitSet(new long[]{0x0000000000000008L}); 8450 public static final BitSet FOLLOW_I_STATEMENT_FORMAT31i_in_insn_format31i3000 = new BitSet(new long[]{0x0000000000000004L}); 8451 public static final BitSet FOLLOW_INSTRUCTION_FORMAT31i_in_insn_format31i3002 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8452 public static final BitSet FOLLOW_REGISTER_in_insn_format31i3004 = new BitSet(new long[]{0x0000008000009800L,0x0000000040000000L,0x0800000000000000L,0x0000000000002000L}); 8453 public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_format31i3006 = new BitSet(new long[]{0x0000000000000008L}); 8454 public static final BitSet FOLLOW_I_STATEMENT_FORMAT31t_in_insn_format31t3029 = new BitSet(new long[]{0x0000000000000004L}); 8455 public static final BitSet FOLLOW_INSTRUCTION_FORMAT31t_in_insn_format31t3031 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8456 public static final BitSet FOLLOW_REGISTER_in_insn_format31t3033 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 8457 public static final BitSet FOLLOW_label_ref_in_insn_format31t3035 = new BitSet(new long[]{0x0000000000000008L}); 8458 public static final BitSet FOLLOW_I_STATEMENT_FORMAT32x_in_insn_format32x3058 = new BitSet(new long[]{0x0000000000000004L}); 8459 public static final BitSet FOLLOW_INSTRUCTION_FORMAT32x_in_insn_format32x3060 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8460 public static final BitSet FOLLOW_REGISTER_in_insn_format32x3064 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8461 public static final BitSet FOLLOW_REGISTER_in_insn_format32x3068 = new BitSet(new long[]{0x0000000000000008L}); 8462 public static final BitSet FOLLOW_I_STATEMENT_FORMAT35c_CALL_SITE_in_insn_format35c_call_site3096 = new BitSet(new long[]{0x0000000000000004L}); 8463 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_CALL_SITE_in_insn_format35c_call_site3098 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000100L}); 8464 public static final BitSet FOLLOW_register_list_in_insn_format35c_call_site3100 = new BitSet(new long[]{0x0000000000000000L,0x0000008000000000L}); 8465 public static final BitSet FOLLOW_call_site_reference_in_insn_format35c_call_site3102 = new BitSet(new long[]{0x0000000000000008L}); 8466 public static final BitSet FOLLOW_I_STATEMENT_FORMAT35c_METHOD_in_insn_format35c_method3125 = new BitSet(new long[]{0x0000000000000004L}); 8467 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_METHOD_in_insn_format35c_method3127 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000100L}); 8468 public static final BitSet FOLLOW_register_list_in_insn_format35c_method3129 = new BitSet(new long[]{0x0000000000010100L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 8469 public static final BitSet FOLLOW_method_reference_in_insn_format35c_method3131 = new BitSet(new long[]{0x0000000000000008L}); 8470 public static final BitSet FOLLOW_I_STATEMENT_FORMAT35c_TYPE_in_insn_format35c_type3154 = new BitSet(new long[]{0x0000000000000004L}); 8471 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_TYPE_in_insn_format35c_type3156 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000100L}); 8472 public static final BitSet FOLLOW_register_list_in_insn_format35c_type3158 = new BitSet(new long[]{0x0000000000010100L,0x0000000000000000L,0x0000000000000000L,0x0000000000000100L}); 8473 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_insn_format35c_type3160 = new BitSet(new long[]{0x0000000000000008L}); 8474 public static final BitSet FOLLOW_I_STATEMENT_FORMAT3rc_CALL_SITE_in_insn_format3rc_call_site3188 = new BitSet(new long[]{0x0000000000000004L}); 8475 public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rc_CALL_SITE_in_insn_format3rc_call_site3190 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000200L}); 8476 public static final BitSet FOLLOW_register_range_in_insn_format3rc_call_site3192 = new BitSet(new long[]{0x0000000000000000L,0x0000008000000000L}); 8477 public static final BitSet FOLLOW_call_site_reference_in_insn_format3rc_call_site3194 = new BitSet(new long[]{0x0000000000000008L}); 8478 public static final BitSet FOLLOW_I_STATEMENT_FORMAT3rc_METHOD_in_insn_format3rc_method3217 = new BitSet(new long[]{0x0000000000000004L}); 8479 public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rc_METHOD_in_insn_format3rc_method3219 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000200L}); 8480 public static final BitSet FOLLOW_register_range_in_insn_format3rc_method3221 = new BitSet(new long[]{0x0000000000010100L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 8481 public static final BitSet FOLLOW_method_reference_in_insn_format3rc_method3223 = new BitSet(new long[]{0x0000000000000008L}); 8482 public static final BitSet FOLLOW_I_STATEMENT_FORMAT3rc_TYPE_in_insn_format3rc_type3246 = new BitSet(new long[]{0x0000000000000004L}); 8483 public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rc_TYPE_in_insn_format3rc_type3248 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000200L}); 8484 public static final BitSet FOLLOW_register_range_in_insn_format3rc_type3250 = new BitSet(new long[]{0x0000000000010100L,0x0000000000000000L,0x0000000000000000L,0x0000000000000100L}); 8485 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_insn_format3rc_type3252 = new BitSet(new long[]{0x0000000000000008L}); 8486 public static final BitSet FOLLOW_I_STATEMENT_FORMAT45cc_METHOD_in_insn_format45cc_method3275 = new BitSet(new long[]{0x0000000000000004L}); 8487 public static final BitSet FOLLOW_INSTRUCTION_FORMAT45cc_METHOD_in_insn_format45cc_method3277 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000100L}); 8488 public static final BitSet FOLLOW_register_list_in_insn_format45cc_method3279 = new BitSet(new long[]{0x0000000000010100L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 8489 public static final BitSet FOLLOW_method_reference_in_insn_format45cc_method3281 = new BitSet(new long[]{0x0000000000000000L,0x4000000000000000L}); 8490 public static final BitSet FOLLOW_method_prototype_in_insn_format45cc_method3283 = new BitSet(new long[]{0x0000000000000008L}); 8491 public static final BitSet FOLLOW_I_STATEMENT_FORMAT4rcc_METHOD_in_insn_format4rcc_method3306 = new BitSet(new long[]{0x0000000000000004L}); 8492 public static final BitSet FOLLOW_INSTRUCTION_FORMAT4rcc_METHOD_in_insn_format4rcc_method3308 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000200L}); 8493 public static final BitSet FOLLOW_register_range_in_insn_format4rcc_method3310 = new BitSet(new long[]{0x0000000000010100L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L}); 8494 public static final BitSet FOLLOW_method_reference_in_insn_format4rcc_method3312 = new BitSet(new long[]{0x0000000000000000L,0x4000000000000000L}); 8495 public static final BitSet FOLLOW_method_prototype_in_insn_format4rcc_method3314 = new BitSet(new long[]{0x0000000000000008L}); 8496 public static final BitSet FOLLOW_I_STATEMENT_FORMAT51l_in_insn_format51l_type3337 = new BitSet(new long[]{0x0000000000000004L}); 8497 public static final BitSet FOLLOW_INSTRUCTION_FORMAT51l_in_insn_format51l_type3339 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L}); 8498 public static final BitSet FOLLOW_REGISTER_in_insn_format51l_type3341 = new BitSet(new long[]{0x0000008000809800L,0x0000000040000000L,0x0800000000000000L,0x0000000000002000L}); 8499 public static final BitSet FOLLOW_fixed_64bit_literal_in_insn_format51l_type3343 = new BitSet(new long[]{0x0000000000000008L}); 8500 public static final BitSet FOLLOW_I_STATEMENT_ARRAY_DATA_in_insn_array_data_directive3366 = new BitSet(new long[]{0x0000000000000004L}); 8501 public static final BitSet FOLLOW_I_ARRAY_ELEMENT_SIZE_in_insn_array_data_directive3369 = new BitSet(new long[]{0x0000000000000004L}); 8502 public static final BitSet FOLLOW_short_integral_literal_in_insn_array_data_directive3371 = new BitSet(new long[]{0x0000000000000008L}); 8503 public static final BitSet FOLLOW_array_elements_in_insn_array_data_directive3374 = new BitSet(new long[]{0x0000000000000008L}); 8504 public static final BitSet FOLLOW_I_STATEMENT_PACKED_SWITCH_in_insn_packed_switch_directive3396 = new BitSet(new long[]{0x0000000000000004L}); 8505 public static final BitSet FOLLOW_I_PACKED_SWITCH_START_KEY_in_insn_packed_switch_directive3399 = new BitSet(new long[]{0x0000000000000004L}); 8506 public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_packed_switch_directive3401 = new BitSet(new long[]{0x0000000000000008L}); 8507 public static final BitSet FOLLOW_packed_switch_elements_in_insn_packed_switch_directive3404 = new BitSet(new long[]{0x0000000000000008L}); 8508 public static final BitSet FOLLOW_I_STATEMENT_SPARSE_SWITCH_in_insn_sparse_switch_directive3428 = new BitSet(new long[]{0x0000000000000004L}); 8509 public static final BitSet FOLLOW_sparse_switch_elements_in_insn_sparse_switch_directive3430 = new BitSet(new long[]{0x0000000000000008L}); 8510 public static final BitSet FOLLOW_ARRAY_TYPE_PREFIX_in_array_descriptor3451 = new BitSet(new long[]{0x0000000000010000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000100L}); 8511 public static final BitSet FOLLOW_PRIMITIVE_TYPE_in_array_descriptor3455 = new BitSet(new long[]{0x0000000000000002L}); 8512 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_array_descriptor3483 = new BitSet(new long[]{0x0000000000000002L}); 8513 public static final BitSet FOLLOW_PRIMITIVE_TYPE_in_nonvoid_type_descriptor3501 = new BitSet(new long[]{0x0000000000000002L}); 8514 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_nonvoid_type_descriptor3509 = new BitSet(new long[]{0x0000000000000002L}); 8515 public static final BitSet FOLLOW_array_descriptor_in_nonvoid_type_descriptor3517 = new BitSet(new long[]{0x0000000000000002L}); 8516 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_reference_type_descriptor3538 = new BitSet(new long[]{0x0000000000000002L}); 8517 public static final BitSet FOLLOW_array_descriptor_in_reference_type_descriptor3546 = new BitSet(new long[]{0x0000000000000002L}); 8518 public static final BitSet FOLLOW_VOID_TYPE_in_type_descriptor3566 = new BitSet(new long[]{0x0000000000000002L}); 8519 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_type_descriptor3574 = new BitSet(new long[]{0x0000000000000002L}); 8520 public static final BitSet FOLLOW_long_literal_in_short_integral_literal3592 = new BitSet(new long[]{0x0000000000000002L}); 8521 public static final BitSet FOLLOW_integer_literal_in_short_integral_literal3604 = new BitSet(new long[]{0x0000000000000002L}); 8522 public static final BitSet FOLLOW_short_literal_in_short_integral_literal3616 = new BitSet(new long[]{0x0000000000000002L}); 8523 public static final BitSet FOLLOW_char_literal_in_short_integral_literal3624 = new BitSet(new long[]{0x0000000000000002L}); 8524 public static final BitSet FOLLOW_byte_literal_in_short_integral_literal3632 = new BitSet(new long[]{0x0000000000000002L}); 8525 public static final BitSet FOLLOW_long_literal_in_integral_literal3647 = new BitSet(new long[]{0x0000000000000002L}); 8526 public static final BitSet FOLLOW_integer_literal_in_integral_literal3659 = new BitSet(new long[]{0x0000000000000002L}); 8527 public static final BitSet FOLLOW_short_literal_in_integral_literal3667 = new BitSet(new long[]{0x0000000000000002L}); 8528 public static final BitSet FOLLOW_byte_literal_in_integral_literal3675 = new BitSet(new long[]{0x0000000000000002L}); 8529 public static final BitSet FOLLOW_INTEGER_LITERAL_in_integer_literal3691 = new BitSet(new long[]{0x0000000000000002L}); 8530 public static final BitSet FOLLOW_LONG_LITERAL_in_long_literal3706 = new BitSet(new long[]{0x0000000000000002L}); 8531 public static final BitSet FOLLOW_SHORT_LITERAL_in_short_literal3721 = new BitSet(new long[]{0x0000000000000002L}); 8532 public static final BitSet FOLLOW_BYTE_LITERAL_in_byte_literal3736 = new BitSet(new long[]{0x0000000000000002L}); 8533 public static final BitSet FOLLOW_FLOAT_LITERAL_in_float_literal3751 = new BitSet(new long[]{0x0000000000000002L}); 8534 public static final BitSet FOLLOW_DOUBLE_LITERAL_in_double_literal3766 = new BitSet(new long[]{0x0000000000000002L}); 8535 public static final BitSet FOLLOW_CHAR_LITERAL_in_char_literal3781 = new BitSet(new long[]{0x0000000000000002L}); 8536 public static final BitSet FOLLOW_STRING_LITERAL_in_string_literal3796 = new BitSet(new long[]{0x0000000000000002L}); 8537 public static final BitSet FOLLOW_BOOL_LITERAL_in_bool_literal3815 = new BitSet(new long[]{0x0000000000000002L}); 8538 public static final BitSet FOLLOW_I_ENCODED_ARRAY_in_array_literal3837 = new BitSet(new long[]{0x0000000000000004L}); 8539 public static final BitSet FOLLOW_literal_in_array_literal3840 = new BitSet(new long[]{0x0000008000819908L,0x4001F00040000000L,0x0820000000000000L,0x0000000000222102L}); 8540 public static final BitSet FOLLOW_I_ANNOTATIONS_in_annotations3865 = new BitSet(new long[]{0x0000000000000004L}); 8541 public static final BitSet FOLLOW_annotation_in_annotations3868 = new BitSet(new long[]{0x0000000000000008L,0x0000000200000000L}); 8542 public static final BitSet FOLLOW_I_ANNOTATION_in_annotation3897 = new BitSet(new long[]{0x0000000000000004L}); 8543 public static final BitSet FOLLOW_ANNOTATION_VISIBILITY_in_annotation3899 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0020000000000000L}); 8544 public static final BitSet FOLLOW_subannotation_in_annotation3901 = new BitSet(new long[]{0x0000000000000008L}); 8545 public static final BitSet FOLLOW_I_ANNOTATION_ELEMENT_in_annotation_element3922 = new BitSet(new long[]{0x0000000000000004L}); 8546 public static final BitSet FOLLOW_SIMPLE_NAME_in_annotation_element3924 = new BitSet(new long[]{0x0000008000819900L,0x4001F00040000000L,0x0820000000000000L,0x0000000000222102L}); 8547 public static final BitSet FOLLOW_literal_in_annotation_element3926 = new BitSet(new long[]{0x0000000000000008L}); 8548 public static final BitSet FOLLOW_I_SUBANNOTATION_in_subannotation3953 = new BitSet(new long[]{0x0000000000000004L}); 8549 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_subannotation3963 = new BitSet(new long[]{0x0000000000000008L,0x0000000800000000L}); 8550 public static final BitSet FOLLOW_annotation_element_in_subannotation3974 = new BitSet(new long[]{0x0000000000000008L,0x0000000800000000L}); 8551 public static final BitSet FOLLOW_I_ENCODED_FIELD_in_field_literal4013 = new BitSet(new long[]{0x0000000000000004L}); 8552 public static final BitSet FOLLOW_field_reference_in_field_literal4015 = new BitSet(new long[]{0x0000000000000008L}); 8553 public static final BitSet FOLLOW_I_ENCODED_METHOD_in_method_literal4036 = new BitSet(new long[]{0x0000000000000004L}); 8554 public static final BitSet FOLLOW_method_reference_in_method_literal4038 = new BitSet(new long[]{0x0000000000000008L}); 8555 public static final BitSet FOLLOW_I_ENCODED_ENUM_in_enum_literal4059 = new BitSet(new long[]{0x0000000000000004L}); 8556 public static final BitSet FOLLOW_field_reference_in_enum_literal4061 = new BitSet(new long[]{0x0000000000000008L}); 8557 } 8558