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