1// $ANTLR 3.5.2 smaliParser.g 2017-04-20 15:20:45 2 3package org.jf.smali; 4 5import org.jf.dexlib2.Format; 6import org.jf.dexlib2.Opcode; 7import org.jf.dexlib2.Opcodes; 8 9 10import org.antlr.runtime.*; 11import java.util.Stack; 12import java.util.List; 13import java.util.ArrayList; 14 15import org.antlr.runtime.tree.*; 16 17 18@SuppressWarnings("all") 19public class smaliParser extends Parser { 20 public static final String[] tokenNames = new String[] { 21 "<invalid>", "<EOR>", "<DOWN>", "<UP>", "ACCESS_SPEC", "ANNOTATION_DIRECTIVE", 22 "ANNOTATION_VISIBILITY", "ARRAY_DATA_DIRECTIVE", "ARRAY_TYPE_PREFIX", 23 "ARROW", "BOOL_LITERAL", "BYTE_LITERAL", "CATCHALL_DIRECTIVE", "CATCH_DIRECTIVE", 24 "CHAR_LITERAL", "CLASS_DESCRIPTOR", "CLASS_DIRECTIVE", "CLOSE_BRACE", 25 "CLOSE_PAREN", "COLON", "COMMA", "DOTDOT", "DOUBLE_LITERAL", "DOUBLE_LITERAL_OR_ID", 26 "END_ANNOTATION_DIRECTIVE", "END_ARRAY_DATA_DIRECTIVE", "END_FIELD_DIRECTIVE", 27 "END_LOCAL_DIRECTIVE", "END_METHOD_DIRECTIVE", "END_PACKED_SWITCH_DIRECTIVE", 28 "END_PARAMETER_DIRECTIVE", "END_SPARSE_SWITCH_DIRECTIVE", "END_SUBANNOTATION_DIRECTIVE", 29 "ENUM_DIRECTIVE", "EPILOGUE_DIRECTIVE", "EQUAL", "FIELD_DIRECTIVE", "FIELD_OFFSET", 30 "FLOAT_LITERAL", "FLOAT_LITERAL_OR_ID", "IMPLEMENTS_DIRECTIVE", "INLINE_INDEX", 31 "INSTRUCTION_FORMAT10t", "INSTRUCTION_FORMAT10x", "INSTRUCTION_FORMAT10x_ODEX", 32 "INSTRUCTION_FORMAT11n", "INSTRUCTION_FORMAT11x", "INSTRUCTION_FORMAT12x", 33 "INSTRUCTION_FORMAT12x_OR_ID", "INSTRUCTION_FORMAT20bc", "INSTRUCTION_FORMAT20t", 34 "INSTRUCTION_FORMAT21c_FIELD", "INSTRUCTION_FORMAT21c_FIELD_ODEX", "INSTRUCTION_FORMAT21c_STRING", 35 "INSTRUCTION_FORMAT21c_TYPE", "INSTRUCTION_FORMAT21ih", "INSTRUCTION_FORMAT21lh", 36 "INSTRUCTION_FORMAT21s", "INSTRUCTION_FORMAT21t", "INSTRUCTION_FORMAT22b", 37 "INSTRUCTION_FORMAT22c_FIELD", "INSTRUCTION_FORMAT22c_FIELD_ODEX", "INSTRUCTION_FORMAT22c_TYPE", 38 "INSTRUCTION_FORMAT22cs_FIELD", "INSTRUCTION_FORMAT22s", "INSTRUCTION_FORMAT22s_OR_ID", 39 "INSTRUCTION_FORMAT22t", "INSTRUCTION_FORMAT22x", "INSTRUCTION_FORMAT23x", 40 "INSTRUCTION_FORMAT30t", "INSTRUCTION_FORMAT31c", "INSTRUCTION_FORMAT31i", 41 "INSTRUCTION_FORMAT31i_OR_ID", "INSTRUCTION_FORMAT31t", "INSTRUCTION_FORMAT32x", 42 "INSTRUCTION_FORMAT35c_METHOD", "INSTRUCTION_FORMAT35c_METHOD_ODEX", "INSTRUCTION_FORMAT35c_TYPE", 43 "INSTRUCTION_FORMAT35mi_METHOD", "INSTRUCTION_FORMAT35ms_METHOD", "INSTRUCTION_FORMAT3rc_METHOD", 44 "INSTRUCTION_FORMAT3rc_METHOD_ODEX", "INSTRUCTION_FORMAT3rc_TYPE", "INSTRUCTION_FORMAT3rmi_METHOD", 45 "INSTRUCTION_FORMAT3rms_METHOD", "INSTRUCTION_FORMAT45cc_METHOD", "INSTRUCTION_FORMAT4rcc_METHOD", 46 "INSTRUCTION_FORMAT51l", "INTEGER_LITERAL", "INVALID_TOKEN", "I_ACCESS_LIST", 47 "I_ANNOTATION", "I_ANNOTATIONS", "I_ANNOTATION_ELEMENT", "I_ARRAY_ELEMENTS", 48 "I_ARRAY_ELEMENT_SIZE", "I_CATCH", "I_CATCHALL", "I_CATCHES", "I_CLASS_DEF", 49 "I_ENCODED_ARRAY", "I_ENCODED_ENUM", "I_ENCODED_FIELD", "I_ENCODED_METHOD", 50 "I_END_LOCAL", "I_EPILOGUE", "I_FIELD", "I_FIELDS", "I_FIELD_INITIAL_VALUE", 51 "I_FIELD_TYPE", "I_IMPLEMENTS", "I_LABEL", "I_LINE", "I_LOCAL", "I_LOCALS", 52 "I_METHOD", "I_METHODS", "I_METHOD_PROTOTYPE", "I_METHOD_RETURN_TYPE", 53 "I_ORDERED_METHOD_ITEMS", "I_PACKED_SWITCH_ELEMENTS", "I_PACKED_SWITCH_START_KEY", 54 "I_PARAMETER", "I_PARAMETERS", "I_PARAMETER_NOT_SPECIFIED", "I_PROLOGUE", 55 "I_REGISTERS", "I_REGISTER_LIST", "I_REGISTER_RANGE", "I_RESTART_LOCAL", 56 "I_SOURCE", "I_SPARSE_SWITCH_ELEMENTS", "I_STATEMENT_ARRAY_DATA", "I_STATEMENT_FORMAT10t", 57 "I_STATEMENT_FORMAT10x", "I_STATEMENT_FORMAT11n", "I_STATEMENT_FORMAT11x", 58 "I_STATEMENT_FORMAT12x", "I_STATEMENT_FORMAT20bc", "I_STATEMENT_FORMAT20t", 59 "I_STATEMENT_FORMAT21c_FIELD", "I_STATEMENT_FORMAT21c_STRING", "I_STATEMENT_FORMAT21c_TYPE", 60 "I_STATEMENT_FORMAT21ih", "I_STATEMENT_FORMAT21lh", "I_STATEMENT_FORMAT21s", 61 "I_STATEMENT_FORMAT21t", "I_STATEMENT_FORMAT22b", "I_STATEMENT_FORMAT22c_FIELD", 62 "I_STATEMENT_FORMAT22c_TYPE", "I_STATEMENT_FORMAT22s", "I_STATEMENT_FORMAT22t", 63 "I_STATEMENT_FORMAT22x", "I_STATEMENT_FORMAT23x", "I_STATEMENT_FORMAT30t", 64 "I_STATEMENT_FORMAT31c", "I_STATEMENT_FORMAT31i", "I_STATEMENT_FORMAT31t", 65 "I_STATEMENT_FORMAT32x", "I_STATEMENT_FORMAT35c_METHOD", "I_STATEMENT_FORMAT35c_TYPE", 66 "I_STATEMENT_FORMAT3rc_METHOD", "I_STATEMENT_FORMAT3rc_TYPE", "I_STATEMENT_FORMAT45cc_METHOD", 67 "I_STATEMENT_FORMAT4rcc_METHOD", "I_STATEMENT_FORMAT51l", "I_STATEMENT_PACKED_SWITCH", 68 "I_STATEMENT_SPARSE_SWITCH", "I_SUBANNOTATION", "I_SUPER", "LINE_COMMENT", 69 "LINE_DIRECTIVE", "LOCALS_DIRECTIVE", "LOCAL_DIRECTIVE", "LONG_LITERAL", 70 "MEMBER_NAME", "METHOD_DIRECTIVE", "NEGATIVE_INTEGER_LITERAL", "NULL_LITERAL", 71 "OPEN_BRACE", "OPEN_PAREN", "PACKED_SWITCH_DIRECTIVE", "PARAMETER_DIRECTIVE", 72 "PARAM_LIST_OR_ID_PRIMITIVE_TYPE", "POSITIVE_INTEGER_LITERAL", "PRIMITIVE_TYPE", 73 "PROLOGUE_DIRECTIVE", "REGISTER", "REGISTERS_DIRECTIVE", "RESTART_LOCAL_DIRECTIVE", 74 "SHORT_LITERAL", "SIMPLE_NAME", "SOURCE_DIRECTIVE", "SPARSE_SWITCH_DIRECTIVE", 75 "STRING_LITERAL", "SUBANNOTATION_DIRECTIVE", "SUPER_DIRECTIVE", "VERIFICATION_ERROR_TYPE", 76 "VOID_TYPE", "VTABLE_INDEX", "WHITE_SPACE" 77 }; 78 public static final int EOF=-1; 79 public static final int ACCESS_SPEC=4; 80 public static final int ANNOTATION_DIRECTIVE=5; 81 public static final int ANNOTATION_VISIBILITY=6; 82 public static final int ARRAY_DATA_DIRECTIVE=7; 83 public static final int ARRAY_TYPE_PREFIX=8; 84 public static final int ARROW=9; 85 public static final int BOOL_LITERAL=10; 86 public static final int BYTE_LITERAL=11; 87 public static final int CATCHALL_DIRECTIVE=12; 88 public static final int CATCH_DIRECTIVE=13; 89 public static final int CHAR_LITERAL=14; 90 public static final int CLASS_DESCRIPTOR=15; 91 public static final int CLASS_DIRECTIVE=16; 92 public static final int CLOSE_BRACE=17; 93 public static final int CLOSE_PAREN=18; 94 public static final int COLON=19; 95 public static final int COMMA=20; 96 public static final int DOTDOT=21; 97 public static final int DOUBLE_LITERAL=22; 98 public static final int DOUBLE_LITERAL_OR_ID=23; 99 public static final int END_ANNOTATION_DIRECTIVE=24; 100 public static final int END_ARRAY_DATA_DIRECTIVE=25; 101 public static final int END_FIELD_DIRECTIVE=26; 102 public static final int END_LOCAL_DIRECTIVE=27; 103 public static final int END_METHOD_DIRECTIVE=28; 104 public static final int END_PACKED_SWITCH_DIRECTIVE=29; 105 public static final int END_PARAMETER_DIRECTIVE=30; 106 public static final int END_SPARSE_SWITCH_DIRECTIVE=31; 107 public static final int END_SUBANNOTATION_DIRECTIVE=32; 108 public static final int ENUM_DIRECTIVE=33; 109 public static final int EPILOGUE_DIRECTIVE=34; 110 public static final int EQUAL=35; 111 public static final int FIELD_DIRECTIVE=36; 112 public static final int FIELD_OFFSET=37; 113 public static final int FLOAT_LITERAL=38; 114 public static final int FLOAT_LITERAL_OR_ID=39; 115 public static final int IMPLEMENTS_DIRECTIVE=40; 116 public static final int INLINE_INDEX=41; 117 public static final int INSTRUCTION_FORMAT10t=42; 118 public static final int INSTRUCTION_FORMAT10x=43; 119 public static final int INSTRUCTION_FORMAT10x_ODEX=44; 120 public static final int INSTRUCTION_FORMAT11n=45; 121 public static final int INSTRUCTION_FORMAT11x=46; 122 public static final int INSTRUCTION_FORMAT12x=47; 123 public static final int INSTRUCTION_FORMAT12x_OR_ID=48; 124 public static final int INSTRUCTION_FORMAT20bc=49; 125 public static final int INSTRUCTION_FORMAT20t=50; 126 public static final int INSTRUCTION_FORMAT21c_FIELD=51; 127 public static final int INSTRUCTION_FORMAT21c_FIELD_ODEX=52; 128 public static final int INSTRUCTION_FORMAT21c_STRING=53; 129 public static final int INSTRUCTION_FORMAT21c_TYPE=54; 130 public static final int INSTRUCTION_FORMAT21ih=55; 131 public static final int INSTRUCTION_FORMAT21lh=56; 132 public static final int INSTRUCTION_FORMAT21s=57; 133 public static final int INSTRUCTION_FORMAT21t=58; 134 public static final int INSTRUCTION_FORMAT22b=59; 135 public static final int INSTRUCTION_FORMAT22c_FIELD=60; 136 public static final int INSTRUCTION_FORMAT22c_FIELD_ODEX=61; 137 public static final int INSTRUCTION_FORMAT22c_TYPE=62; 138 public static final int INSTRUCTION_FORMAT22cs_FIELD=63; 139 public static final int INSTRUCTION_FORMAT22s=64; 140 public static final int INSTRUCTION_FORMAT22s_OR_ID=65; 141 public static final int INSTRUCTION_FORMAT22t=66; 142 public static final int INSTRUCTION_FORMAT22x=67; 143 public static final int INSTRUCTION_FORMAT23x=68; 144 public static final int INSTRUCTION_FORMAT30t=69; 145 public static final int INSTRUCTION_FORMAT31c=70; 146 public static final int INSTRUCTION_FORMAT31i=71; 147 public static final int INSTRUCTION_FORMAT31i_OR_ID=72; 148 public static final int INSTRUCTION_FORMAT31t=73; 149 public static final int INSTRUCTION_FORMAT32x=74; 150 public static final int INSTRUCTION_FORMAT35c_METHOD=75; 151 public static final int INSTRUCTION_FORMAT35c_METHOD_ODEX=76; 152 public static final int INSTRUCTION_FORMAT35c_TYPE=77; 153 public static final int INSTRUCTION_FORMAT35mi_METHOD=78; 154 public static final int INSTRUCTION_FORMAT35ms_METHOD=79; 155 public static final int INSTRUCTION_FORMAT3rc_METHOD=80; 156 public static final int INSTRUCTION_FORMAT3rc_METHOD_ODEX=81; 157 public static final int INSTRUCTION_FORMAT3rc_TYPE=82; 158 public static final int INSTRUCTION_FORMAT3rmi_METHOD=83; 159 public static final int INSTRUCTION_FORMAT3rms_METHOD=84; 160 public static final int INSTRUCTION_FORMAT45cc_METHOD=85; 161 public static final int INSTRUCTION_FORMAT4rcc_METHOD=86; 162 public static final int INSTRUCTION_FORMAT51l=87; 163 public static final int INTEGER_LITERAL=88; 164 public static final int INVALID_TOKEN=89; 165 public static final int I_ACCESS_LIST=90; 166 public static final int I_ANNOTATION=91; 167 public static final int I_ANNOTATIONS=92; 168 public static final int I_ANNOTATION_ELEMENT=93; 169 public static final int I_ARRAY_ELEMENTS=94; 170 public static final int I_ARRAY_ELEMENT_SIZE=95; 171 public static final int I_CATCH=96; 172 public static final int I_CATCHALL=97; 173 public static final int I_CATCHES=98; 174 public static final int I_CLASS_DEF=99; 175 public static final int I_ENCODED_ARRAY=100; 176 public static final int I_ENCODED_ENUM=101; 177 public static final int I_ENCODED_FIELD=102; 178 public static final int I_ENCODED_METHOD=103; 179 public static final int I_END_LOCAL=104; 180 public static final int I_EPILOGUE=105; 181 public static final int I_FIELD=106; 182 public static final int I_FIELDS=107; 183 public static final int I_FIELD_INITIAL_VALUE=108; 184 public static final int I_FIELD_TYPE=109; 185 public static final int I_IMPLEMENTS=110; 186 public static final int I_LABEL=111; 187 public static final int I_LINE=112; 188 public static final int I_LOCAL=113; 189 public static final int I_LOCALS=114; 190 public static final int I_METHOD=115; 191 public static final int I_METHODS=116; 192 public static final int I_METHOD_PROTOTYPE=117; 193 public static final int I_METHOD_RETURN_TYPE=118; 194 public static final int I_ORDERED_METHOD_ITEMS=119; 195 public static final int I_PACKED_SWITCH_ELEMENTS=120; 196 public static final int I_PACKED_SWITCH_START_KEY=121; 197 public static final int I_PARAMETER=122; 198 public static final int I_PARAMETERS=123; 199 public static final int I_PARAMETER_NOT_SPECIFIED=124; 200 public static final int I_PROLOGUE=125; 201 public static final int I_REGISTERS=126; 202 public static final int I_REGISTER_LIST=127; 203 public static final int I_REGISTER_RANGE=128; 204 public static final int I_RESTART_LOCAL=129; 205 public static final int I_SOURCE=130; 206 public static final int I_SPARSE_SWITCH_ELEMENTS=131; 207 public static final int I_STATEMENT_ARRAY_DATA=132; 208 public static final int I_STATEMENT_FORMAT10t=133; 209 public static final int I_STATEMENT_FORMAT10x=134; 210 public static final int I_STATEMENT_FORMAT11n=135; 211 public static final int I_STATEMENT_FORMAT11x=136; 212 public static final int I_STATEMENT_FORMAT12x=137; 213 public static final int I_STATEMENT_FORMAT20bc=138; 214 public static final int I_STATEMENT_FORMAT20t=139; 215 public static final int I_STATEMENT_FORMAT21c_FIELD=140; 216 public static final int I_STATEMENT_FORMAT21c_STRING=141; 217 public static final int I_STATEMENT_FORMAT21c_TYPE=142; 218 public static final int I_STATEMENT_FORMAT21ih=143; 219 public static final int I_STATEMENT_FORMAT21lh=144; 220 public static final int I_STATEMENT_FORMAT21s=145; 221 public static final int I_STATEMENT_FORMAT21t=146; 222 public static final int I_STATEMENT_FORMAT22b=147; 223 public static final int I_STATEMENT_FORMAT22c_FIELD=148; 224 public static final int I_STATEMENT_FORMAT22c_TYPE=149; 225 public static final int I_STATEMENT_FORMAT22s=150; 226 public static final int I_STATEMENT_FORMAT22t=151; 227 public static final int I_STATEMENT_FORMAT22x=152; 228 public static final int I_STATEMENT_FORMAT23x=153; 229 public static final int I_STATEMENT_FORMAT30t=154; 230 public static final int I_STATEMENT_FORMAT31c=155; 231 public static final int I_STATEMENT_FORMAT31i=156; 232 public static final int I_STATEMENT_FORMAT31t=157; 233 public static final int I_STATEMENT_FORMAT32x=158; 234 public static final int I_STATEMENT_FORMAT35c_METHOD=159; 235 public static final int I_STATEMENT_FORMAT35c_TYPE=160; 236 public static final int I_STATEMENT_FORMAT3rc_METHOD=161; 237 public static final int I_STATEMENT_FORMAT3rc_TYPE=162; 238 public static final int I_STATEMENT_FORMAT45cc_METHOD=163; 239 public static final int I_STATEMENT_FORMAT4rcc_METHOD=164; 240 public static final int I_STATEMENT_FORMAT51l=165; 241 public static final int I_STATEMENT_PACKED_SWITCH=166; 242 public static final int I_STATEMENT_SPARSE_SWITCH=167; 243 public static final int I_SUBANNOTATION=168; 244 public static final int I_SUPER=169; 245 public static final int LINE_COMMENT=170; 246 public static final int LINE_DIRECTIVE=171; 247 public static final int LOCALS_DIRECTIVE=172; 248 public static final int LOCAL_DIRECTIVE=173; 249 public static final int LONG_LITERAL=174; 250 public static final int MEMBER_NAME=175; 251 public static final int METHOD_DIRECTIVE=176; 252 public static final int NEGATIVE_INTEGER_LITERAL=177; 253 public static final int NULL_LITERAL=178; 254 public static final int OPEN_BRACE=179; 255 public static final int OPEN_PAREN=180; 256 public static final int PACKED_SWITCH_DIRECTIVE=181; 257 public static final int PARAMETER_DIRECTIVE=182; 258 public static final int PARAM_LIST_OR_ID_PRIMITIVE_TYPE=183; 259 public static final int POSITIVE_INTEGER_LITERAL=184; 260 public static final int PRIMITIVE_TYPE=185; 261 public static final int PROLOGUE_DIRECTIVE=186; 262 public static final int REGISTER=187; 263 public static final int REGISTERS_DIRECTIVE=188; 264 public static final int RESTART_LOCAL_DIRECTIVE=189; 265 public static final int SHORT_LITERAL=190; 266 public static final int SIMPLE_NAME=191; 267 public static final int SOURCE_DIRECTIVE=192; 268 public static final int SPARSE_SWITCH_DIRECTIVE=193; 269 public static final int STRING_LITERAL=194; 270 public static final int SUBANNOTATION_DIRECTIVE=195; 271 public static final int SUPER_DIRECTIVE=196; 272 public static final int VERIFICATION_ERROR_TYPE=197; 273 public static final int VOID_TYPE=198; 274 public static final int VTABLE_INDEX=199; 275 public static final int WHITE_SPACE=200; 276 277 // delegates 278 public Parser[] getDelegates() { 279 return new Parser[] {}; 280 } 281 282 // delegators 283 284 285 public smaliParser(TokenStream input) { 286 this(input, new RecognizerSharedState()); 287 } 288 public smaliParser(TokenStream input, RecognizerSharedState state) { 289 super(input, state); 290 } 291 292 protected TreeAdaptor adaptor = new CommonTreeAdaptor(); 293 294 public void setTreeAdaptor(TreeAdaptor adaptor) { 295 this.adaptor = adaptor; 296 } 297 public TreeAdaptor getTreeAdaptor() { 298 return adaptor; 299 } 300 @Override public String[] getTokenNames() { return smaliParser.tokenNames; } 301 @Override public String getGrammarFileName() { return "smaliParser.g"; } 302 303 304 public static final int ERROR_CHANNEL = 100; 305 306 private boolean verboseErrors = false; 307 private boolean allowOdex = false; 308 private int apiLevel = 15; 309 private Opcodes opcodes = Opcodes.forApi(apiLevel); 310 311 public void setVerboseErrors(boolean verboseErrors) { 312 this.verboseErrors = verboseErrors; 313 } 314 315 public void setAllowOdex(boolean allowOdex) { 316 this.allowOdex = allowOdex; 317 } 318 319 public void setApiLevel(int apiLevel) { 320 this.opcodes = Opcodes.forApi(apiLevel); 321 this.apiLevel = apiLevel; 322 } 323 324 public String getErrorMessage(RecognitionException e, 325 String[] tokenNames) { 326 327 if (verboseErrors) { 328 List stack = getRuleInvocationStack(e, this.getClass().getName()); 329 String msg = null; 330 331 if (e instanceof NoViableAltException) { 332 NoViableAltException nvae = (NoViableAltException)e; 333 msg = " no viable alt; token="+getTokenErrorDisplay(e.token)+ 334 " (decision="+nvae.decisionNumber+ 335 " state "+nvae.stateNumber+")"+ 336 " decision=<<"+nvae.grammarDecisionDescription+">>"; 337 } else { 338 msg = super.getErrorMessage(e, tokenNames); 339 } 340 341 return stack + " " + msg; 342 } else { 343 return super.getErrorMessage(e, tokenNames); 344 } 345 } 346 347 public String getTokenErrorDisplay(Token t) { 348 if (!verboseErrors) { 349 String s = t.getText(); 350 if ( s==null ) { 351 if ( t.getType()==Token.EOF ) { 352 s = "<EOF>"; 353 } 354 else { 355 s = "<"+tokenNames[t.getType()]+">"; 356 } 357 } 358 s = s.replaceAll("\n","\\\\n"); 359 s = s.replaceAll("\r","\\\\r"); 360 s = s.replaceAll("\t","\\\\t"); 361 return "'"+s+"'"; 362 } 363 364 CommonToken ct = (CommonToken)t; 365 366 String channelStr = ""; 367 if (t.getChannel()>0) { 368 channelStr=",channel="+t.getChannel(); 369 } 370 String txt = t.getText(); 371 if ( txt!=null ) { 372 txt = txt.replaceAll("\n","\\\\n"); 373 txt = txt.replaceAll("\r","\\\\r"); 374 txt = txt.replaceAll("\t","\\\\t"); 375 } 376 else { 377 txt = "<no text>"; 378 } 379 return "[@"+t.getTokenIndex()+","+ct.getStartIndex()+":"+ct.getStopIndex()+"='"+txt+"',<"+tokenNames[t.getType()]+">"+channelStr+","+t.getLine()+":"+t.getCharPositionInLine()+"]"; 380 } 381 382 public String getErrorHeader(RecognitionException e) { 383 return getSourceName()+"["+ e.line+","+e.charPositionInLine+"]"; 384 } 385 386 private CommonTree buildTree(int type, String text, List<CommonTree> children) { 387 CommonTree root = new CommonTree(new CommonToken(type, text)); 388 for (CommonTree child: children) { 389 root.addChild(child); 390 } 391 return root; 392 } 393 394 private CommonToken getParamListSubToken(CommonToken baseToken, String str, int typeStartIndex) { 395 CommonToken token = new CommonToken(baseToken); 396 token.setStartIndex(baseToken.getStartIndex() + typeStartIndex); 397 398 switch (str.charAt(typeStartIndex)) { 399 case 'Z': 400 case 'B': 401 case 'S': 402 case 'C': 403 case 'I': 404 case 'J': 405 case 'F': 406 case 'D': 407 { 408 token.setType(PRIMITIVE_TYPE); 409 token.setText(str.substring(typeStartIndex, typeStartIndex+1)); 410 token.setStopIndex(baseToken.getStartIndex() + typeStartIndex); 411 break; 412 } 413 case 'L': 414 { 415 int i = typeStartIndex; 416 while (str.charAt(++i) != ';'); 417 418 token.setType(CLASS_DESCRIPTOR); 419 token.setText(str.substring(typeStartIndex, i + 1)); 420 token.setStopIndex(baseToken.getStartIndex() + i); 421 break; 422 } 423 case '[': 424 { 425 int i = typeStartIndex; 426 while (str.charAt(++i) == '['); 427 428 token.setType(ARRAY_TYPE_PREFIX); 429 token.setText(str.substring(typeStartIndex, i)); 430 token.setStopIndex(baseToken.getStartIndex() + i - 1); 431 break; 432 } 433 default: 434 throw new RuntimeException(String.format("Invalid character '%c' in param list \"%s\" at position %d", str.charAt(typeStartIndex), str, typeStartIndex)); 435 } 436 437 return token; 438 } 439 440 private CommonTree parseParamList(CommonToken paramListToken) { 441 String paramList = paramListToken.getText(); 442 CommonTree root = new CommonTree(); 443 444 int startIndex = paramListToken.getStartIndex(); 445 446 int i=0; 447 while (i<paramList.length()) { 448 CommonToken token = getParamListSubToken(paramListToken, paramList, i); 449 root.addChild(new CommonTree(token)); 450 i += token.getText().length(); 451 } 452 453 if (root.getChildCount() == 0) { 454 return null; 455 } 456 return root; 457 } 458 459 private void throwOdexedInstructionException(IntStream input, String odexedInstruction) 460 throws OdexedInstructionException { 461 /*this has to be done in a separate method, otherwise java will complain about the 462 auto-generated code in the rule after the throw not being reachable*/ 463 throw new OdexedInstructionException(input, odexedInstruction); 464 } 465 466 467 protected static class smali_file_scope { 468 boolean hasClassSpec; 469 boolean hasSuperSpec; 470 boolean hasSourceSpec; 471 List<CommonTree> classAnnotations; 472 } 473 protected Stack<smali_file_scope> smali_file_stack = new Stack<smali_file_scope>(); 474 475 public static class smali_file_return extends ParserRuleReturnScope { 476 CommonTree tree; 477 @Override 478 public CommonTree getTree() { return tree; } 479 }; 480 481 482 // $ANTLR start "smali_file" 483 // smaliParser.g:415:1: smali_file : ({...}? => class_spec |{...}? => super_spec | implements_spec |{...}? => source_spec | method | field | annotation )+ EOF -> ^( I_CLASS_DEF class_spec ( super_spec )? ( implements_spec )* ( source_spec )? ^( I_METHODS ( method )* ) ^( I_FIELDS ( field )* ) ) ; 484 public final smaliParser.smali_file_return smali_file() throws RecognitionException { 485 smali_file_stack.push(new smali_file_scope()); 486 smaliParser.smali_file_return retval = new smaliParser.smali_file_return(); 487 retval.start = input.LT(1); 488 489 CommonTree root_0 = null; 490 491 Token EOF8=null; 492 ParserRuleReturnScope class_spec1 =null; 493 ParserRuleReturnScope super_spec2 =null; 494 ParserRuleReturnScope implements_spec3 =null; 495 ParserRuleReturnScope source_spec4 =null; 496 ParserRuleReturnScope method5 =null; 497 ParserRuleReturnScope field6 =null; 498 ParserRuleReturnScope annotation7 =null; 499 500 CommonTree EOF8_tree=null; 501 RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF"); 502 RewriteRuleSubtreeStream stream_class_spec=new RewriteRuleSubtreeStream(adaptor,"rule class_spec"); 503 RewriteRuleSubtreeStream stream_annotation=new RewriteRuleSubtreeStream(adaptor,"rule annotation"); 504 RewriteRuleSubtreeStream stream_method=new RewriteRuleSubtreeStream(adaptor,"rule method"); 505 RewriteRuleSubtreeStream stream_field=new RewriteRuleSubtreeStream(adaptor,"rule field"); 506 RewriteRuleSubtreeStream stream_super_spec=new RewriteRuleSubtreeStream(adaptor,"rule super_spec"); 507 RewriteRuleSubtreeStream stream_implements_spec=new RewriteRuleSubtreeStream(adaptor,"rule implements_spec"); 508 RewriteRuleSubtreeStream stream_source_spec=new RewriteRuleSubtreeStream(adaptor,"rule source_spec"); 509 510 smali_file_stack.peek().hasClassSpec = smali_file_stack.peek().hasSuperSpec = smali_file_stack.peek().hasSourceSpec = false; 511 smali_file_stack.peek().classAnnotations = new ArrayList<CommonTree>(); 512 513 try { 514 // smaliParser.g:427:3: ( ({...}? => class_spec |{...}? => super_spec | implements_spec |{...}? => source_spec | method | field | annotation )+ EOF -> ^( I_CLASS_DEF class_spec ( super_spec )? ( implements_spec )* ( source_spec )? ^( I_METHODS ( method )* ) ^( I_FIELDS ( field )* ) ) ) 515 // smaliParser.g:428:3: ({...}? => class_spec |{...}? => super_spec | implements_spec |{...}? => source_spec | method | field | annotation )+ EOF 516 { 517 // smaliParser.g:428:3: ({...}? => class_spec |{...}? => super_spec | implements_spec |{...}? => source_spec | method | field | annotation )+ 518 int cnt1=0; 519 loop1: 520 while (true) { 521 int alt1=8; 522 int LA1_0 = input.LA(1); 523 if ( (LA1_0==CLASS_DIRECTIVE) && ((!smali_file_stack.peek().hasClassSpec))) { 524 alt1=1; 525 } 526 else if ( (LA1_0==SUPER_DIRECTIVE) && ((!smali_file_stack.peek().hasSuperSpec))) { 527 alt1=2; 528 } 529 else if ( (LA1_0==IMPLEMENTS_DIRECTIVE) ) { 530 alt1=3; 531 } 532 else if ( (LA1_0==SOURCE_DIRECTIVE) && ((!smali_file_stack.peek().hasSourceSpec))) { 533 alt1=4; 534 } 535 else if ( (LA1_0==METHOD_DIRECTIVE) ) { 536 alt1=5; 537 } 538 else if ( (LA1_0==FIELD_DIRECTIVE) ) { 539 alt1=6; 540 } 541 else if ( (LA1_0==ANNOTATION_DIRECTIVE) ) { 542 alt1=7; 543 } 544 545 switch (alt1) { 546 case 1 : 547 // smaliParser.g:428:5: {...}? => class_spec 548 { 549 if ( !((!smali_file_stack.peek().hasClassSpec)) ) { 550 throw new FailedPredicateException(input, "smali_file", "!$smali_file::hasClassSpec"); 551 } 552 pushFollow(FOLLOW_class_spec_in_smali_file1075); 553 class_spec1=class_spec(); 554 state._fsp--; 555 556 stream_class_spec.add(class_spec1.getTree()); 557 smali_file_stack.peek().hasClassSpec = true; 558 } 559 break; 560 case 2 : 561 // smaliParser.g:429:5: {...}? => super_spec 562 { 563 if ( !((!smali_file_stack.peek().hasSuperSpec)) ) { 564 throw new FailedPredicateException(input, "smali_file", "!$smali_file::hasSuperSpec"); 565 } 566 pushFollow(FOLLOW_super_spec_in_smali_file1086); 567 super_spec2=super_spec(); 568 state._fsp--; 569 570 stream_super_spec.add(super_spec2.getTree()); 571 smali_file_stack.peek().hasSuperSpec = true; 572 } 573 break; 574 case 3 : 575 // smaliParser.g:430:5: implements_spec 576 { 577 pushFollow(FOLLOW_implements_spec_in_smali_file1094); 578 implements_spec3=implements_spec(); 579 state._fsp--; 580 581 stream_implements_spec.add(implements_spec3.getTree()); 582 } 583 break; 584 case 4 : 585 // smaliParser.g:431:5: {...}? => source_spec 586 { 587 if ( !((!smali_file_stack.peek().hasSourceSpec)) ) { 588 throw new FailedPredicateException(input, "smali_file", "!$smali_file::hasSourceSpec"); 589 } 590 pushFollow(FOLLOW_source_spec_in_smali_file1103); 591 source_spec4=source_spec(); 592 state._fsp--; 593 594 stream_source_spec.add(source_spec4.getTree()); 595 smali_file_stack.peek().hasSourceSpec = true; 596 } 597 break; 598 case 5 : 599 // smaliParser.g:432:5: method 600 { 601 pushFollow(FOLLOW_method_in_smali_file1111); 602 method5=method(); 603 state._fsp--; 604 605 stream_method.add(method5.getTree()); 606 } 607 break; 608 case 6 : 609 // smaliParser.g:433:5: field 610 { 611 pushFollow(FOLLOW_field_in_smali_file1117); 612 field6=field(); 613 state._fsp--; 614 615 stream_field.add(field6.getTree()); 616 } 617 break; 618 case 7 : 619 // smaliParser.g:434:5: annotation 620 { 621 pushFollow(FOLLOW_annotation_in_smali_file1123); 622 annotation7=annotation(); 623 state._fsp--; 624 625 stream_annotation.add(annotation7.getTree()); 626 smali_file_stack.peek().classAnnotations.add((annotation7!=null?((CommonTree)annotation7.getTree()):null)); 627 } 628 break; 629 630 default : 631 if ( cnt1 >= 1 ) break loop1; 632 EarlyExitException eee = new EarlyExitException(1, input); 633 throw eee; 634 } 635 cnt1++; 636 } 637 638 EOF8=(Token)match(input,EOF,FOLLOW_EOF_in_smali_file1134); 639 stream_EOF.add(EOF8); 640 641 642 if (!smali_file_stack.peek().hasClassSpec) { 643 throw new SemanticException(input, "The file must contain a .class directive"); 644 } 645 646 if (!smali_file_stack.peek().hasSuperSpec) { 647 if (!(class_spec1!=null?((smaliParser.class_spec_return)class_spec1).className:null).equals("Ljava/lang/Object;")) { 648 throw new SemanticException(input, "The file must contain a .super directive"); 649 } 650 } 651 652 // AST REWRITE 653 // elements: super_spec, method, field, implements_spec, class_spec, source_spec 654 // token labels: 655 // rule labels: retval 656 // token list labels: 657 // rule list labels: 658 // wildcard labels: 659 retval.tree = root_0; 660 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 661 662 root_0 = (CommonTree)adaptor.nil(); 663 // 448:3: -> ^( I_CLASS_DEF class_spec ( super_spec )? ( implements_spec )* ( source_spec )? ^( I_METHODS ( method )* ) ^( I_FIELDS ( field )* ) ) 664 { 665 // smaliParser.g:448:6: ^( I_CLASS_DEF class_spec ( super_spec )? ( implements_spec )* ( source_spec )? ^( I_METHODS ( method )* ) ^( I_FIELDS ( field )* ) ) 666 { 667 CommonTree root_1 = (CommonTree)adaptor.nil(); 668 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_CLASS_DEF, "I_CLASS_DEF"), root_1); 669 adaptor.addChild(root_1, stream_class_spec.nextTree()); 670 // smaliParser.g:450:8: ( super_spec )? 671 if ( stream_super_spec.hasNext() ) { 672 adaptor.addChild(root_1, stream_super_spec.nextTree()); 673 } 674 stream_super_spec.reset(); 675 676 // smaliParser.g:451:8: ( implements_spec )* 677 while ( stream_implements_spec.hasNext() ) { 678 adaptor.addChild(root_1, stream_implements_spec.nextTree()); 679 } 680 stream_implements_spec.reset(); 681 682 // smaliParser.g:452:8: ( source_spec )? 683 if ( stream_source_spec.hasNext() ) { 684 adaptor.addChild(root_1, stream_source_spec.nextTree()); 685 } 686 stream_source_spec.reset(); 687 688 // smaliParser.g:453:8: ^( I_METHODS ( method )* ) 689 { 690 CommonTree root_2 = (CommonTree)adaptor.nil(); 691 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_METHODS, "I_METHODS"), root_2); 692 // smaliParser.g:453:20: ( method )* 693 while ( stream_method.hasNext() ) { 694 adaptor.addChild(root_2, stream_method.nextTree()); 695 } 696 stream_method.reset(); 697 698 adaptor.addChild(root_1, root_2); 699 } 700 701 // smaliParser.g:453:29: ^( I_FIELDS ( field )* ) 702 { 703 CommonTree root_2 = (CommonTree)adaptor.nil(); 704 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELDS, "I_FIELDS"), root_2); 705 // smaliParser.g:453:40: ( field )* 706 while ( stream_field.hasNext() ) { 707 adaptor.addChild(root_2, stream_field.nextTree()); 708 } 709 stream_field.reset(); 710 711 adaptor.addChild(root_1, root_2); 712 } 713 714 adaptor.addChild(root_1, buildTree(I_ANNOTATIONS, "I_ANNOTATIONS", smali_file_stack.peek().classAnnotations)); 715 adaptor.addChild(root_0, root_1); 716 } 717 718 } 719 720 721 retval.tree = root_0; 722 723 } 724 725 retval.stop = input.LT(-1); 726 727 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 728 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 729 730 } 731 catch (RecognitionException re) { 732 reportError(re); 733 recover(input,re); 734 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 735 } 736 finally { 737 // do for sure before leaving 738 smali_file_stack.pop(); 739 } 740 return retval; 741 } 742 // $ANTLR end "smali_file" 743 744 745 public static class class_spec_return extends ParserRuleReturnScope { 746 public String className; 747 CommonTree tree; 748 @Override 749 public CommonTree getTree() { return tree; } 750 }; 751 752 753 // $ANTLR start "class_spec" 754 // smaliParser.g:455:1: class_spec returns [String className] : CLASS_DIRECTIVE access_list CLASS_DESCRIPTOR -> CLASS_DESCRIPTOR access_list ; 755 public final smaliParser.class_spec_return class_spec() throws RecognitionException { 756 smaliParser.class_spec_return retval = new smaliParser.class_spec_return(); 757 retval.start = input.LT(1); 758 759 CommonTree root_0 = null; 760 761 Token CLASS_DIRECTIVE9=null; 762 Token CLASS_DESCRIPTOR11=null; 763 ParserRuleReturnScope access_list10 =null; 764 765 CommonTree CLASS_DIRECTIVE9_tree=null; 766 CommonTree CLASS_DESCRIPTOR11_tree=null; 767 RewriteRuleTokenStream stream_CLASS_DESCRIPTOR=new RewriteRuleTokenStream(adaptor,"token CLASS_DESCRIPTOR"); 768 RewriteRuleTokenStream stream_CLASS_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token CLASS_DIRECTIVE"); 769 RewriteRuleSubtreeStream stream_access_list=new RewriteRuleSubtreeStream(adaptor,"rule access_list"); 770 771 try { 772 // smaliParser.g:456:3: ( CLASS_DIRECTIVE access_list CLASS_DESCRIPTOR -> CLASS_DESCRIPTOR access_list ) 773 // smaliParser.g:456:5: CLASS_DIRECTIVE access_list CLASS_DESCRIPTOR 774 { 775 CLASS_DIRECTIVE9=(Token)match(input,CLASS_DIRECTIVE,FOLLOW_CLASS_DIRECTIVE_in_class_spec1221); 776 stream_CLASS_DIRECTIVE.add(CLASS_DIRECTIVE9); 777 778 pushFollow(FOLLOW_access_list_in_class_spec1223); 779 access_list10=access_list(); 780 state._fsp--; 781 782 stream_access_list.add(access_list10.getTree()); 783 CLASS_DESCRIPTOR11=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_class_spec1225); 784 stream_CLASS_DESCRIPTOR.add(CLASS_DESCRIPTOR11); 785 786 retval.className = (CLASS_DESCRIPTOR11!=null?CLASS_DESCRIPTOR11.getText():null); 787 // AST REWRITE 788 // elements: access_list, CLASS_DESCRIPTOR 789 // token labels: 790 // rule labels: retval 791 // token list labels: 792 // rule list labels: 793 // wildcard labels: 794 retval.tree = root_0; 795 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 796 797 root_0 = (CommonTree)adaptor.nil(); 798 // 456:89: -> CLASS_DESCRIPTOR access_list 799 { 800 adaptor.addChild(root_0, stream_CLASS_DESCRIPTOR.nextNode()); 801 adaptor.addChild(root_0, stream_access_list.nextTree()); 802 } 803 804 805 retval.tree = root_0; 806 807 } 808 809 retval.stop = input.LT(-1); 810 811 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 812 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 813 814 } 815 catch (RecognitionException re) { 816 reportError(re); 817 recover(input,re); 818 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 819 } 820 finally { 821 // do for sure before leaving 822 } 823 return retval; 824 } 825 // $ANTLR end "class_spec" 826 827 828 public static class super_spec_return extends ParserRuleReturnScope { 829 CommonTree tree; 830 @Override 831 public CommonTree getTree() { return tree; } 832 }; 833 834 835 // $ANTLR start "super_spec" 836 // smaliParser.g:458:1: super_spec : SUPER_DIRECTIVE CLASS_DESCRIPTOR -> ^( I_SUPER[$start, \"I_SUPER\"] CLASS_DESCRIPTOR ) ; 837 public final smaliParser.super_spec_return super_spec() throws RecognitionException { 838 smaliParser.super_spec_return retval = new smaliParser.super_spec_return(); 839 retval.start = input.LT(1); 840 841 CommonTree root_0 = null; 842 843 Token SUPER_DIRECTIVE12=null; 844 Token CLASS_DESCRIPTOR13=null; 845 846 CommonTree SUPER_DIRECTIVE12_tree=null; 847 CommonTree CLASS_DESCRIPTOR13_tree=null; 848 RewriteRuleTokenStream stream_CLASS_DESCRIPTOR=new RewriteRuleTokenStream(adaptor,"token CLASS_DESCRIPTOR"); 849 RewriteRuleTokenStream stream_SUPER_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token SUPER_DIRECTIVE"); 850 851 try { 852 // smaliParser.g:459:3: ( SUPER_DIRECTIVE CLASS_DESCRIPTOR -> ^( I_SUPER[$start, \"I_SUPER\"] CLASS_DESCRIPTOR ) ) 853 // smaliParser.g:459:5: SUPER_DIRECTIVE CLASS_DESCRIPTOR 854 { 855 SUPER_DIRECTIVE12=(Token)match(input,SUPER_DIRECTIVE,FOLLOW_SUPER_DIRECTIVE_in_super_spec1243); 856 stream_SUPER_DIRECTIVE.add(SUPER_DIRECTIVE12); 857 858 CLASS_DESCRIPTOR13=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_super_spec1245); 859 stream_CLASS_DESCRIPTOR.add(CLASS_DESCRIPTOR13); 860 861 // AST REWRITE 862 // elements: CLASS_DESCRIPTOR 863 // token labels: 864 // rule labels: retval 865 // token list labels: 866 // rule list labels: 867 // wildcard labels: 868 retval.tree = root_0; 869 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 870 871 root_0 = (CommonTree)adaptor.nil(); 872 // 459:38: -> ^( I_SUPER[$start, \"I_SUPER\"] CLASS_DESCRIPTOR ) 873 { 874 // smaliParser.g:459:41: ^( I_SUPER[$start, \"I_SUPER\"] CLASS_DESCRIPTOR ) 875 { 876 CommonTree root_1 = (CommonTree)adaptor.nil(); 877 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_SUPER, (retval.start), "I_SUPER"), root_1); 878 adaptor.addChild(root_1, stream_CLASS_DESCRIPTOR.nextNode()); 879 adaptor.addChild(root_0, root_1); 880 } 881 882 } 883 884 885 retval.tree = root_0; 886 887 } 888 889 retval.stop = input.LT(-1); 890 891 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 892 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 893 894 } 895 catch (RecognitionException re) { 896 reportError(re); 897 recover(input,re); 898 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 899 } 900 finally { 901 // do for sure before leaving 902 } 903 return retval; 904 } 905 // $ANTLR end "super_spec" 906 907 908 public static class implements_spec_return extends ParserRuleReturnScope { 909 CommonTree tree; 910 @Override 911 public CommonTree getTree() { return tree; } 912 }; 913 914 915 // $ANTLR start "implements_spec" 916 // smaliParser.g:461:1: implements_spec : IMPLEMENTS_DIRECTIVE CLASS_DESCRIPTOR -> ^( I_IMPLEMENTS[$start, \"I_IMPLEMENTS\"] CLASS_DESCRIPTOR ) ; 917 public final smaliParser.implements_spec_return implements_spec() throws RecognitionException { 918 smaliParser.implements_spec_return retval = new smaliParser.implements_spec_return(); 919 retval.start = input.LT(1); 920 921 CommonTree root_0 = null; 922 923 Token IMPLEMENTS_DIRECTIVE14=null; 924 Token CLASS_DESCRIPTOR15=null; 925 926 CommonTree IMPLEMENTS_DIRECTIVE14_tree=null; 927 CommonTree CLASS_DESCRIPTOR15_tree=null; 928 RewriteRuleTokenStream stream_IMPLEMENTS_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token IMPLEMENTS_DIRECTIVE"); 929 RewriteRuleTokenStream stream_CLASS_DESCRIPTOR=new RewriteRuleTokenStream(adaptor,"token CLASS_DESCRIPTOR"); 930 931 try { 932 // smaliParser.g:462:3: ( IMPLEMENTS_DIRECTIVE CLASS_DESCRIPTOR -> ^( I_IMPLEMENTS[$start, \"I_IMPLEMENTS\"] CLASS_DESCRIPTOR ) ) 933 // smaliParser.g:462:5: IMPLEMENTS_DIRECTIVE CLASS_DESCRIPTOR 934 { 935 IMPLEMENTS_DIRECTIVE14=(Token)match(input,IMPLEMENTS_DIRECTIVE,FOLLOW_IMPLEMENTS_DIRECTIVE_in_implements_spec1264); 936 stream_IMPLEMENTS_DIRECTIVE.add(IMPLEMENTS_DIRECTIVE14); 937 938 CLASS_DESCRIPTOR15=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_implements_spec1266); 939 stream_CLASS_DESCRIPTOR.add(CLASS_DESCRIPTOR15); 940 941 // AST REWRITE 942 // elements: CLASS_DESCRIPTOR 943 // token labels: 944 // rule labels: retval 945 // token list labels: 946 // rule list labels: 947 // wildcard labels: 948 retval.tree = root_0; 949 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 950 951 root_0 = (CommonTree)adaptor.nil(); 952 // 462:43: -> ^( I_IMPLEMENTS[$start, \"I_IMPLEMENTS\"] CLASS_DESCRIPTOR ) 953 { 954 // smaliParser.g:462:46: ^( I_IMPLEMENTS[$start, \"I_IMPLEMENTS\"] CLASS_DESCRIPTOR ) 955 { 956 CommonTree root_1 = (CommonTree)adaptor.nil(); 957 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_IMPLEMENTS, (retval.start), "I_IMPLEMENTS"), root_1); 958 adaptor.addChild(root_1, stream_CLASS_DESCRIPTOR.nextNode()); 959 adaptor.addChild(root_0, root_1); 960 } 961 962 } 963 964 965 retval.tree = root_0; 966 967 } 968 969 retval.stop = input.LT(-1); 970 971 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 972 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 973 974 } 975 catch (RecognitionException re) { 976 reportError(re); 977 recover(input,re); 978 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 979 } 980 finally { 981 // do for sure before leaving 982 } 983 return retval; 984 } 985 // $ANTLR end "implements_spec" 986 987 988 public static class source_spec_return extends ParserRuleReturnScope { 989 CommonTree tree; 990 @Override 991 public CommonTree getTree() { return tree; } 992 }; 993 994 995 // $ANTLR start "source_spec" 996 // smaliParser.g:464:1: source_spec : SOURCE_DIRECTIVE STRING_LITERAL -> ^( I_SOURCE[$start, \"I_SOURCE\"] STRING_LITERAL ) ; 997 public final smaliParser.source_spec_return source_spec() throws RecognitionException { 998 smaliParser.source_spec_return retval = new smaliParser.source_spec_return(); 999 retval.start = input.LT(1); 1000 1001 CommonTree root_0 = null; 1002 1003 Token SOURCE_DIRECTIVE16=null; 1004 Token STRING_LITERAL17=null; 1005 1006 CommonTree SOURCE_DIRECTIVE16_tree=null; 1007 CommonTree STRING_LITERAL17_tree=null; 1008 RewriteRuleTokenStream stream_SOURCE_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token SOURCE_DIRECTIVE"); 1009 RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL"); 1010 1011 try { 1012 // smaliParser.g:465:3: ( SOURCE_DIRECTIVE STRING_LITERAL -> ^( I_SOURCE[$start, \"I_SOURCE\"] STRING_LITERAL ) ) 1013 // smaliParser.g:465:5: SOURCE_DIRECTIVE STRING_LITERAL 1014 { 1015 SOURCE_DIRECTIVE16=(Token)match(input,SOURCE_DIRECTIVE,FOLLOW_SOURCE_DIRECTIVE_in_source_spec1285); 1016 stream_SOURCE_DIRECTIVE.add(SOURCE_DIRECTIVE16); 1017 1018 STRING_LITERAL17=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_source_spec1287); 1019 stream_STRING_LITERAL.add(STRING_LITERAL17); 1020 1021 // AST REWRITE 1022 // elements: STRING_LITERAL 1023 // token labels: 1024 // rule labels: retval 1025 // token list labels: 1026 // rule list labels: 1027 // wildcard labels: 1028 retval.tree = root_0; 1029 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 1030 1031 root_0 = (CommonTree)adaptor.nil(); 1032 // 465:37: -> ^( I_SOURCE[$start, \"I_SOURCE\"] STRING_LITERAL ) 1033 { 1034 // smaliParser.g:465:40: ^( I_SOURCE[$start, \"I_SOURCE\"] STRING_LITERAL ) 1035 { 1036 CommonTree root_1 = (CommonTree)adaptor.nil(); 1037 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_SOURCE, (retval.start), "I_SOURCE"), root_1); 1038 adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode()); 1039 adaptor.addChild(root_0, root_1); 1040 } 1041 1042 } 1043 1044 1045 retval.tree = root_0; 1046 1047 } 1048 1049 retval.stop = input.LT(-1); 1050 1051 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 1052 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 1053 1054 } 1055 catch (RecognitionException re) { 1056 reportError(re); 1057 recover(input,re); 1058 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 1059 } 1060 finally { 1061 // do for sure before leaving 1062 } 1063 return retval; 1064 } 1065 // $ANTLR end "source_spec" 1066 1067 1068 public static class access_list_return extends ParserRuleReturnScope { 1069 CommonTree tree; 1070 @Override 1071 public CommonTree getTree() { return tree; } 1072 }; 1073 1074 1075 // $ANTLR start "access_list" 1076 // smaliParser.g:467:1: access_list : ( ACCESS_SPEC )* -> ^( I_ACCESS_LIST[$start,\"I_ACCESS_LIST\"] ( ACCESS_SPEC )* ) ; 1077 public final smaliParser.access_list_return access_list() throws RecognitionException { 1078 smaliParser.access_list_return retval = new smaliParser.access_list_return(); 1079 retval.start = input.LT(1); 1080 1081 CommonTree root_0 = null; 1082 1083 Token ACCESS_SPEC18=null; 1084 1085 CommonTree ACCESS_SPEC18_tree=null; 1086 RewriteRuleTokenStream stream_ACCESS_SPEC=new RewriteRuleTokenStream(adaptor,"token ACCESS_SPEC"); 1087 1088 try { 1089 // smaliParser.g:468:3: ( ( ACCESS_SPEC )* -> ^( I_ACCESS_LIST[$start,\"I_ACCESS_LIST\"] ( ACCESS_SPEC )* ) ) 1090 // smaliParser.g:468:5: ( ACCESS_SPEC )* 1091 { 1092 // smaliParser.g:468:5: ( ACCESS_SPEC )* 1093 loop2: 1094 while (true) { 1095 int alt2=2; 1096 int LA2_0 = input.LA(1); 1097 if ( (LA2_0==ACCESS_SPEC) ) { 1098 int LA2_2 = input.LA(2); 1099 if ( (LA2_2==ACCESS_SPEC||LA2_2==ANNOTATION_VISIBILITY||LA2_2==BOOL_LITERAL||LA2_2==CLASS_DESCRIPTOR||LA2_2==DOUBLE_LITERAL_OR_ID||LA2_2==FLOAT_LITERAL_OR_ID||(LA2_2 >= INSTRUCTION_FORMAT10t && LA2_2 <= INSTRUCTION_FORMAT10x_ODEX)||LA2_2==INSTRUCTION_FORMAT11x||LA2_2==INSTRUCTION_FORMAT12x_OR_ID||(LA2_2 >= INSTRUCTION_FORMAT21c_FIELD && LA2_2 <= INSTRUCTION_FORMAT21c_TYPE)||LA2_2==INSTRUCTION_FORMAT21t||(LA2_2 >= INSTRUCTION_FORMAT22c_FIELD && LA2_2 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA2_2 >= INSTRUCTION_FORMAT22s_OR_ID && LA2_2 <= INSTRUCTION_FORMAT22t)||LA2_2==INSTRUCTION_FORMAT23x||(LA2_2 >= INSTRUCTION_FORMAT31i_OR_ID && LA2_2 <= INSTRUCTION_FORMAT31t)||(LA2_2 >= INSTRUCTION_FORMAT35c_METHOD && LA2_2 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA2_2 >= INSTRUCTION_FORMAT45cc_METHOD && LA2_2 <= INSTRUCTION_FORMAT51l)||LA2_2==MEMBER_NAME||(LA2_2 >= NEGATIVE_INTEGER_LITERAL && LA2_2 <= NULL_LITERAL)||(LA2_2 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA2_2 <= PRIMITIVE_TYPE)||LA2_2==REGISTER||LA2_2==SIMPLE_NAME||(LA2_2 >= VERIFICATION_ERROR_TYPE && LA2_2 <= VOID_TYPE)) ) { 1100 alt2=1; 1101 } 1102 1103 } 1104 1105 switch (alt2) { 1106 case 1 : 1107 // smaliParser.g:468:5: ACCESS_SPEC 1108 { 1109 ACCESS_SPEC18=(Token)match(input,ACCESS_SPEC,FOLLOW_ACCESS_SPEC_in_access_list1306); 1110 stream_ACCESS_SPEC.add(ACCESS_SPEC18); 1111 1112 } 1113 break; 1114 1115 default : 1116 break loop2; 1117 } 1118 } 1119 1120 // AST REWRITE 1121 // elements: ACCESS_SPEC 1122 // token labels: 1123 // rule labels: retval 1124 // token list labels: 1125 // rule list labels: 1126 // wildcard labels: 1127 retval.tree = root_0; 1128 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 1129 1130 root_0 = (CommonTree)adaptor.nil(); 1131 // 468:18: -> ^( I_ACCESS_LIST[$start,\"I_ACCESS_LIST\"] ( ACCESS_SPEC )* ) 1132 { 1133 // smaliParser.g:468:21: ^( I_ACCESS_LIST[$start,\"I_ACCESS_LIST\"] ( ACCESS_SPEC )* ) 1134 { 1135 CommonTree root_1 = (CommonTree)adaptor.nil(); 1136 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ACCESS_LIST, (retval.start), "I_ACCESS_LIST"), root_1); 1137 // smaliParser.g:468:61: ( ACCESS_SPEC )* 1138 while ( stream_ACCESS_SPEC.hasNext() ) { 1139 adaptor.addChild(root_1, stream_ACCESS_SPEC.nextNode()); 1140 } 1141 stream_ACCESS_SPEC.reset(); 1142 1143 adaptor.addChild(root_0, root_1); 1144 } 1145 1146 } 1147 1148 1149 retval.tree = root_0; 1150 1151 } 1152 1153 retval.stop = input.LT(-1); 1154 1155 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 1156 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 1157 1158 } 1159 catch (RecognitionException re) { 1160 reportError(re); 1161 recover(input,re); 1162 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 1163 } 1164 finally { 1165 // do for sure before leaving 1166 } 1167 return retval; 1168 } 1169 // $ANTLR end "access_list" 1170 1171 1172 public static class field_return extends ParserRuleReturnScope { 1173 CommonTree tree; 1174 @Override 1175 public CommonTree getTree() { return tree; } 1176 }; 1177 1178 1179 // $ANTLR start "field" 1180 // smaliParser.g:475:1: field : FIELD_DIRECTIVE access_list member_name COLON nonvoid_type_descriptor ( EQUAL literal )? ( ({...}? annotation )* ( END_FIELD_DIRECTIVE -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ( annotation )* ) ) | -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ) ) ) ) ; 1181 public final smaliParser.field_return field() throws RecognitionException { 1182 smaliParser.field_return retval = new smaliParser.field_return(); 1183 retval.start = input.LT(1); 1184 1185 CommonTree root_0 = null; 1186 1187 Token FIELD_DIRECTIVE19=null; 1188 Token COLON22=null; 1189 Token EQUAL24=null; 1190 Token END_FIELD_DIRECTIVE27=null; 1191 ParserRuleReturnScope access_list20 =null; 1192 ParserRuleReturnScope member_name21 =null; 1193 ParserRuleReturnScope nonvoid_type_descriptor23 =null; 1194 ParserRuleReturnScope literal25 =null; 1195 ParserRuleReturnScope annotation26 =null; 1196 1197 CommonTree FIELD_DIRECTIVE19_tree=null; 1198 CommonTree COLON22_tree=null; 1199 CommonTree EQUAL24_tree=null; 1200 CommonTree END_FIELD_DIRECTIVE27_tree=null; 1201 RewriteRuleTokenStream stream_END_FIELD_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_FIELD_DIRECTIVE"); 1202 RewriteRuleTokenStream stream_EQUAL=new RewriteRuleTokenStream(adaptor,"token EQUAL"); 1203 RewriteRuleTokenStream stream_FIELD_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token FIELD_DIRECTIVE"); 1204 RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON"); 1205 RewriteRuleSubtreeStream stream_annotation=new RewriteRuleSubtreeStream(adaptor,"rule annotation"); 1206 RewriteRuleSubtreeStream stream_access_list=new RewriteRuleSubtreeStream(adaptor,"rule access_list"); 1207 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 1208 RewriteRuleSubtreeStream stream_member_name=new RewriteRuleSubtreeStream(adaptor,"rule member_name"); 1209 RewriteRuleSubtreeStream stream_literal=new RewriteRuleSubtreeStream(adaptor,"rule literal"); 1210 1211 List<CommonTree> annotations = new ArrayList<CommonTree>(); 1212 try { 1213 // smaliParser.g:477:3: ( FIELD_DIRECTIVE access_list member_name COLON nonvoid_type_descriptor ( EQUAL literal )? ( ({...}? annotation )* ( END_FIELD_DIRECTIVE -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ( annotation )* ) ) | -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ) ) ) ) ) 1214 // smaliParser.g:477:5: FIELD_DIRECTIVE access_list member_name COLON nonvoid_type_descriptor ( EQUAL literal )? ( ({...}? annotation )* ( END_FIELD_DIRECTIVE -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ( annotation )* ) ) | -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ) ) ) ) 1215 { 1216 FIELD_DIRECTIVE19=(Token)match(input,FIELD_DIRECTIVE,FOLLOW_FIELD_DIRECTIVE_in_field1337); 1217 stream_FIELD_DIRECTIVE.add(FIELD_DIRECTIVE19); 1218 1219 pushFollow(FOLLOW_access_list_in_field1339); 1220 access_list20=access_list(); 1221 state._fsp--; 1222 1223 stream_access_list.add(access_list20.getTree()); 1224 pushFollow(FOLLOW_member_name_in_field1341); 1225 member_name21=member_name(); 1226 state._fsp--; 1227 1228 stream_member_name.add(member_name21.getTree()); 1229 COLON22=(Token)match(input,COLON,FOLLOW_COLON_in_field1343); 1230 stream_COLON.add(COLON22); 1231 1232 pushFollow(FOLLOW_nonvoid_type_descriptor_in_field1345); 1233 nonvoid_type_descriptor23=nonvoid_type_descriptor(); 1234 state._fsp--; 1235 1236 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor23.getTree()); 1237 // smaliParser.g:477:75: ( EQUAL literal )? 1238 int alt3=2; 1239 int LA3_0 = input.LA(1); 1240 if ( (LA3_0==EQUAL) ) { 1241 alt3=1; 1242 } 1243 switch (alt3) { 1244 case 1 : 1245 // smaliParser.g:477:76: EQUAL literal 1246 { 1247 EQUAL24=(Token)match(input,EQUAL,FOLLOW_EQUAL_in_field1348); 1248 stream_EQUAL.add(EQUAL24); 1249 1250 pushFollow(FOLLOW_literal_in_field1350); 1251 literal25=literal(); 1252 state._fsp--; 1253 1254 stream_literal.add(literal25.getTree()); 1255 } 1256 break; 1257 1258 } 1259 1260 // smaliParser.g:478:5: ( ({...}? annotation )* ( END_FIELD_DIRECTIVE -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ( annotation )* ) ) | -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ) ) ) ) 1261 // smaliParser.g:478:7: ({...}? annotation )* ( END_FIELD_DIRECTIVE -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ( annotation )* ) ) | -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ) ) ) 1262 { 1263 // smaliParser.g:478:7: ({...}? annotation )* 1264 loop4: 1265 while (true) { 1266 int alt4=2; 1267 int LA4_0 = input.LA(1); 1268 if ( (LA4_0==ANNOTATION_DIRECTIVE) ) { 1269 int LA4_9 = input.LA(2); 1270 if ( ((input.LA(1) == ANNOTATION_DIRECTIVE)) ) { 1271 alt4=1; 1272 } 1273 1274 } 1275 1276 switch (alt4) { 1277 case 1 : 1278 // smaliParser.g:478:8: {...}? annotation 1279 { 1280 if ( !((input.LA(1) == ANNOTATION_DIRECTIVE)) ) { 1281 throw new FailedPredicateException(input, "field", "input.LA(1) == ANNOTATION_DIRECTIVE"); 1282 } 1283 pushFollow(FOLLOW_annotation_in_field1363); 1284 annotation26=annotation(); 1285 state._fsp--; 1286 1287 stream_annotation.add(annotation26.getTree()); 1288 annotations.add((annotation26!=null?((CommonTree)annotation26.getTree()):null)); 1289 } 1290 break; 1291 1292 default : 1293 break loop4; 1294 } 1295 } 1296 1297 // smaliParser.g:479:7: ( END_FIELD_DIRECTIVE -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ( annotation )* ) ) | -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ) ) ) 1298 int alt5=2; 1299 int LA5_0 = input.LA(1); 1300 if ( (LA5_0==END_FIELD_DIRECTIVE) ) { 1301 alt5=1; 1302 } 1303 else if ( (LA5_0==EOF||LA5_0==ANNOTATION_DIRECTIVE||LA5_0==CLASS_DIRECTIVE||LA5_0==FIELD_DIRECTIVE||LA5_0==IMPLEMENTS_DIRECTIVE||LA5_0==METHOD_DIRECTIVE||LA5_0==SOURCE_DIRECTIVE||LA5_0==SUPER_DIRECTIVE) ) { 1304 alt5=2; 1305 } 1306 1307 else { 1308 NoViableAltException nvae = 1309 new NoViableAltException("", 5, 0, input); 1310 throw nvae; 1311 } 1312 1313 switch (alt5) { 1314 case 1 : 1315 // smaliParser.g:479:9: END_FIELD_DIRECTIVE 1316 { 1317 END_FIELD_DIRECTIVE27=(Token)match(input,END_FIELD_DIRECTIVE,FOLLOW_END_FIELD_DIRECTIVE_in_field1377); 1318 stream_END_FIELD_DIRECTIVE.add(END_FIELD_DIRECTIVE27); 1319 1320 // AST REWRITE 1321 // elements: access_list, nonvoid_type_descriptor, annotation, member_name, literal 1322 // token labels: 1323 // rule labels: retval 1324 // token list labels: 1325 // rule list labels: 1326 // wildcard labels: 1327 retval.tree = root_0; 1328 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 1329 1330 root_0 = (CommonTree)adaptor.nil(); 1331 // 480:9: -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ( annotation )* ) ) 1332 { 1333 // smaliParser.g:480:12: ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ( annotation )* ) ) 1334 { 1335 CommonTree root_1 = (CommonTree)adaptor.nil(); 1336 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELD, (retval.start), "I_FIELD"), root_1); 1337 adaptor.addChild(root_1, stream_member_name.nextTree()); 1338 adaptor.addChild(root_1, stream_access_list.nextTree()); 1339 // smaliParser.g:480:65: ^( I_FIELD_TYPE nonvoid_type_descriptor ) 1340 { 1341 CommonTree root_2 = (CommonTree)adaptor.nil(); 1342 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELD_TYPE, "I_FIELD_TYPE"), root_2); 1343 adaptor.addChild(root_2, stream_nonvoid_type_descriptor.nextTree()); 1344 adaptor.addChild(root_1, root_2); 1345 } 1346 1347 // smaliParser.g:480:105: ( ^( I_FIELD_INITIAL_VALUE literal ) )? 1348 if ( stream_literal.hasNext() ) { 1349 // smaliParser.g:480:105: ^( I_FIELD_INITIAL_VALUE literal ) 1350 { 1351 CommonTree root_2 = (CommonTree)adaptor.nil(); 1352 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELD_INITIAL_VALUE, "I_FIELD_INITIAL_VALUE"), root_2); 1353 adaptor.addChild(root_2, stream_literal.nextTree()); 1354 adaptor.addChild(root_1, root_2); 1355 } 1356 1357 } 1358 stream_literal.reset(); 1359 1360 // smaliParser.g:480:139: ^( I_ANNOTATIONS ( annotation )* ) 1361 { 1362 CommonTree root_2 = (CommonTree)adaptor.nil(); 1363 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ANNOTATIONS, "I_ANNOTATIONS"), root_2); 1364 // smaliParser.g:480:155: ( annotation )* 1365 while ( stream_annotation.hasNext() ) { 1366 adaptor.addChild(root_2, stream_annotation.nextTree()); 1367 } 1368 stream_annotation.reset(); 1369 1370 adaptor.addChild(root_1, root_2); 1371 } 1372 1373 adaptor.addChild(root_0, root_1); 1374 } 1375 1376 } 1377 1378 1379 retval.tree = root_0; 1380 1381 } 1382 break; 1383 case 2 : 1384 // smaliParser.g:481:21: 1385 { 1386 smali_file_stack.peek().classAnnotations.addAll(annotations); 1387 // AST REWRITE 1388 // elements: member_name, access_list, literal, nonvoid_type_descriptor 1389 // token labels: 1390 // rule labels: retval 1391 // token list labels: 1392 // rule list labels: 1393 // wildcard labels: 1394 retval.tree = root_0; 1395 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 1396 1397 root_0 = (CommonTree)adaptor.nil(); 1398 // 482:9: -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ) ) 1399 { 1400 // smaliParser.g:482:12: ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ) ) 1401 { 1402 CommonTree root_1 = (CommonTree)adaptor.nil(); 1403 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELD, (retval.start), "I_FIELD"), root_1); 1404 adaptor.addChild(root_1, stream_member_name.nextTree()); 1405 adaptor.addChild(root_1, stream_access_list.nextTree()); 1406 // smaliParser.g:482:65: ^( I_FIELD_TYPE nonvoid_type_descriptor ) 1407 { 1408 CommonTree root_2 = (CommonTree)adaptor.nil(); 1409 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELD_TYPE, "I_FIELD_TYPE"), root_2); 1410 adaptor.addChild(root_2, stream_nonvoid_type_descriptor.nextTree()); 1411 adaptor.addChild(root_1, root_2); 1412 } 1413 1414 // smaliParser.g:482:105: ( ^( I_FIELD_INITIAL_VALUE literal ) )? 1415 if ( stream_literal.hasNext() ) { 1416 // smaliParser.g:482:105: ^( I_FIELD_INITIAL_VALUE literal ) 1417 { 1418 CommonTree root_2 = (CommonTree)adaptor.nil(); 1419 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELD_INITIAL_VALUE, "I_FIELD_INITIAL_VALUE"), root_2); 1420 adaptor.addChild(root_2, stream_literal.nextTree()); 1421 adaptor.addChild(root_1, root_2); 1422 } 1423 1424 } 1425 stream_literal.reset(); 1426 1427 // smaliParser.g:482:139: ^( I_ANNOTATIONS ) 1428 { 1429 CommonTree root_2 = (CommonTree)adaptor.nil(); 1430 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ANNOTATIONS, "I_ANNOTATIONS"), root_2); 1431 adaptor.addChild(root_1, root_2); 1432 } 1433 1434 adaptor.addChild(root_0, root_1); 1435 } 1436 1437 } 1438 1439 1440 retval.tree = root_0; 1441 1442 } 1443 break; 1444 1445 } 1446 1447 } 1448 1449 } 1450 1451 retval.stop = input.LT(-1); 1452 1453 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 1454 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 1455 1456 } 1457 catch (RecognitionException re) { 1458 reportError(re); 1459 recover(input,re); 1460 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 1461 } 1462 finally { 1463 // do for sure before leaving 1464 } 1465 return retval; 1466 } 1467 // $ANTLR end "field" 1468 1469 1470 public static class method_return extends ParserRuleReturnScope { 1471 CommonTree tree; 1472 @Override 1473 public CommonTree getTree() { return tree; } 1474 }; 1475 1476 1477 // $ANTLR start "method" 1478 // smaliParser.g:486:1: method : METHOD_DIRECTIVE access_list member_name method_prototype statements_and_directives END_METHOD_DIRECTIVE -> ^( I_METHOD[$start, \"I_METHOD\"] member_name method_prototype access_list statements_and_directives ) ; 1479 public final smaliParser.method_return method() throws RecognitionException { 1480 smaliParser.method_return retval = new smaliParser.method_return(); 1481 retval.start = input.LT(1); 1482 1483 CommonTree root_0 = null; 1484 1485 Token METHOD_DIRECTIVE28=null; 1486 Token END_METHOD_DIRECTIVE33=null; 1487 ParserRuleReturnScope access_list29 =null; 1488 ParserRuleReturnScope member_name30 =null; 1489 ParserRuleReturnScope method_prototype31 =null; 1490 ParserRuleReturnScope statements_and_directives32 =null; 1491 1492 CommonTree METHOD_DIRECTIVE28_tree=null; 1493 CommonTree END_METHOD_DIRECTIVE33_tree=null; 1494 RewriteRuleTokenStream stream_END_METHOD_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_METHOD_DIRECTIVE"); 1495 RewriteRuleTokenStream stream_METHOD_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token METHOD_DIRECTIVE"); 1496 RewriteRuleSubtreeStream stream_method_prototype=new RewriteRuleSubtreeStream(adaptor,"rule method_prototype"); 1497 RewriteRuleSubtreeStream stream_access_list=new RewriteRuleSubtreeStream(adaptor,"rule access_list"); 1498 RewriteRuleSubtreeStream stream_member_name=new RewriteRuleSubtreeStream(adaptor,"rule member_name"); 1499 RewriteRuleSubtreeStream stream_statements_and_directives=new RewriteRuleSubtreeStream(adaptor,"rule statements_and_directives"); 1500 1501 try { 1502 // smaliParser.g:487:3: ( METHOD_DIRECTIVE access_list member_name method_prototype statements_and_directives END_METHOD_DIRECTIVE -> ^( I_METHOD[$start, \"I_METHOD\"] member_name method_prototype access_list statements_and_directives ) ) 1503 // smaliParser.g:487:5: METHOD_DIRECTIVE access_list member_name method_prototype statements_and_directives END_METHOD_DIRECTIVE 1504 { 1505 METHOD_DIRECTIVE28=(Token)match(input,METHOD_DIRECTIVE,FOLLOW_METHOD_DIRECTIVE_in_method1488); 1506 stream_METHOD_DIRECTIVE.add(METHOD_DIRECTIVE28); 1507 1508 pushFollow(FOLLOW_access_list_in_method1490); 1509 access_list29=access_list(); 1510 state._fsp--; 1511 1512 stream_access_list.add(access_list29.getTree()); 1513 pushFollow(FOLLOW_member_name_in_method1492); 1514 member_name30=member_name(); 1515 state._fsp--; 1516 1517 stream_member_name.add(member_name30.getTree()); 1518 pushFollow(FOLLOW_method_prototype_in_method1494); 1519 method_prototype31=method_prototype(); 1520 state._fsp--; 1521 1522 stream_method_prototype.add(method_prototype31.getTree()); 1523 pushFollow(FOLLOW_statements_and_directives_in_method1496); 1524 statements_and_directives32=statements_and_directives(); 1525 state._fsp--; 1526 1527 stream_statements_and_directives.add(statements_and_directives32.getTree()); 1528 END_METHOD_DIRECTIVE33=(Token)match(input,END_METHOD_DIRECTIVE,FOLLOW_END_METHOD_DIRECTIVE_in_method1502); 1529 stream_END_METHOD_DIRECTIVE.add(END_METHOD_DIRECTIVE33); 1530 1531 // AST REWRITE 1532 // elements: method_prototype, access_list, member_name, statements_and_directives 1533 // token labels: 1534 // rule labels: retval 1535 // token list labels: 1536 // rule list labels: 1537 // wildcard labels: 1538 retval.tree = root_0; 1539 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 1540 1541 root_0 = (CommonTree)adaptor.nil(); 1542 // 489:5: -> ^( I_METHOD[$start, \"I_METHOD\"] member_name method_prototype access_list statements_and_directives ) 1543 { 1544 // smaliParser.g:489:8: ^( I_METHOD[$start, \"I_METHOD\"] member_name method_prototype access_list statements_and_directives ) 1545 { 1546 CommonTree root_1 = (CommonTree)adaptor.nil(); 1547 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_METHOD, (retval.start), "I_METHOD"), root_1); 1548 adaptor.addChild(root_1, stream_member_name.nextTree()); 1549 adaptor.addChild(root_1, stream_method_prototype.nextTree()); 1550 adaptor.addChild(root_1, stream_access_list.nextTree()); 1551 adaptor.addChild(root_1, stream_statements_and_directives.nextTree()); 1552 adaptor.addChild(root_0, root_1); 1553 } 1554 1555 } 1556 1557 1558 retval.tree = root_0; 1559 1560 } 1561 1562 retval.stop = input.LT(-1); 1563 1564 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 1565 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 1566 1567 } 1568 catch (RecognitionException re) { 1569 reportError(re); 1570 recover(input,re); 1571 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 1572 } 1573 finally { 1574 // do for sure before leaving 1575 } 1576 return retval; 1577 } 1578 // $ANTLR end "method" 1579 1580 1581 protected static class statements_and_directives_scope { 1582 boolean hasRegistersDirective; 1583 List<CommonTree> methodAnnotations; 1584 } 1585 protected Stack<statements_and_directives_scope> statements_and_directives_stack = new Stack<statements_and_directives_scope>(); 1586 1587 public static class statements_and_directives_return extends ParserRuleReturnScope { 1588 CommonTree tree; 1589 @Override 1590 public CommonTree getTree() { return tree; } 1591 }; 1592 1593 1594 // $ANTLR start "statements_and_directives" 1595 // smaliParser.g:491:1: statements_and_directives : ( ordered_method_item | registers_directive | catch_directive | catchall_directive | parameter_directive | annotation )* -> ( registers_directive )? ^( I_ORDERED_METHOD_ITEMS ( ordered_method_item )* ) ^( I_CATCHES ( catch_directive )* ( catchall_directive )* ) ^( I_PARAMETERS ( parameter_directive )* ) ; 1596 public final smaliParser.statements_and_directives_return statements_and_directives() throws RecognitionException { 1597 statements_and_directives_stack.push(new statements_and_directives_scope()); 1598 smaliParser.statements_and_directives_return retval = new smaliParser.statements_and_directives_return(); 1599 retval.start = input.LT(1); 1600 1601 CommonTree root_0 = null; 1602 1603 ParserRuleReturnScope ordered_method_item34 =null; 1604 ParserRuleReturnScope registers_directive35 =null; 1605 ParserRuleReturnScope catch_directive36 =null; 1606 ParserRuleReturnScope catchall_directive37 =null; 1607 ParserRuleReturnScope parameter_directive38 =null; 1608 ParserRuleReturnScope annotation39 =null; 1609 1610 RewriteRuleSubtreeStream stream_annotation=new RewriteRuleSubtreeStream(adaptor,"rule annotation"); 1611 RewriteRuleSubtreeStream stream_catchall_directive=new RewriteRuleSubtreeStream(adaptor,"rule catchall_directive"); 1612 RewriteRuleSubtreeStream stream_registers_directive=new RewriteRuleSubtreeStream(adaptor,"rule registers_directive"); 1613 RewriteRuleSubtreeStream stream_catch_directive=new RewriteRuleSubtreeStream(adaptor,"rule catch_directive"); 1614 RewriteRuleSubtreeStream stream_ordered_method_item=new RewriteRuleSubtreeStream(adaptor,"rule ordered_method_item"); 1615 RewriteRuleSubtreeStream stream_parameter_directive=new RewriteRuleSubtreeStream(adaptor,"rule parameter_directive"); 1616 1617 try { 1618 // smaliParser.g:497:3: ( ( ordered_method_item | registers_directive | catch_directive | catchall_directive | parameter_directive | annotation )* -> ( registers_directive )? ^( I_ORDERED_METHOD_ITEMS ( ordered_method_item )* ) ^( I_CATCHES ( catch_directive )* ( catchall_directive )* ) ^( I_PARAMETERS ( parameter_directive )* ) ) 1619 // smaliParser.g:497:5: ( ordered_method_item | registers_directive | catch_directive | catchall_directive | parameter_directive | annotation )* 1620 { 1621 1622 statements_and_directives_stack.peek().hasRegistersDirective = false; 1623 statements_and_directives_stack.peek().methodAnnotations = new ArrayList<CommonTree>(); 1624 1625 // smaliParser.g:501:5: ( ordered_method_item | registers_directive | catch_directive | catchall_directive | parameter_directive | annotation )* 1626 loop6: 1627 while (true) { 1628 int alt6=7; 1629 switch ( input.LA(1) ) { 1630 case ARRAY_DATA_DIRECTIVE: 1631 case COLON: 1632 case END_LOCAL_DIRECTIVE: 1633 case EPILOGUE_DIRECTIVE: 1634 case INSTRUCTION_FORMAT10t: 1635 case INSTRUCTION_FORMAT10x: 1636 case INSTRUCTION_FORMAT10x_ODEX: 1637 case INSTRUCTION_FORMAT11n: 1638 case INSTRUCTION_FORMAT11x: 1639 case INSTRUCTION_FORMAT12x: 1640 case INSTRUCTION_FORMAT12x_OR_ID: 1641 case INSTRUCTION_FORMAT20bc: 1642 case INSTRUCTION_FORMAT20t: 1643 case INSTRUCTION_FORMAT21c_FIELD: 1644 case INSTRUCTION_FORMAT21c_FIELD_ODEX: 1645 case INSTRUCTION_FORMAT21c_STRING: 1646 case INSTRUCTION_FORMAT21c_TYPE: 1647 case INSTRUCTION_FORMAT21ih: 1648 case INSTRUCTION_FORMAT21lh: 1649 case INSTRUCTION_FORMAT21s: 1650 case INSTRUCTION_FORMAT21t: 1651 case INSTRUCTION_FORMAT22b: 1652 case INSTRUCTION_FORMAT22c_FIELD: 1653 case INSTRUCTION_FORMAT22c_FIELD_ODEX: 1654 case INSTRUCTION_FORMAT22c_TYPE: 1655 case INSTRUCTION_FORMAT22cs_FIELD: 1656 case INSTRUCTION_FORMAT22s: 1657 case INSTRUCTION_FORMAT22s_OR_ID: 1658 case INSTRUCTION_FORMAT22t: 1659 case INSTRUCTION_FORMAT22x: 1660 case INSTRUCTION_FORMAT23x: 1661 case INSTRUCTION_FORMAT30t: 1662 case INSTRUCTION_FORMAT31c: 1663 case INSTRUCTION_FORMAT31i: 1664 case INSTRUCTION_FORMAT31i_OR_ID: 1665 case INSTRUCTION_FORMAT31t: 1666 case INSTRUCTION_FORMAT32x: 1667 case INSTRUCTION_FORMAT35c_METHOD: 1668 case INSTRUCTION_FORMAT35c_METHOD_ODEX: 1669 case INSTRUCTION_FORMAT35c_TYPE: 1670 case INSTRUCTION_FORMAT35mi_METHOD: 1671 case INSTRUCTION_FORMAT35ms_METHOD: 1672 case INSTRUCTION_FORMAT3rc_METHOD: 1673 case INSTRUCTION_FORMAT3rc_METHOD_ODEX: 1674 case INSTRUCTION_FORMAT3rc_TYPE: 1675 case INSTRUCTION_FORMAT3rmi_METHOD: 1676 case INSTRUCTION_FORMAT3rms_METHOD: 1677 case INSTRUCTION_FORMAT45cc_METHOD: 1678 case INSTRUCTION_FORMAT4rcc_METHOD: 1679 case INSTRUCTION_FORMAT51l: 1680 case LINE_DIRECTIVE: 1681 case LOCAL_DIRECTIVE: 1682 case PACKED_SWITCH_DIRECTIVE: 1683 case PROLOGUE_DIRECTIVE: 1684 case RESTART_LOCAL_DIRECTIVE: 1685 case SOURCE_DIRECTIVE: 1686 case SPARSE_SWITCH_DIRECTIVE: 1687 { 1688 alt6=1; 1689 } 1690 break; 1691 case LOCALS_DIRECTIVE: 1692 case REGISTERS_DIRECTIVE: 1693 { 1694 alt6=2; 1695 } 1696 break; 1697 case CATCH_DIRECTIVE: 1698 { 1699 alt6=3; 1700 } 1701 break; 1702 case CATCHALL_DIRECTIVE: 1703 { 1704 alt6=4; 1705 } 1706 break; 1707 case PARAMETER_DIRECTIVE: 1708 { 1709 alt6=5; 1710 } 1711 break; 1712 case ANNOTATION_DIRECTIVE: 1713 { 1714 alt6=6; 1715 } 1716 break; 1717 } 1718 switch (alt6) { 1719 case 1 : 1720 // smaliParser.g:501:7: ordered_method_item 1721 { 1722 pushFollow(FOLLOW_ordered_method_item_in_statements_and_directives1547); 1723 ordered_method_item34=ordered_method_item(); 1724 state._fsp--; 1725 1726 stream_ordered_method_item.add(ordered_method_item34.getTree()); 1727 } 1728 break; 1729 case 2 : 1730 // smaliParser.g:502:7: registers_directive 1731 { 1732 pushFollow(FOLLOW_registers_directive_in_statements_and_directives1555); 1733 registers_directive35=registers_directive(); 1734 state._fsp--; 1735 1736 stream_registers_directive.add(registers_directive35.getTree()); 1737 } 1738 break; 1739 case 3 : 1740 // smaliParser.g:503:7: catch_directive 1741 { 1742 pushFollow(FOLLOW_catch_directive_in_statements_and_directives1563); 1743 catch_directive36=catch_directive(); 1744 state._fsp--; 1745 1746 stream_catch_directive.add(catch_directive36.getTree()); 1747 } 1748 break; 1749 case 4 : 1750 // smaliParser.g:504:7: catchall_directive 1751 { 1752 pushFollow(FOLLOW_catchall_directive_in_statements_and_directives1571); 1753 catchall_directive37=catchall_directive(); 1754 state._fsp--; 1755 1756 stream_catchall_directive.add(catchall_directive37.getTree()); 1757 } 1758 break; 1759 case 5 : 1760 // smaliParser.g:505:7: parameter_directive 1761 { 1762 pushFollow(FOLLOW_parameter_directive_in_statements_and_directives1579); 1763 parameter_directive38=parameter_directive(); 1764 state._fsp--; 1765 1766 stream_parameter_directive.add(parameter_directive38.getTree()); 1767 } 1768 break; 1769 case 6 : 1770 // smaliParser.g:506:7: annotation 1771 { 1772 pushFollow(FOLLOW_annotation_in_statements_and_directives1587); 1773 annotation39=annotation(); 1774 state._fsp--; 1775 1776 stream_annotation.add(annotation39.getTree()); 1777 statements_and_directives_stack.peek().methodAnnotations.add((annotation39!=null?((CommonTree)annotation39.getTree()):null)); 1778 } 1779 break; 1780 1781 default : 1782 break loop6; 1783 } 1784 } 1785 1786 // AST REWRITE 1787 // elements: ordered_method_item, catch_directive, catchall_directive, parameter_directive, registers_directive 1788 // token labels: 1789 // rule labels: retval 1790 // token list labels: 1791 // rule list labels: 1792 // wildcard labels: 1793 retval.tree = root_0; 1794 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 1795 1796 root_0 = (CommonTree)adaptor.nil(); 1797 // 508:5: -> ( registers_directive )? ^( I_ORDERED_METHOD_ITEMS ( ordered_method_item )* ) ^( I_CATCHES ( catch_directive )* ( catchall_directive )* ) ^( I_PARAMETERS ( parameter_directive )* ) 1798 { 1799 // smaliParser.g:508:8: ( registers_directive )? 1800 if ( stream_registers_directive.hasNext() ) { 1801 adaptor.addChild(root_0, stream_registers_directive.nextTree()); 1802 } 1803 stream_registers_directive.reset(); 1804 1805 // smaliParser.g:509:8: ^( I_ORDERED_METHOD_ITEMS ( ordered_method_item )* ) 1806 { 1807 CommonTree root_1 = (CommonTree)adaptor.nil(); 1808 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ORDERED_METHOD_ITEMS, "I_ORDERED_METHOD_ITEMS"), root_1); 1809 // smaliParser.g:509:33: ( ordered_method_item )* 1810 while ( stream_ordered_method_item.hasNext() ) { 1811 adaptor.addChild(root_1, stream_ordered_method_item.nextTree()); 1812 } 1813 stream_ordered_method_item.reset(); 1814 1815 adaptor.addChild(root_0, root_1); 1816 } 1817 1818 // smaliParser.g:510:8: ^( I_CATCHES ( catch_directive )* ( catchall_directive )* ) 1819 { 1820 CommonTree root_1 = (CommonTree)adaptor.nil(); 1821 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_CATCHES, "I_CATCHES"), root_1); 1822 // smaliParser.g:510:20: ( catch_directive )* 1823 while ( stream_catch_directive.hasNext() ) { 1824 adaptor.addChild(root_1, stream_catch_directive.nextTree()); 1825 } 1826 stream_catch_directive.reset(); 1827 1828 // smaliParser.g:510:37: ( catchall_directive )* 1829 while ( stream_catchall_directive.hasNext() ) { 1830 adaptor.addChild(root_1, stream_catchall_directive.nextTree()); 1831 } 1832 stream_catchall_directive.reset(); 1833 1834 adaptor.addChild(root_0, root_1); 1835 } 1836 1837 // smaliParser.g:511:8: ^( I_PARAMETERS ( parameter_directive )* ) 1838 { 1839 CommonTree root_1 = (CommonTree)adaptor.nil(); 1840 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_PARAMETERS, "I_PARAMETERS"), root_1); 1841 // smaliParser.g:511:23: ( parameter_directive )* 1842 while ( stream_parameter_directive.hasNext() ) { 1843 adaptor.addChild(root_1, stream_parameter_directive.nextTree()); 1844 } 1845 stream_parameter_directive.reset(); 1846 1847 adaptor.addChild(root_0, root_1); 1848 } 1849 1850 adaptor.addChild(root_0, buildTree(I_ANNOTATIONS, "I_ANNOTATIONS", statements_and_directives_stack.peek().methodAnnotations)); 1851 } 1852 1853 1854 retval.tree = root_0; 1855 1856 } 1857 1858 retval.stop = input.LT(-1); 1859 1860 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 1861 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 1862 1863 } 1864 catch (RecognitionException re) { 1865 reportError(re); 1866 recover(input,re); 1867 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 1868 } 1869 finally { 1870 // do for sure before leaving 1871 statements_and_directives_stack.pop(); 1872 } 1873 return retval; 1874 } 1875 // $ANTLR end "statements_and_directives" 1876 1877 1878 public static class ordered_method_item_return extends ParserRuleReturnScope { 1879 CommonTree tree; 1880 @Override 1881 public CommonTree getTree() { return tree; } 1882 }; 1883 1884 1885 // $ANTLR start "ordered_method_item" 1886 // smaliParser.g:515:1: ordered_method_item : ( label | instruction | debug_directive ); 1887 public final smaliParser.ordered_method_item_return ordered_method_item() throws RecognitionException { 1888 smaliParser.ordered_method_item_return retval = new smaliParser.ordered_method_item_return(); 1889 retval.start = input.LT(1); 1890 1891 CommonTree root_0 = null; 1892 1893 ParserRuleReturnScope label40 =null; 1894 ParserRuleReturnScope instruction41 =null; 1895 ParserRuleReturnScope debug_directive42 =null; 1896 1897 1898 try { 1899 // smaliParser.g:516:3: ( label | instruction | debug_directive ) 1900 int alt7=3; 1901 switch ( input.LA(1) ) { 1902 case COLON: 1903 { 1904 alt7=1; 1905 } 1906 break; 1907 case ARRAY_DATA_DIRECTIVE: 1908 case INSTRUCTION_FORMAT10t: 1909 case INSTRUCTION_FORMAT10x: 1910 case INSTRUCTION_FORMAT10x_ODEX: 1911 case INSTRUCTION_FORMAT11n: 1912 case INSTRUCTION_FORMAT11x: 1913 case INSTRUCTION_FORMAT12x: 1914 case INSTRUCTION_FORMAT12x_OR_ID: 1915 case INSTRUCTION_FORMAT20bc: 1916 case INSTRUCTION_FORMAT20t: 1917 case INSTRUCTION_FORMAT21c_FIELD: 1918 case INSTRUCTION_FORMAT21c_FIELD_ODEX: 1919 case INSTRUCTION_FORMAT21c_STRING: 1920 case INSTRUCTION_FORMAT21c_TYPE: 1921 case INSTRUCTION_FORMAT21ih: 1922 case INSTRUCTION_FORMAT21lh: 1923 case INSTRUCTION_FORMAT21s: 1924 case INSTRUCTION_FORMAT21t: 1925 case INSTRUCTION_FORMAT22b: 1926 case INSTRUCTION_FORMAT22c_FIELD: 1927 case INSTRUCTION_FORMAT22c_FIELD_ODEX: 1928 case INSTRUCTION_FORMAT22c_TYPE: 1929 case INSTRUCTION_FORMAT22cs_FIELD: 1930 case INSTRUCTION_FORMAT22s: 1931 case INSTRUCTION_FORMAT22s_OR_ID: 1932 case INSTRUCTION_FORMAT22t: 1933 case INSTRUCTION_FORMAT22x: 1934 case INSTRUCTION_FORMAT23x: 1935 case INSTRUCTION_FORMAT30t: 1936 case INSTRUCTION_FORMAT31c: 1937 case INSTRUCTION_FORMAT31i: 1938 case INSTRUCTION_FORMAT31i_OR_ID: 1939 case INSTRUCTION_FORMAT31t: 1940 case INSTRUCTION_FORMAT32x: 1941 case INSTRUCTION_FORMAT35c_METHOD: 1942 case INSTRUCTION_FORMAT35c_METHOD_ODEX: 1943 case INSTRUCTION_FORMAT35c_TYPE: 1944 case INSTRUCTION_FORMAT35mi_METHOD: 1945 case INSTRUCTION_FORMAT35ms_METHOD: 1946 case INSTRUCTION_FORMAT3rc_METHOD: 1947 case INSTRUCTION_FORMAT3rc_METHOD_ODEX: 1948 case INSTRUCTION_FORMAT3rc_TYPE: 1949 case INSTRUCTION_FORMAT3rmi_METHOD: 1950 case INSTRUCTION_FORMAT3rms_METHOD: 1951 case INSTRUCTION_FORMAT45cc_METHOD: 1952 case INSTRUCTION_FORMAT4rcc_METHOD: 1953 case INSTRUCTION_FORMAT51l: 1954 case PACKED_SWITCH_DIRECTIVE: 1955 case SPARSE_SWITCH_DIRECTIVE: 1956 { 1957 alt7=2; 1958 } 1959 break; 1960 case END_LOCAL_DIRECTIVE: 1961 case EPILOGUE_DIRECTIVE: 1962 case LINE_DIRECTIVE: 1963 case LOCAL_DIRECTIVE: 1964 case PROLOGUE_DIRECTIVE: 1965 case RESTART_LOCAL_DIRECTIVE: 1966 case SOURCE_DIRECTIVE: 1967 { 1968 alt7=3; 1969 } 1970 break; 1971 default: 1972 NoViableAltException nvae = 1973 new NoViableAltException("", 7, 0, input); 1974 throw nvae; 1975 } 1976 switch (alt7) { 1977 case 1 : 1978 // smaliParser.g:516:5: label 1979 { 1980 root_0 = (CommonTree)adaptor.nil(); 1981 1982 1983 pushFollow(FOLLOW_label_in_ordered_method_item1672); 1984 label40=label(); 1985 state._fsp--; 1986 1987 adaptor.addChild(root_0, label40.getTree()); 1988 1989 } 1990 break; 1991 case 2 : 1992 // smaliParser.g:517:5: instruction 1993 { 1994 root_0 = (CommonTree)adaptor.nil(); 1995 1996 1997 pushFollow(FOLLOW_instruction_in_ordered_method_item1678); 1998 instruction41=instruction(); 1999 state._fsp--; 2000 2001 adaptor.addChild(root_0, instruction41.getTree()); 2002 2003 } 2004 break; 2005 case 3 : 2006 // smaliParser.g:518:5: debug_directive 2007 { 2008 root_0 = (CommonTree)adaptor.nil(); 2009 2010 2011 pushFollow(FOLLOW_debug_directive_in_ordered_method_item1684); 2012 debug_directive42=debug_directive(); 2013 state._fsp--; 2014 2015 adaptor.addChild(root_0, debug_directive42.getTree()); 2016 2017 } 2018 break; 2019 2020 } 2021 retval.stop = input.LT(-1); 2022 2023 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 2024 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 2025 2026 } 2027 catch (RecognitionException re) { 2028 reportError(re); 2029 recover(input,re); 2030 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 2031 } 2032 finally { 2033 // do for sure before leaving 2034 } 2035 return retval; 2036 } 2037 // $ANTLR end "ordered_method_item" 2038 2039 2040 public static class registers_directive_return extends ParserRuleReturnScope { 2041 CommonTree tree; 2042 @Override 2043 public CommonTree getTree() { return tree; } 2044 }; 2045 2046 2047 // $ANTLR start "registers_directive" 2048 // smaliParser.g:520:1: registers_directive : (directive= REGISTERS_DIRECTIVE regCount= integral_literal -> ^( I_REGISTERS[$REGISTERS_DIRECTIVE, \"I_REGISTERS\"] $regCount) |directive= LOCALS_DIRECTIVE regCount2= integral_literal -> ^( I_LOCALS[$LOCALS_DIRECTIVE, \"I_LOCALS\"] $regCount2) ) ; 2049 public final smaliParser.registers_directive_return registers_directive() throws RecognitionException { 2050 smaliParser.registers_directive_return retval = new smaliParser.registers_directive_return(); 2051 retval.start = input.LT(1); 2052 2053 CommonTree root_0 = null; 2054 2055 Token directive=null; 2056 ParserRuleReturnScope regCount =null; 2057 ParserRuleReturnScope regCount2 =null; 2058 2059 CommonTree directive_tree=null; 2060 RewriteRuleTokenStream stream_LOCALS_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token LOCALS_DIRECTIVE"); 2061 RewriteRuleTokenStream stream_REGISTERS_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token REGISTERS_DIRECTIVE"); 2062 RewriteRuleSubtreeStream stream_integral_literal=new RewriteRuleSubtreeStream(adaptor,"rule integral_literal"); 2063 2064 try { 2065 // smaliParser.g:521:3: ( (directive= REGISTERS_DIRECTIVE regCount= integral_literal -> ^( I_REGISTERS[$REGISTERS_DIRECTIVE, \"I_REGISTERS\"] $regCount) |directive= LOCALS_DIRECTIVE regCount2= integral_literal -> ^( I_LOCALS[$LOCALS_DIRECTIVE, \"I_LOCALS\"] $regCount2) ) ) 2066 // smaliParser.g:521:5: (directive= REGISTERS_DIRECTIVE regCount= integral_literal -> ^( I_REGISTERS[$REGISTERS_DIRECTIVE, \"I_REGISTERS\"] $regCount) |directive= LOCALS_DIRECTIVE regCount2= integral_literal -> ^( I_LOCALS[$LOCALS_DIRECTIVE, \"I_LOCALS\"] $regCount2) ) 2067 { 2068 // smaliParser.g:521:5: (directive= REGISTERS_DIRECTIVE regCount= integral_literal -> ^( I_REGISTERS[$REGISTERS_DIRECTIVE, \"I_REGISTERS\"] $regCount) |directive= LOCALS_DIRECTIVE regCount2= integral_literal -> ^( I_LOCALS[$LOCALS_DIRECTIVE, \"I_LOCALS\"] $regCount2) ) 2069 int alt8=2; 2070 int LA8_0 = input.LA(1); 2071 if ( (LA8_0==REGISTERS_DIRECTIVE) ) { 2072 alt8=1; 2073 } 2074 else if ( (LA8_0==LOCALS_DIRECTIVE) ) { 2075 alt8=2; 2076 } 2077 2078 else { 2079 NoViableAltException nvae = 2080 new NoViableAltException("", 8, 0, input); 2081 throw nvae; 2082 } 2083 2084 switch (alt8) { 2085 case 1 : 2086 // smaliParser.g:522:7: directive= REGISTERS_DIRECTIVE regCount= integral_literal 2087 { 2088 directive=(Token)match(input,REGISTERS_DIRECTIVE,FOLLOW_REGISTERS_DIRECTIVE_in_registers_directive1704); 2089 stream_REGISTERS_DIRECTIVE.add(directive); 2090 2091 pushFollow(FOLLOW_integral_literal_in_registers_directive1708); 2092 regCount=integral_literal(); 2093 state._fsp--; 2094 2095 stream_integral_literal.add(regCount.getTree()); 2096 // AST REWRITE 2097 // elements: regCount 2098 // token labels: 2099 // rule labels: regCount, retval 2100 // token list labels: 2101 // rule list labels: 2102 // wildcard labels: 2103 retval.tree = root_0; 2104 RewriteRuleSubtreeStream stream_regCount=new RewriteRuleSubtreeStream(adaptor,"rule regCount",regCount!=null?regCount.getTree():null); 2105 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2106 2107 root_0 = (CommonTree)adaptor.nil(); 2108 // 522:63: -> ^( I_REGISTERS[$REGISTERS_DIRECTIVE, \"I_REGISTERS\"] $regCount) 2109 { 2110 // smaliParser.g:522:66: ^( I_REGISTERS[$REGISTERS_DIRECTIVE, \"I_REGISTERS\"] $regCount) 2111 { 2112 CommonTree root_1 = (CommonTree)adaptor.nil(); 2113 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_REGISTERS, directive, "I_REGISTERS"), root_1); 2114 adaptor.addChild(root_1, stream_regCount.nextTree()); 2115 adaptor.addChild(root_0, root_1); 2116 } 2117 2118 } 2119 2120 2121 retval.tree = root_0; 2122 2123 } 2124 break; 2125 case 2 : 2126 // smaliParser.g:523:7: directive= LOCALS_DIRECTIVE regCount2= integral_literal 2127 { 2128 directive=(Token)match(input,LOCALS_DIRECTIVE,FOLLOW_LOCALS_DIRECTIVE_in_registers_directive1728); 2129 stream_LOCALS_DIRECTIVE.add(directive); 2130 2131 pushFollow(FOLLOW_integral_literal_in_registers_directive1732); 2132 regCount2=integral_literal(); 2133 state._fsp--; 2134 2135 stream_integral_literal.add(regCount2.getTree()); 2136 // AST REWRITE 2137 // elements: regCount2 2138 // token labels: 2139 // rule labels: regCount2, retval 2140 // token list labels: 2141 // rule list labels: 2142 // wildcard labels: 2143 retval.tree = root_0; 2144 RewriteRuleSubtreeStream stream_regCount2=new RewriteRuleSubtreeStream(adaptor,"rule regCount2",regCount2!=null?regCount2.getTree():null); 2145 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2146 2147 root_0 = (CommonTree)adaptor.nil(); 2148 // 523:61: -> ^( I_LOCALS[$LOCALS_DIRECTIVE, \"I_LOCALS\"] $regCount2) 2149 { 2150 // smaliParser.g:523:64: ^( I_LOCALS[$LOCALS_DIRECTIVE, \"I_LOCALS\"] $regCount2) 2151 { 2152 CommonTree root_1 = (CommonTree)adaptor.nil(); 2153 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_LOCALS, directive, "I_LOCALS"), root_1); 2154 adaptor.addChild(root_1, stream_regCount2.nextTree()); 2155 adaptor.addChild(root_0, root_1); 2156 } 2157 2158 } 2159 2160 2161 retval.tree = root_0; 2162 2163 } 2164 break; 2165 2166 } 2167 2168 2169 if (statements_and_directives_stack.peek().hasRegistersDirective) { 2170 throw new SemanticException(input, directive, "There can only be a single .registers or .locals directive in a method"); 2171 } 2172 statements_and_directives_stack.peek().hasRegistersDirective =true; 2173 2174 } 2175 2176 retval.stop = input.LT(-1); 2177 2178 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 2179 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 2180 2181 } 2182 catch (RecognitionException re) { 2183 reportError(re); 2184 recover(input,re); 2185 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 2186 } 2187 finally { 2188 // do for sure before leaving 2189 } 2190 return retval; 2191 } 2192 // $ANTLR end "registers_directive" 2193 2194 2195 public static class param_list_or_id_return extends ParserRuleReturnScope { 2196 CommonTree tree; 2197 @Override 2198 public CommonTree getTree() { return tree; } 2199 }; 2200 2201 2202 // $ANTLR start "param_list_or_id" 2203 // smaliParser.g:532:1: param_list_or_id : ( PARAM_LIST_OR_ID_PRIMITIVE_TYPE )+ ; 2204 public final smaliParser.param_list_or_id_return param_list_or_id() throws RecognitionException { 2205 smaliParser.param_list_or_id_return retval = new smaliParser.param_list_or_id_return(); 2206 retval.start = input.LT(1); 2207 2208 CommonTree root_0 = null; 2209 2210 Token PARAM_LIST_OR_ID_PRIMITIVE_TYPE43=null; 2211 2212 CommonTree PARAM_LIST_OR_ID_PRIMITIVE_TYPE43_tree=null; 2213 2214 try { 2215 // smaliParser.g:533:3: ( ( PARAM_LIST_OR_ID_PRIMITIVE_TYPE )+ ) 2216 // smaliParser.g:533:5: ( PARAM_LIST_OR_ID_PRIMITIVE_TYPE )+ 2217 { 2218 root_0 = (CommonTree)adaptor.nil(); 2219 2220 2221 // smaliParser.g:533:5: ( PARAM_LIST_OR_ID_PRIMITIVE_TYPE )+ 2222 int cnt9=0; 2223 loop9: 2224 while (true) { 2225 int alt9=2; 2226 int LA9_0 = input.LA(1); 2227 if ( (LA9_0==PARAM_LIST_OR_ID_PRIMITIVE_TYPE) ) { 2228 alt9=1; 2229 } 2230 2231 switch (alt9) { 2232 case 1 : 2233 // smaliParser.g:533:5: PARAM_LIST_OR_ID_PRIMITIVE_TYPE 2234 { 2235 PARAM_LIST_OR_ID_PRIMITIVE_TYPE43=(Token)match(input,PARAM_LIST_OR_ID_PRIMITIVE_TYPE,FOLLOW_PARAM_LIST_OR_ID_PRIMITIVE_TYPE_in_param_list_or_id1764); 2236 PARAM_LIST_OR_ID_PRIMITIVE_TYPE43_tree = (CommonTree)adaptor.create(PARAM_LIST_OR_ID_PRIMITIVE_TYPE43); 2237 adaptor.addChild(root_0, PARAM_LIST_OR_ID_PRIMITIVE_TYPE43_tree); 2238 2239 } 2240 break; 2241 2242 default : 2243 if ( cnt9 >= 1 ) break loop9; 2244 EarlyExitException eee = new EarlyExitException(9, input); 2245 throw eee; 2246 } 2247 cnt9++; 2248 } 2249 2250 } 2251 2252 retval.stop = input.LT(-1); 2253 2254 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 2255 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 2256 2257 } 2258 catch (RecognitionException re) { 2259 reportError(re); 2260 recover(input,re); 2261 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 2262 } 2263 finally { 2264 // do for sure before leaving 2265 } 2266 return retval; 2267 } 2268 // $ANTLR end "param_list_or_id" 2269 2270 2271 public static class simple_name_return extends ParserRuleReturnScope { 2272 CommonTree tree; 2273 @Override 2274 public CommonTree getTree() { return tree; } 2275 }; 2276 2277 2278 // $ANTLR start "simple_name" 2279 // smaliParser.g:537:1: simple_name : ( SIMPLE_NAME | ACCESS_SPEC -> SIMPLE_NAME[$ACCESS_SPEC] | VERIFICATION_ERROR_TYPE -> SIMPLE_NAME[$VERIFICATION_ERROR_TYPE] | POSITIVE_INTEGER_LITERAL -> SIMPLE_NAME[$POSITIVE_INTEGER_LITERAL] | NEGATIVE_INTEGER_LITERAL -> SIMPLE_NAME[$NEGATIVE_INTEGER_LITERAL] | FLOAT_LITERAL_OR_ID -> SIMPLE_NAME[$FLOAT_LITERAL_OR_ID] | DOUBLE_LITERAL_OR_ID -> SIMPLE_NAME[$DOUBLE_LITERAL_OR_ID] | BOOL_LITERAL -> SIMPLE_NAME[$BOOL_LITERAL] | NULL_LITERAL -> SIMPLE_NAME[$NULL_LITERAL] | REGISTER -> SIMPLE_NAME[$REGISTER] | param_list_or_id ->| PRIMITIVE_TYPE -> SIMPLE_NAME[$PRIMITIVE_TYPE] | VOID_TYPE -> SIMPLE_NAME[$VOID_TYPE] | ANNOTATION_VISIBILITY -> SIMPLE_NAME[$ANNOTATION_VISIBILITY] | INSTRUCTION_FORMAT10t -> SIMPLE_NAME[$INSTRUCTION_FORMAT10t] | INSTRUCTION_FORMAT10x -> SIMPLE_NAME[$INSTRUCTION_FORMAT10x] | INSTRUCTION_FORMAT10x_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT10x_ODEX] | INSTRUCTION_FORMAT11x -> SIMPLE_NAME[$INSTRUCTION_FORMAT11x] | INSTRUCTION_FORMAT12x_OR_ID -> SIMPLE_NAME[$INSTRUCTION_FORMAT12x_OR_ID] | INSTRUCTION_FORMAT21c_FIELD -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_FIELD] | INSTRUCTION_FORMAT21c_FIELD_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_FIELD_ODEX] | INSTRUCTION_FORMAT21c_STRING -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_STRING] | INSTRUCTION_FORMAT21c_TYPE -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_TYPE] | INSTRUCTION_FORMAT21t -> SIMPLE_NAME[$INSTRUCTION_FORMAT21t] | INSTRUCTION_FORMAT22c_FIELD -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_FIELD] | INSTRUCTION_FORMAT22c_FIELD_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_FIELD_ODEX] | INSTRUCTION_FORMAT22c_TYPE -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_TYPE] | INSTRUCTION_FORMAT22cs_FIELD -> SIMPLE_NAME[$INSTRUCTION_FORMAT22cs_FIELD] | INSTRUCTION_FORMAT22s_OR_ID -> SIMPLE_NAME[$INSTRUCTION_FORMAT22s_OR_ID] | INSTRUCTION_FORMAT22t -> SIMPLE_NAME[$INSTRUCTION_FORMAT22t] | INSTRUCTION_FORMAT23x -> SIMPLE_NAME[$INSTRUCTION_FORMAT23x] | INSTRUCTION_FORMAT31i_OR_ID -> SIMPLE_NAME[$INSTRUCTION_FORMAT31i_OR_ID] | INSTRUCTION_FORMAT31t -> SIMPLE_NAME[$INSTRUCTION_FORMAT31t] | INSTRUCTION_FORMAT35c_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_METHOD] | INSTRUCTION_FORMAT35c_METHOD_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_METHOD_ODEX] | INSTRUCTION_FORMAT35c_TYPE -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_TYPE] | INSTRUCTION_FORMAT35mi_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT35mi_METHOD] | INSTRUCTION_FORMAT35ms_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT35ms_METHOD] | INSTRUCTION_FORMAT45cc_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT45cc_METHOD] | INSTRUCTION_FORMAT4rcc_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT4rcc_METHOD] | INSTRUCTION_FORMAT51l -> SIMPLE_NAME[$INSTRUCTION_FORMAT51l] ); 2280 public final smaliParser.simple_name_return simple_name() throws RecognitionException { 2281 smaliParser.simple_name_return retval = new smaliParser.simple_name_return(); 2282 retval.start = input.LT(1); 2283 2284 CommonTree root_0 = null; 2285 2286 Token SIMPLE_NAME44=null; 2287 Token ACCESS_SPEC45=null; 2288 Token VERIFICATION_ERROR_TYPE46=null; 2289 Token POSITIVE_INTEGER_LITERAL47=null; 2290 Token NEGATIVE_INTEGER_LITERAL48=null; 2291 Token FLOAT_LITERAL_OR_ID49=null; 2292 Token DOUBLE_LITERAL_OR_ID50=null; 2293 Token BOOL_LITERAL51=null; 2294 Token NULL_LITERAL52=null; 2295 Token REGISTER53=null; 2296 Token PRIMITIVE_TYPE55=null; 2297 Token VOID_TYPE56=null; 2298 Token ANNOTATION_VISIBILITY57=null; 2299 Token INSTRUCTION_FORMAT10t58=null; 2300 Token INSTRUCTION_FORMAT10x59=null; 2301 Token INSTRUCTION_FORMAT10x_ODEX60=null; 2302 Token INSTRUCTION_FORMAT11x61=null; 2303 Token INSTRUCTION_FORMAT12x_OR_ID62=null; 2304 Token INSTRUCTION_FORMAT21c_FIELD63=null; 2305 Token INSTRUCTION_FORMAT21c_FIELD_ODEX64=null; 2306 Token INSTRUCTION_FORMAT21c_STRING65=null; 2307 Token INSTRUCTION_FORMAT21c_TYPE66=null; 2308 Token INSTRUCTION_FORMAT21t67=null; 2309 Token INSTRUCTION_FORMAT22c_FIELD68=null; 2310 Token INSTRUCTION_FORMAT22c_FIELD_ODEX69=null; 2311 Token INSTRUCTION_FORMAT22c_TYPE70=null; 2312 Token INSTRUCTION_FORMAT22cs_FIELD71=null; 2313 Token INSTRUCTION_FORMAT22s_OR_ID72=null; 2314 Token INSTRUCTION_FORMAT22t73=null; 2315 Token INSTRUCTION_FORMAT23x74=null; 2316 Token INSTRUCTION_FORMAT31i_OR_ID75=null; 2317 Token INSTRUCTION_FORMAT31t76=null; 2318 Token INSTRUCTION_FORMAT35c_METHOD77=null; 2319 Token INSTRUCTION_FORMAT35c_METHOD_ODEX78=null; 2320 Token INSTRUCTION_FORMAT35c_TYPE79=null; 2321 Token INSTRUCTION_FORMAT35mi_METHOD80=null; 2322 Token INSTRUCTION_FORMAT35ms_METHOD81=null; 2323 Token INSTRUCTION_FORMAT45cc_METHOD82=null; 2324 Token INSTRUCTION_FORMAT4rcc_METHOD83=null; 2325 Token INSTRUCTION_FORMAT51l84=null; 2326 ParserRuleReturnScope param_list_or_id54 =null; 2327 2328 CommonTree SIMPLE_NAME44_tree=null; 2329 CommonTree ACCESS_SPEC45_tree=null; 2330 CommonTree VERIFICATION_ERROR_TYPE46_tree=null; 2331 CommonTree POSITIVE_INTEGER_LITERAL47_tree=null; 2332 CommonTree NEGATIVE_INTEGER_LITERAL48_tree=null; 2333 CommonTree FLOAT_LITERAL_OR_ID49_tree=null; 2334 CommonTree DOUBLE_LITERAL_OR_ID50_tree=null; 2335 CommonTree BOOL_LITERAL51_tree=null; 2336 CommonTree NULL_LITERAL52_tree=null; 2337 CommonTree REGISTER53_tree=null; 2338 CommonTree PRIMITIVE_TYPE55_tree=null; 2339 CommonTree VOID_TYPE56_tree=null; 2340 CommonTree ANNOTATION_VISIBILITY57_tree=null; 2341 CommonTree INSTRUCTION_FORMAT10t58_tree=null; 2342 CommonTree INSTRUCTION_FORMAT10x59_tree=null; 2343 CommonTree INSTRUCTION_FORMAT10x_ODEX60_tree=null; 2344 CommonTree INSTRUCTION_FORMAT11x61_tree=null; 2345 CommonTree INSTRUCTION_FORMAT12x_OR_ID62_tree=null; 2346 CommonTree INSTRUCTION_FORMAT21c_FIELD63_tree=null; 2347 CommonTree INSTRUCTION_FORMAT21c_FIELD_ODEX64_tree=null; 2348 CommonTree INSTRUCTION_FORMAT21c_STRING65_tree=null; 2349 CommonTree INSTRUCTION_FORMAT21c_TYPE66_tree=null; 2350 CommonTree INSTRUCTION_FORMAT21t67_tree=null; 2351 CommonTree INSTRUCTION_FORMAT22c_FIELD68_tree=null; 2352 CommonTree INSTRUCTION_FORMAT22c_FIELD_ODEX69_tree=null; 2353 CommonTree INSTRUCTION_FORMAT22c_TYPE70_tree=null; 2354 CommonTree INSTRUCTION_FORMAT22cs_FIELD71_tree=null; 2355 CommonTree INSTRUCTION_FORMAT22s_OR_ID72_tree=null; 2356 CommonTree INSTRUCTION_FORMAT22t73_tree=null; 2357 CommonTree INSTRUCTION_FORMAT23x74_tree=null; 2358 CommonTree INSTRUCTION_FORMAT31i_OR_ID75_tree=null; 2359 CommonTree INSTRUCTION_FORMAT31t76_tree=null; 2360 CommonTree INSTRUCTION_FORMAT35c_METHOD77_tree=null; 2361 CommonTree INSTRUCTION_FORMAT35c_METHOD_ODEX78_tree=null; 2362 CommonTree INSTRUCTION_FORMAT35c_TYPE79_tree=null; 2363 CommonTree INSTRUCTION_FORMAT35mi_METHOD80_tree=null; 2364 CommonTree INSTRUCTION_FORMAT35ms_METHOD81_tree=null; 2365 CommonTree INSTRUCTION_FORMAT45cc_METHOD82_tree=null; 2366 CommonTree INSTRUCTION_FORMAT4rcc_METHOD83_tree=null; 2367 CommonTree INSTRUCTION_FORMAT51l84_tree=null; 2368 RewriteRuleTokenStream stream_ANNOTATION_VISIBILITY=new RewriteRuleTokenStream(adaptor,"token ANNOTATION_VISIBILITY"); 2369 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_TYPE"); 2370 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22t"); 2371 RewriteRuleTokenStream stream_VOID_TYPE=new RewriteRuleTokenStream(adaptor,"token VOID_TYPE"); 2372 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT10t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT10t"); 2373 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35mi_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35mi_METHOD"); 2374 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22s_OR_ID=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22s_OR_ID"); 2375 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22cs_FIELD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22cs_FIELD"); 2376 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT12x_OR_ID=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT12x_OR_ID"); 2377 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35ms_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35ms_METHOD"); 2378 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35c_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35c_METHOD"); 2379 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT45cc_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT45cc_METHOD"); 2380 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35c_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35c_TYPE"); 2381 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT10x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT10x"); 2382 RewriteRuleTokenStream stream_FLOAT_LITERAL_OR_ID=new RewriteRuleTokenStream(adaptor,"token FLOAT_LITERAL_OR_ID"); 2383 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_TYPE"); 2384 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_STRING=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_STRING"); 2385 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35c_METHOD_ODEX=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35c_METHOD_ODEX"); 2386 RewriteRuleTokenStream stream_NEGATIVE_INTEGER_LITERAL=new RewriteRuleTokenStream(adaptor,"token NEGATIVE_INTEGER_LITERAL"); 2387 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 2388 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_FIELD_ODEX=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_FIELD_ODEX"); 2389 RewriteRuleTokenStream stream_DOUBLE_LITERAL_OR_ID=new RewriteRuleTokenStream(adaptor,"token DOUBLE_LITERAL_OR_ID"); 2390 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT31i_OR_ID=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT31i_OR_ID"); 2391 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21t"); 2392 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT31t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT31t"); 2393 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT23x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT23x"); 2394 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT51l=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT51l"); 2395 RewriteRuleTokenStream stream_POSITIVE_INTEGER_LITERAL=new RewriteRuleTokenStream(adaptor,"token POSITIVE_INTEGER_LITERAL"); 2396 RewriteRuleTokenStream stream_BOOL_LITERAL=new RewriteRuleTokenStream(adaptor,"token BOOL_LITERAL"); 2397 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT10x_ODEX=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT10x_ODEX"); 2398 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_FIELD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_FIELD"); 2399 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_FIELD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_FIELD"); 2400 RewriteRuleTokenStream stream_VERIFICATION_ERROR_TYPE=new RewriteRuleTokenStream(adaptor,"token VERIFICATION_ERROR_TYPE"); 2401 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT11x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT11x"); 2402 RewriteRuleTokenStream stream_ACCESS_SPEC=new RewriteRuleTokenStream(adaptor,"token ACCESS_SPEC"); 2403 RewriteRuleTokenStream stream_NULL_LITERAL=new RewriteRuleTokenStream(adaptor,"token NULL_LITERAL"); 2404 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT4rcc_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT4rcc_METHOD"); 2405 RewriteRuleTokenStream stream_PRIMITIVE_TYPE=new RewriteRuleTokenStream(adaptor,"token PRIMITIVE_TYPE"); 2406 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_FIELD_ODEX=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_FIELD_ODEX"); 2407 RewriteRuleSubtreeStream stream_param_list_or_id=new RewriteRuleSubtreeStream(adaptor,"rule param_list_or_id"); 2408 2409 try { 2410 // smaliParser.g:538:3: ( SIMPLE_NAME | ACCESS_SPEC -> SIMPLE_NAME[$ACCESS_SPEC] | VERIFICATION_ERROR_TYPE -> SIMPLE_NAME[$VERIFICATION_ERROR_TYPE] | POSITIVE_INTEGER_LITERAL -> SIMPLE_NAME[$POSITIVE_INTEGER_LITERAL] | NEGATIVE_INTEGER_LITERAL -> SIMPLE_NAME[$NEGATIVE_INTEGER_LITERAL] | FLOAT_LITERAL_OR_ID -> SIMPLE_NAME[$FLOAT_LITERAL_OR_ID] | DOUBLE_LITERAL_OR_ID -> SIMPLE_NAME[$DOUBLE_LITERAL_OR_ID] | BOOL_LITERAL -> SIMPLE_NAME[$BOOL_LITERAL] | NULL_LITERAL -> SIMPLE_NAME[$NULL_LITERAL] | REGISTER -> SIMPLE_NAME[$REGISTER] | param_list_or_id ->| PRIMITIVE_TYPE -> SIMPLE_NAME[$PRIMITIVE_TYPE] | VOID_TYPE -> SIMPLE_NAME[$VOID_TYPE] | ANNOTATION_VISIBILITY -> SIMPLE_NAME[$ANNOTATION_VISIBILITY] | INSTRUCTION_FORMAT10t -> SIMPLE_NAME[$INSTRUCTION_FORMAT10t] | INSTRUCTION_FORMAT10x -> SIMPLE_NAME[$INSTRUCTION_FORMAT10x] | INSTRUCTION_FORMAT10x_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT10x_ODEX] | INSTRUCTION_FORMAT11x -> SIMPLE_NAME[$INSTRUCTION_FORMAT11x] | INSTRUCTION_FORMAT12x_OR_ID -> SIMPLE_NAME[$INSTRUCTION_FORMAT12x_OR_ID] | INSTRUCTION_FORMAT21c_FIELD -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_FIELD] | INSTRUCTION_FORMAT21c_FIELD_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_FIELD_ODEX] | INSTRUCTION_FORMAT21c_STRING -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_STRING] | INSTRUCTION_FORMAT21c_TYPE -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_TYPE] | INSTRUCTION_FORMAT21t -> SIMPLE_NAME[$INSTRUCTION_FORMAT21t] | INSTRUCTION_FORMAT22c_FIELD -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_FIELD] | INSTRUCTION_FORMAT22c_FIELD_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_FIELD_ODEX] | INSTRUCTION_FORMAT22c_TYPE -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_TYPE] | INSTRUCTION_FORMAT22cs_FIELD -> SIMPLE_NAME[$INSTRUCTION_FORMAT22cs_FIELD] | INSTRUCTION_FORMAT22s_OR_ID -> SIMPLE_NAME[$INSTRUCTION_FORMAT22s_OR_ID] | INSTRUCTION_FORMAT22t -> SIMPLE_NAME[$INSTRUCTION_FORMAT22t] | INSTRUCTION_FORMAT23x -> SIMPLE_NAME[$INSTRUCTION_FORMAT23x] | INSTRUCTION_FORMAT31i_OR_ID -> SIMPLE_NAME[$INSTRUCTION_FORMAT31i_OR_ID] | INSTRUCTION_FORMAT31t -> SIMPLE_NAME[$INSTRUCTION_FORMAT31t] | INSTRUCTION_FORMAT35c_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_METHOD] | INSTRUCTION_FORMAT35c_METHOD_ODEX -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_METHOD_ODEX] | INSTRUCTION_FORMAT35c_TYPE -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_TYPE] | INSTRUCTION_FORMAT35mi_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT35mi_METHOD] | INSTRUCTION_FORMAT35ms_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT35ms_METHOD] | INSTRUCTION_FORMAT45cc_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT45cc_METHOD] | INSTRUCTION_FORMAT4rcc_METHOD -> SIMPLE_NAME[$INSTRUCTION_FORMAT4rcc_METHOD] | INSTRUCTION_FORMAT51l -> SIMPLE_NAME[$INSTRUCTION_FORMAT51l] ) 2411 int alt10=41; 2412 switch ( input.LA(1) ) { 2413 case SIMPLE_NAME: 2414 { 2415 alt10=1; 2416 } 2417 break; 2418 case ACCESS_SPEC: 2419 { 2420 alt10=2; 2421 } 2422 break; 2423 case VERIFICATION_ERROR_TYPE: 2424 { 2425 alt10=3; 2426 } 2427 break; 2428 case POSITIVE_INTEGER_LITERAL: 2429 { 2430 alt10=4; 2431 } 2432 break; 2433 case NEGATIVE_INTEGER_LITERAL: 2434 { 2435 alt10=5; 2436 } 2437 break; 2438 case FLOAT_LITERAL_OR_ID: 2439 { 2440 alt10=6; 2441 } 2442 break; 2443 case DOUBLE_LITERAL_OR_ID: 2444 { 2445 alt10=7; 2446 } 2447 break; 2448 case BOOL_LITERAL: 2449 { 2450 alt10=8; 2451 } 2452 break; 2453 case NULL_LITERAL: 2454 { 2455 alt10=9; 2456 } 2457 break; 2458 case REGISTER: 2459 { 2460 alt10=10; 2461 } 2462 break; 2463 case PARAM_LIST_OR_ID_PRIMITIVE_TYPE: 2464 { 2465 alt10=11; 2466 } 2467 break; 2468 case PRIMITIVE_TYPE: 2469 { 2470 alt10=12; 2471 } 2472 break; 2473 case VOID_TYPE: 2474 { 2475 alt10=13; 2476 } 2477 break; 2478 case ANNOTATION_VISIBILITY: 2479 { 2480 alt10=14; 2481 } 2482 break; 2483 case INSTRUCTION_FORMAT10t: 2484 { 2485 alt10=15; 2486 } 2487 break; 2488 case INSTRUCTION_FORMAT10x: 2489 { 2490 alt10=16; 2491 } 2492 break; 2493 case INSTRUCTION_FORMAT10x_ODEX: 2494 { 2495 alt10=17; 2496 } 2497 break; 2498 case INSTRUCTION_FORMAT11x: 2499 { 2500 alt10=18; 2501 } 2502 break; 2503 case INSTRUCTION_FORMAT12x_OR_ID: 2504 { 2505 alt10=19; 2506 } 2507 break; 2508 case INSTRUCTION_FORMAT21c_FIELD: 2509 { 2510 alt10=20; 2511 } 2512 break; 2513 case INSTRUCTION_FORMAT21c_FIELD_ODEX: 2514 { 2515 alt10=21; 2516 } 2517 break; 2518 case INSTRUCTION_FORMAT21c_STRING: 2519 { 2520 alt10=22; 2521 } 2522 break; 2523 case INSTRUCTION_FORMAT21c_TYPE: 2524 { 2525 alt10=23; 2526 } 2527 break; 2528 case INSTRUCTION_FORMAT21t: 2529 { 2530 alt10=24; 2531 } 2532 break; 2533 case INSTRUCTION_FORMAT22c_FIELD: 2534 { 2535 alt10=25; 2536 } 2537 break; 2538 case INSTRUCTION_FORMAT22c_FIELD_ODEX: 2539 { 2540 alt10=26; 2541 } 2542 break; 2543 case INSTRUCTION_FORMAT22c_TYPE: 2544 { 2545 alt10=27; 2546 } 2547 break; 2548 case INSTRUCTION_FORMAT22cs_FIELD: 2549 { 2550 alt10=28; 2551 } 2552 break; 2553 case INSTRUCTION_FORMAT22s_OR_ID: 2554 { 2555 alt10=29; 2556 } 2557 break; 2558 case INSTRUCTION_FORMAT22t: 2559 { 2560 alt10=30; 2561 } 2562 break; 2563 case INSTRUCTION_FORMAT23x: 2564 { 2565 alt10=31; 2566 } 2567 break; 2568 case INSTRUCTION_FORMAT31i_OR_ID: 2569 { 2570 alt10=32; 2571 } 2572 break; 2573 case INSTRUCTION_FORMAT31t: 2574 { 2575 alt10=33; 2576 } 2577 break; 2578 case INSTRUCTION_FORMAT35c_METHOD: 2579 { 2580 alt10=34; 2581 } 2582 break; 2583 case INSTRUCTION_FORMAT35c_METHOD_ODEX: 2584 { 2585 alt10=35; 2586 } 2587 break; 2588 case INSTRUCTION_FORMAT35c_TYPE: 2589 { 2590 alt10=36; 2591 } 2592 break; 2593 case INSTRUCTION_FORMAT35mi_METHOD: 2594 { 2595 alt10=37; 2596 } 2597 break; 2598 case INSTRUCTION_FORMAT35ms_METHOD: 2599 { 2600 alt10=38; 2601 } 2602 break; 2603 case INSTRUCTION_FORMAT45cc_METHOD: 2604 { 2605 alt10=39; 2606 } 2607 break; 2608 case INSTRUCTION_FORMAT4rcc_METHOD: 2609 { 2610 alt10=40; 2611 } 2612 break; 2613 case INSTRUCTION_FORMAT51l: 2614 { 2615 alt10=41; 2616 } 2617 break; 2618 default: 2619 NoViableAltException nvae = 2620 new NoViableAltException("", 10, 0, input); 2621 throw nvae; 2622 } 2623 switch (alt10) { 2624 case 1 : 2625 // smaliParser.g:538:5: SIMPLE_NAME 2626 { 2627 root_0 = (CommonTree)adaptor.nil(); 2628 2629 2630 SIMPLE_NAME44=(Token)match(input,SIMPLE_NAME,FOLLOW_SIMPLE_NAME_in_simple_name1777); 2631 SIMPLE_NAME44_tree = (CommonTree)adaptor.create(SIMPLE_NAME44); 2632 adaptor.addChild(root_0, SIMPLE_NAME44_tree); 2633 2634 } 2635 break; 2636 case 2 : 2637 // smaliParser.g:539:5: ACCESS_SPEC 2638 { 2639 ACCESS_SPEC45=(Token)match(input,ACCESS_SPEC,FOLLOW_ACCESS_SPEC_in_simple_name1783); 2640 stream_ACCESS_SPEC.add(ACCESS_SPEC45); 2641 2642 // AST REWRITE 2643 // elements: 2644 // token labels: 2645 // rule labels: retval 2646 // token list labels: 2647 // rule list labels: 2648 // wildcard labels: 2649 retval.tree = root_0; 2650 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2651 2652 root_0 = (CommonTree)adaptor.nil(); 2653 // 539:17: -> SIMPLE_NAME[$ACCESS_SPEC] 2654 { 2655 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, ACCESS_SPEC45)); 2656 } 2657 2658 2659 retval.tree = root_0; 2660 2661 } 2662 break; 2663 case 3 : 2664 // smaliParser.g:540:5: VERIFICATION_ERROR_TYPE 2665 { 2666 VERIFICATION_ERROR_TYPE46=(Token)match(input,VERIFICATION_ERROR_TYPE,FOLLOW_VERIFICATION_ERROR_TYPE_in_simple_name1794); 2667 stream_VERIFICATION_ERROR_TYPE.add(VERIFICATION_ERROR_TYPE46); 2668 2669 // AST REWRITE 2670 // elements: 2671 // token labels: 2672 // rule labels: retval 2673 // token list labels: 2674 // rule list labels: 2675 // wildcard labels: 2676 retval.tree = root_0; 2677 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2678 2679 root_0 = (CommonTree)adaptor.nil(); 2680 // 540:29: -> SIMPLE_NAME[$VERIFICATION_ERROR_TYPE] 2681 { 2682 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, VERIFICATION_ERROR_TYPE46)); 2683 } 2684 2685 2686 retval.tree = root_0; 2687 2688 } 2689 break; 2690 case 4 : 2691 // smaliParser.g:541:5: POSITIVE_INTEGER_LITERAL 2692 { 2693 POSITIVE_INTEGER_LITERAL47=(Token)match(input,POSITIVE_INTEGER_LITERAL,FOLLOW_POSITIVE_INTEGER_LITERAL_in_simple_name1805); 2694 stream_POSITIVE_INTEGER_LITERAL.add(POSITIVE_INTEGER_LITERAL47); 2695 2696 // AST REWRITE 2697 // elements: 2698 // token labels: 2699 // rule labels: retval 2700 // token list labels: 2701 // rule list labels: 2702 // wildcard labels: 2703 retval.tree = root_0; 2704 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2705 2706 root_0 = (CommonTree)adaptor.nil(); 2707 // 541:30: -> SIMPLE_NAME[$POSITIVE_INTEGER_LITERAL] 2708 { 2709 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, POSITIVE_INTEGER_LITERAL47)); 2710 } 2711 2712 2713 retval.tree = root_0; 2714 2715 } 2716 break; 2717 case 5 : 2718 // smaliParser.g:542:5: NEGATIVE_INTEGER_LITERAL 2719 { 2720 NEGATIVE_INTEGER_LITERAL48=(Token)match(input,NEGATIVE_INTEGER_LITERAL,FOLLOW_NEGATIVE_INTEGER_LITERAL_in_simple_name1816); 2721 stream_NEGATIVE_INTEGER_LITERAL.add(NEGATIVE_INTEGER_LITERAL48); 2722 2723 // AST REWRITE 2724 // elements: 2725 // token labels: 2726 // rule labels: retval 2727 // token list labels: 2728 // rule list labels: 2729 // wildcard labels: 2730 retval.tree = root_0; 2731 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2732 2733 root_0 = (CommonTree)adaptor.nil(); 2734 // 542:30: -> SIMPLE_NAME[$NEGATIVE_INTEGER_LITERAL] 2735 { 2736 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, NEGATIVE_INTEGER_LITERAL48)); 2737 } 2738 2739 2740 retval.tree = root_0; 2741 2742 } 2743 break; 2744 case 6 : 2745 // smaliParser.g:543:5: FLOAT_LITERAL_OR_ID 2746 { 2747 FLOAT_LITERAL_OR_ID49=(Token)match(input,FLOAT_LITERAL_OR_ID,FOLLOW_FLOAT_LITERAL_OR_ID_in_simple_name1827); 2748 stream_FLOAT_LITERAL_OR_ID.add(FLOAT_LITERAL_OR_ID49); 2749 2750 // AST REWRITE 2751 // elements: 2752 // token labels: 2753 // rule labels: retval 2754 // token list labels: 2755 // rule list labels: 2756 // wildcard labels: 2757 retval.tree = root_0; 2758 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2759 2760 root_0 = (CommonTree)adaptor.nil(); 2761 // 543:25: -> SIMPLE_NAME[$FLOAT_LITERAL_OR_ID] 2762 { 2763 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, FLOAT_LITERAL_OR_ID49)); 2764 } 2765 2766 2767 retval.tree = root_0; 2768 2769 } 2770 break; 2771 case 7 : 2772 // smaliParser.g:544:5: DOUBLE_LITERAL_OR_ID 2773 { 2774 DOUBLE_LITERAL_OR_ID50=(Token)match(input,DOUBLE_LITERAL_OR_ID,FOLLOW_DOUBLE_LITERAL_OR_ID_in_simple_name1838); 2775 stream_DOUBLE_LITERAL_OR_ID.add(DOUBLE_LITERAL_OR_ID50); 2776 2777 // AST REWRITE 2778 // elements: 2779 // token labels: 2780 // rule labels: retval 2781 // token list labels: 2782 // rule list labels: 2783 // wildcard labels: 2784 retval.tree = root_0; 2785 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2786 2787 root_0 = (CommonTree)adaptor.nil(); 2788 // 544:26: -> SIMPLE_NAME[$DOUBLE_LITERAL_OR_ID] 2789 { 2790 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, DOUBLE_LITERAL_OR_ID50)); 2791 } 2792 2793 2794 retval.tree = root_0; 2795 2796 } 2797 break; 2798 case 8 : 2799 // smaliParser.g:545:5: BOOL_LITERAL 2800 { 2801 BOOL_LITERAL51=(Token)match(input,BOOL_LITERAL,FOLLOW_BOOL_LITERAL_in_simple_name1849); 2802 stream_BOOL_LITERAL.add(BOOL_LITERAL51); 2803 2804 // AST REWRITE 2805 // elements: 2806 // token labels: 2807 // rule labels: retval 2808 // token list labels: 2809 // rule list labels: 2810 // wildcard labels: 2811 retval.tree = root_0; 2812 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2813 2814 root_0 = (CommonTree)adaptor.nil(); 2815 // 545:18: -> SIMPLE_NAME[$BOOL_LITERAL] 2816 { 2817 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, BOOL_LITERAL51)); 2818 } 2819 2820 2821 retval.tree = root_0; 2822 2823 } 2824 break; 2825 case 9 : 2826 // smaliParser.g:546:5: NULL_LITERAL 2827 { 2828 NULL_LITERAL52=(Token)match(input,NULL_LITERAL,FOLLOW_NULL_LITERAL_in_simple_name1860); 2829 stream_NULL_LITERAL.add(NULL_LITERAL52); 2830 2831 // AST REWRITE 2832 // elements: 2833 // token labels: 2834 // rule labels: retval 2835 // token list labels: 2836 // rule list labels: 2837 // wildcard labels: 2838 retval.tree = root_0; 2839 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2840 2841 root_0 = (CommonTree)adaptor.nil(); 2842 // 546:18: -> SIMPLE_NAME[$NULL_LITERAL] 2843 { 2844 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, NULL_LITERAL52)); 2845 } 2846 2847 2848 retval.tree = root_0; 2849 2850 } 2851 break; 2852 case 10 : 2853 // smaliParser.g:547:5: REGISTER 2854 { 2855 REGISTER53=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_simple_name1871); 2856 stream_REGISTER.add(REGISTER53); 2857 2858 // AST REWRITE 2859 // elements: 2860 // token labels: 2861 // rule labels: retval 2862 // token list labels: 2863 // rule list labels: 2864 // wildcard labels: 2865 retval.tree = root_0; 2866 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2867 2868 root_0 = (CommonTree)adaptor.nil(); 2869 // 547:14: -> SIMPLE_NAME[$REGISTER] 2870 { 2871 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, REGISTER53)); 2872 } 2873 2874 2875 retval.tree = root_0; 2876 2877 } 2878 break; 2879 case 11 : 2880 // smaliParser.g:548:5: param_list_or_id 2881 { 2882 pushFollow(FOLLOW_param_list_or_id_in_simple_name1882); 2883 param_list_or_id54=param_list_or_id(); 2884 state._fsp--; 2885 2886 stream_param_list_or_id.add(param_list_or_id54.getTree()); 2887 // AST REWRITE 2888 // elements: 2889 // token labels: 2890 // rule labels: retval 2891 // token list labels: 2892 // rule list labels: 2893 // wildcard labels: 2894 retval.tree = root_0; 2895 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2896 2897 root_0 = (CommonTree)adaptor.nil(); 2898 // 548:22: -> 2899 { 2900 adaptor.addChild(root_0, adaptor.create(SIMPLE_NAME, (param_list_or_id54!=null?input.toString(param_list_or_id54.start,param_list_or_id54.stop):null)) ); 2901 } 2902 2903 2904 retval.tree = root_0; 2905 2906 } 2907 break; 2908 case 12 : 2909 // smaliParser.g:549:5: PRIMITIVE_TYPE 2910 { 2911 PRIMITIVE_TYPE55=(Token)match(input,PRIMITIVE_TYPE,FOLLOW_PRIMITIVE_TYPE_in_simple_name1892); 2912 stream_PRIMITIVE_TYPE.add(PRIMITIVE_TYPE55); 2913 2914 // AST REWRITE 2915 // elements: 2916 // token labels: 2917 // rule labels: retval 2918 // token list labels: 2919 // rule list labels: 2920 // wildcard labels: 2921 retval.tree = root_0; 2922 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2923 2924 root_0 = (CommonTree)adaptor.nil(); 2925 // 549:20: -> SIMPLE_NAME[$PRIMITIVE_TYPE] 2926 { 2927 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, PRIMITIVE_TYPE55)); 2928 } 2929 2930 2931 retval.tree = root_0; 2932 2933 } 2934 break; 2935 case 13 : 2936 // smaliParser.g:550:5: VOID_TYPE 2937 { 2938 VOID_TYPE56=(Token)match(input,VOID_TYPE,FOLLOW_VOID_TYPE_in_simple_name1903); 2939 stream_VOID_TYPE.add(VOID_TYPE56); 2940 2941 // AST REWRITE 2942 // elements: 2943 // token labels: 2944 // rule labels: retval 2945 // token list labels: 2946 // rule list labels: 2947 // wildcard labels: 2948 retval.tree = root_0; 2949 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2950 2951 root_0 = (CommonTree)adaptor.nil(); 2952 // 550:15: -> SIMPLE_NAME[$VOID_TYPE] 2953 { 2954 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, VOID_TYPE56)); 2955 } 2956 2957 2958 retval.tree = root_0; 2959 2960 } 2961 break; 2962 case 14 : 2963 // smaliParser.g:551:5: ANNOTATION_VISIBILITY 2964 { 2965 ANNOTATION_VISIBILITY57=(Token)match(input,ANNOTATION_VISIBILITY,FOLLOW_ANNOTATION_VISIBILITY_in_simple_name1914); 2966 stream_ANNOTATION_VISIBILITY.add(ANNOTATION_VISIBILITY57); 2967 2968 // AST REWRITE 2969 // elements: 2970 // token labels: 2971 // rule labels: retval 2972 // token list labels: 2973 // rule list labels: 2974 // wildcard labels: 2975 retval.tree = root_0; 2976 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2977 2978 root_0 = (CommonTree)adaptor.nil(); 2979 // 551:27: -> SIMPLE_NAME[$ANNOTATION_VISIBILITY] 2980 { 2981 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, ANNOTATION_VISIBILITY57)); 2982 } 2983 2984 2985 retval.tree = root_0; 2986 2987 } 2988 break; 2989 case 15 : 2990 // smaliParser.g:552:5: INSTRUCTION_FORMAT10t 2991 { 2992 INSTRUCTION_FORMAT10t58=(Token)match(input,INSTRUCTION_FORMAT10t,FOLLOW_INSTRUCTION_FORMAT10t_in_simple_name1925); 2993 stream_INSTRUCTION_FORMAT10t.add(INSTRUCTION_FORMAT10t58); 2994 2995 // AST REWRITE 2996 // elements: 2997 // token labels: 2998 // rule labels: retval 2999 // token list labels: 3000 // rule list labels: 3001 // wildcard labels: 3002 retval.tree = root_0; 3003 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3004 3005 root_0 = (CommonTree)adaptor.nil(); 3006 // 552:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT10t] 3007 { 3008 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT10t58)); 3009 } 3010 3011 3012 retval.tree = root_0; 3013 3014 } 3015 break; 3016 case 16 : 3017 // smaliParser.g:553:5: INSTRUCTION_FORMAT10x 3018 { 3019 INSTRUCTION_FORMAT10x59=(Token)match(input,INSTRUCTION_FORMAT10x,FOLLOW_INSTRUCTION_FORMAT10x_in_simple_name1936); 3020 stream_INSTRUCTION_FORMAT10x.add(INSTRUCTION_FORMAT10x59); 3021 3022 // AST REWRITE 3023 // elements: 3024 // token labels: 3025 // rule labels: retval 3026 // token list labels: 3027 // rule list labels: 3028 // wildcard labels: 3029 retval.tree = root_0; 3030 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3031 3032 root_0 = (CommonTree)adaptor.nil(); 3033 // 553:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT10x] 3034 { 3035 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT10x59)); 3036 } 3037 3038 3039 retval.tree = root_0; 3040 3041 } 3042 break; 3043 case 17 : 3044 // smaliParser.g:554:5: INSTRUCTION_FORMAT10x_ODEX 3045 { 3046 INSTRUCTION_FORMAT10x_ODEX60=(Token)match(input,INSTRUCTION_FORMAT10x_ODEX,FOLLOW_INSTRUCTION_FORMAT10x_ODEX_in_simple_name1947); 3047 stream_INSTRUCTION_FORMAT10x_ODEX.add(INSTRUCTION_FORMAT10x_ODEX60); 3048 3049 // AST REWRITE 3050 // elements: 3051 // token labels: 3052 // rule labels: retval 3053 // token list labels: 3054 // rule list labels: 3055 // wildcard labels: 3056 retval.tree = root_0; 3057 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3058 3059 root_0 = (CommonTree)adaptor.nil(); 3060 // 554:32: -> SIMPLE_NAME[$INSTRUCTION_FORMAT10x_ODEX] 3061 { 3062 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT10x_ODEX60)); 3063 } 3064 3065 3066 retval.tree = root_0; 3067 3068 } 3069 break; 3070 case 18 : 3071 // smaliParser.g:555:5: INSTRUCTION_FORMAT11x 3072 { 3073 INSTRUCTION_FORMAT11x61=(Token)match(input,INSTRUCTION_FORMAT11x,FOLLOW_INSTRUCTION_FORMAT11x_in_simple_name1958); 3074 stream_INSTRUCTION_FORMAT11x.add(INSTRUCTION_FORMAT11x61); 3075 3076 // AST REWRITE 3077 // elements: 3078 // token labels: 3079 // rule labels: retval 3080 // token list labels: 3081 // rule list labels: 3082 // wildcard labels: 3083 retval.tree = root_0; 3084 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3085 3086 root_0 = (CommonTree)adaptor.nil(); 3087 // 555:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT11x] 3088 { 3089 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT11x61)); 3090 } 3091 3092 3093 retval.tree = root_0; 3094 3095 } 3096 break; 3097 case 19 : 3098 // smaliParser.g:556:5: INSTRUCTION_FORMAT12x_OR_ID 3099 { 3100 INSTRUCTION_FORMAT12x_OR_ID62=(Token)match(input,INSTRUCTION_FORMAT12x_OR_ID,FOLLOW_INSTRUCTION_FORMAT12x_OR_ID_in_simple_name1969); 3101 stream_INSTRUCTION_FORMAT12x_OR_ID.add(INSTRUCTION_FORMAT12x_OR_ID62); 3102 3103 // AST REWRITE 3104 // elements: 3105 // token labels: 3106 // rule labels: retval 3107 // token list labels: 3108 // rule list labels: 3109 // wildcard labels: 3110 retval.tree = root_0; 3111 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3112 3113 root_0 = (CommonTree)adaptor.nil(); 3114 // 556:33: -> SIMPLE_NAME[$INSTRUCTION_FORMAT12x_OR_ID] 3115 { 3116 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT12x_OR_ID62)); 3117 } 3118 3119 3120 retval.tree = root_0; 3121 3122 } 3123 break; 3124 case 20 : 3125 // smaliParser.g:557:5: INSTRUCTION_FORMAT21c_FIELD 3126 { 3127 INSTRUCTION_FORMAT21c_FIELD63=(Token)match(input,INSTRUCTION_FORMAT21c_FIELD,FOLLOW_INSTRUCTION_FORMAT21c_FIELD_in_simple_name1980); 3128 stream_INSTRUCTION_FORMAT21c_FIELD.add(INSTRUCTION_FORMAT21c_FIELD63); 3129 3130 // AST REWRITE 3131 // elements: 3132 // token labels: 3133 // rule labels: retval 3134 // token list labels: 3135 // rule list labels: 3136 // wildcard labels: 3137 retval.tree = root_0; 3138 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3139 3140 root_0 = (CommonTree)adaptor.nil(); 3141 // 557:33: -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_FIELD] 3142 { 3143 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT21c_FIELD63)); 3144 } 3145 3146 3147 retval.tree = root_0; 3148 3149 } 3150 break; 3151 case 21 : 3152 // smaliParser.g:558:5: INSTRUCTION_FORMAT21c_FIELD_ODEX 3153 { 3154 INSTRUCTION_FORMAT21c_FIELD_ODEX64=(Token)match(input,INSTRUCTION_FORMAT21c_FIELD_ODEX,FOLLOW_INSTRUCTION_FORMAT21c_FIELD_ODEX_in_simple_name1991); 3155 stream_INSTRUCTION_FORMAT21c_FIELD_ODEX.add(INSTRUCTION_FORMAT21c_FIELD_ODEX64); 3156 3157 // AST REWRITE 3158 // elements: 3159 // token labels: 3160 // rule labels: retval 3161 // token list labels: 3162 // rule list labels: 3163 // wildcard labels: 3164 retval.tree = root_0; 3165 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3166 3167 root_0 = (CommonTree)adaptor.nil(); 3168 // 558:38: -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_FIELD_ODEX] 3169 { 3170 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT21c_FIELD_ODEX64)); 3171 } 3172 3173 3174 retval.tree = root_0; 3175 3176 } 3177 break; 3178 case 22 : 3179 // smaliParser.g:559:5: INSTRUCTION_FORMAT21c_STRING 3180 { 3181 INSTRUCTION_FORMAT21c_STRING65=(Token)match(input,INSTRUCTION_FORMAT21c_STRING,FOLLOW_INSTRUCTION_FORMAT21c_STRING_in_simple_name2002); 3182 stream_INSTRUCTION_FORMAT21c_STRING.add(INSTRUCTION_FORMAT21c_STRING65); 3183 3184 // AST REWRITE 3185 // elements: 3186 // token labels: 3187 // rule labels: retval 3188 // token list labels: 3189 // rule list labels: 3190 // wildcard labels: 3191 retval.tree = root_0; 3192 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3193 3194 root_0 = (CommonTree)adaptor.nil(); 3195 // 559:34: -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_STRING] 3196 { 3197 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT21c_STRING65)); 3198 } 3199 3200 3201 retval.tree = root_0; 3202 3203 } 3204 break; 3205 case 23 : 3206 // smaliParser.g:560:5: INSTRUCTION_FORMAT21c_TYPE 3207 { 3208 INSTRUCTION_FORMAT21c_TYPE66=(Token)match(input,INSTRUCTION_FORMAT21c_TYPE,FOLLOW_INSTRUCTION_FORMAT21c_TYPE_in_simple_name2013); 3209 stream_INSTRUCTION_FORMAT21c_TYPE.add(INSTRUCTION_FORMAT21c_TYPE66); 3210 3211 // AST REWRITE 3212 // elements: 3213 // token labels: 3214 // rule labels: retval 3215 // token list labels: 3216 // rule list labels: 3217 // wildcard labels: 3218 retval.tree = root_0; 3219 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3220 3221 root_0 = (CommonTree)adaptor.nil(); 3222 // 560:32: -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_TYPE] 3223 { 3224 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT21c_TYPE66)); 3225 } 3226 3227 3228 retval.tree = root_0; 3229 3230 } 3231 break; 3232 case 24 : 3233 // smaliParser.g:561:5: INSTRUCTION_FORMAT21t 3234 { 3235 INSTRUCTION_FORMAT21t67=(Token)match(input,INSTRUCTION_FORMAT21t,FOLLOW_INSTRUCTION_FORMAT21t_in_simple_name2024); 3236 stream_INSTRUCTION_FORMAT21t.add(INSTRUCTION_FORMAT21t67); 3237 3238 // AST REWRITE 3239 // elements: 3240 // token labels: 3241 // rule labels: retval 3242 // token list labels: 3243 // rule list labels: 3244 // wildcard labels: 3245 retval.tree = root_0; 3246 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3247 3248 root_0 = (CommonTree)adaptor.nil(); 3249 // 561:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT21t] 3250 { 3251 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT21t67)); 3252 } 3253 3254 3255 retval.tree = root_0; 3256 3257 } 3258 break; 3259 case 25 : 3260 // smaliParser.g:562:5: INSTRUCTION_FORMAT22c_FIELD 3261 { 3262 INSTRUCTION_FORMAT22c_FIELD68=(Token)match(input,INSTRUCTION_FORMAT22c_FIELD,FOLLOW_INSTRUCTION_FORMAT22c_FIELD_in_simple_name2035); 3263 stream_INSTRUCTION_FORMAT22c_FIELD.add(INSTRUCTION_FORMAT22c_FIELD68); 3264 3265 // AST REWRITE 3266 // elements: 3267 // token labels: 3268 // rule labels: retval 3269 // token list labels: 3270 // rule list labels: 3271 // wildcard labels: 3272 retval.tree = root_0; 3273 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3274 3275 root_0 = (CommonTree)adaptor.nil(); 3276 // 562:33: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_FIELD] 3277 { 3278 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22c_FIELD68)); 3279 } 3280 3281 3282 retval.tree = root_0; 3283 3284 } 3285 break; 3286 case 26 : 3287 // smaliParser.g:563:5: INSTRUCTION_FORMAT22c_FIELD_ODEX 3288 { 3289 INSTRUCTION_FORMAT22c_FIELD_ODEX69=(Token)match(input,INSTRUCTION_FORMAT22c_FIELD_ODEX,FOLLOW_INSTRUCTION_FORMAT22c_FIELD_ODEX_in_simple_name2046); 3290 stream_INSTRUCTION_FORMAT22c_FIELD_ODEX.add(INSTRUCTION_FORMAT22c_FIELD_ODEX69); 3291 3292 // AST REWRITE 3293 // elements: 3294 // token labels: 3295 // rule labels: retval 3296 // token list labels: 3297 // rule list labels: 3298 // wildcard labels: 3299 retval.tree = root_0; 3300 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3301 3302 root_0 = (CommonTree)adaptor.nil(); 3303 // 563:38: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_FIELD_ODEX] 3304 { 3305 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22c_FIELD_ODEX69)); 3306 } 3307 3308 3309 retval.tree = root_0; 3310 3311 } 3312 break; 3313 case 27 : 3314 // smaliParser.g:564:5: INSTRUCTION_FORMAT22c_TYPE 3315 { 3316 INSTRUCTION_FORMAT22c_TYPE70=(Token)match(input,INSTRUCTION_FORMAT22c_TYPE,FOLLOW_INSTRUCTION_FORMAT22c_TYPE_in_simple_name2057); 3317 stream_INSTRUCTION_FORMAT22c_TYPE.add(INSTRUCTION_FORMAT22c_TYPE70); 3318 3319 // AST REWRITE 3320 // elements: 3321 // token labels: 3322 // rule labels: retval 3323 // token list labels: 3324 // rule list labels: 3325 // wildcard labels: 3326 retval.tree = root_0; 3327 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3328 3329 root_0 = (CommonTree)adaptor.nil(); 3330 // 564:32: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_TYPE] 3331 { 3332 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22c_TYPE70)); 3333 } 3334 3335 3336 retval.tree = root_0; 3337 3338 } 3339 break; 3340 case 28 : 3341 // smaliParser.g:565:5: INSTRUCTION_FORMAT22cs_FIELD 3342 { 3343 INSTRUCTION_FORMAT22cs_FIELD71=(Token)match(input,INSTRUCTION_FORMAT22cs_FIELD,FOLLOW_INSTRUCTION_FORMAT22cs_FIELD_in_simple_name2068); 3344 stream_INSTRUCTION_FORMAT22cs_FIELD.add(INSTRUCTION_FORMAT22cs_FIELD71); 3345 3346 // AST REWRITE 3347 // elements: 3348 // token labels: 3349 // rule labels: retval 3350 // token list labels: 3351 // rule list labels: 3352 // wildcard labels: 3353 retval.tree = root_0; 3354 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3355 3356 root_0 = (CommonTree)adaptor.nil(); 3357 // 565:34: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22cs_FIELD] 3358 { 3359 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22cs_FIELD71)); 3360 } 3361 3362 3363 retval.tree = root_0; 3364 3365 } 3366 break; 3367 case 29 : 3368 // smaliParser.g:566:5: INSTRUCTION_FORMAT22s_OR_ID 3369 { 3370 INSTRUCTION_FORMAT22s_OR_ID72=(Token)match(input,INSTRUCTION_FORMAT22s_OR_ID,FOLLOW_INSTRUCTION_FORMAT22s_OR_ID_in_simple_name2079); 3371 stream_INSTRUCTION_FORMAT22s_OR_ID.add(INSTRUCTION_FORMAT22s_OR_ID72); 3372 3373 // AST REWRITE 3374 // elements: 3375 // token labels: 3376 // rule labels: retval 3377 // token list labels: 3378 // rule list labels: 3379 // wildcard labels: 3380 retval.tree = root_0; 3381 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3382 3383 root_0 = (CommonTree)adaptor.nil(); 3384 // 566:33: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22s_OR_ID] 3385 { 3386 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22s_OR_ID72)); 3387 } 3388 3389 3390 retval.tree = root_0; 3391 3392 } 3393 break; 3394 case 30 : 3395 // smaliParser.g:567:5: INSTRUCTION_FORMAT22t 3396 { 3397 INSTRUCTION_FORMAT22t73=(Token)match(input,INSTRUCTION_FORMAT22t,FOLLOW_INSTRUCTION_FORMAT22t_in_simple_name2090); 3398 stream_INSTRUCTION_FORMAT22t.add(INSTRUCTION_FORMAT22t73); 3399 3400 // AST REWRITE 3401 // elements: 3402 // token labels: 3403 // rule labels: retval 3404 // token list labels: 3405 // rule list labels: 3406 // wildcard labels: 3407 retval.tree = root_0; 3408 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3409 3410 root_0 = (CommonTree)adaptor.nil(); 3411 // 567:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22t] 3412 { 3413 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22t73)); 3414 } 3415 3416 3417 retval.tree = root_0; 3418 3419 } 3420 break; 3421 case 31 : 3422 // smaliParser.g:568:5: INSTRUCTION_FORMAT23x 3423 { 3424 INSTRUCTION_FORMAT23x74=(Token)match(input,INSTRUCTION_FORMAT23x,FOLLOW_INSTRUCTION_FORMAT23x_in_simple_name2101); 3425 stream_INSTRUCTION_FORMAT23x.add(INSTRUCTION_FORMAT23x74); 3426 3427 // AST REWRITE 3428 // elements: 3429 // token labels: 3430 // rule labels: retval 3431 // token list labels: 3432 // rule list labels: 3433 // wildcard labels: 3434 retval.tree = root_0; 3435 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3436 3437 root_0 = (CommonTree)adaptor.nil(); 3438 // 568:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT23x] 3439 { 3440 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT23x74)); 3441 } 3442 3443 3444 retval.tree = root_0; 3445 3446 } 3447 break; 3448 case 32 : 3449 // smaliParser.g:569:5: INSTRUCTION_FORMAT31i_OR_ID 3450 { 3451 INSTRUCTION_FORMAT31i_OR_ID75=(Token)match(input,INSTRUCTION_FORMAT31i_OR_ID,FOLLOW_INSTRUCTION_FORMAT31i_OR_ID_in_simple_name2112); 3452 stream_INSTRUCTION_FORMAT31i_OR_ID.add(INSTRUCTION_FORMAT31i_OR_ID75); 3453 3454 // AST REWRITE 3455 // elements: 3456 // token labels: 3457 // rule labels: retval 3458 // token list labels: 3459 // rule list labels: 3460 // wildcard labels: 3461 retval.tree = root_0; 3462 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3463 3464 root_0 = (CommonTree)adaptor.nil(); 3465 // 569:33: -> SIMPLE_NAME[$INSTRUCTION_FORMAT31i_OR_ID] 3466 { 3467 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT31i_OR_ID75)); 3468 } 3469 3470 3471 retval.tree = root_0; 3472 3473 } 3474 break; 3475 case 33 : 3476 // smaliParser.g:570:5: INSTRUCTION_FORMAT31t 3477 { 3478 INSTRUCTION_FORMAT31t76=(Token)match(input,INSTRUCTION_FORMAT31t,FOLLOW_INSTRUCTION_FORMAT31t_in_simple_name2123); 3479 stream_INSTRUCTION_FORMAT31t.add(INSTRUCTION_FORMAT31t76); 3480 3481 // AST REWRITE 3482 // elements: 3483 // token labels: 3484 // rule labels: retval 3485 // token list labels: 3486 // rule list labels: 3487 // wildcard labels: 3488 retval.tree = root_0; 3489 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3490 3491 root_0 = (CommonTree)adaptor.nil(); 3492 // 570:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT31t] 3493 { 3494 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT31t76)); 3495 } 3496 3497 3498 retval.tree = root_0; 3499 3500 } 3501 break; 3502 case 34 : 3503 // smaliParser.g:571:5: INSTRUCTION_FORMAT35c_METHOD 3504 { 3505 INSTRUCTION_FORMAT35c_METHOD77=(Token)match(input,INSTRUCTION_FORMAT35c_METHOD,FOLLOW_INSTRUCTION_FORMAT35c_METHOD_in_simple_name2134); 3506 stream_INSTRUCTION_FORMAT35c_METHOD.add(INSTRUCTION_FORMAT35c_METHOD77); 3507 3508 // AST REWRITE 3509 // elements: 3510 // token labels: 3511 // rule labels: retval 3512 // token list labels: 3513 // rule list labels: 3514 // wildcard labels: 3515 retval.tree = root_0; 3516 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3517 3518 root_0 = (CommonTree)adaptor.nil(); 3519 // 571:34: -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_METHOD] 3520 { 3521 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT35c_METHOD77)); 3522 } 3523 3524 3525 retval.tree = root_0; 3526 3527 } 3528 break; 3529 case 35 : 3530 // smaliParser.g:572:5: INSTRUCTION_FORMAT35c_METHOD_ODEX 3531 { 3532 INSTRUCTION_FORMAT35c_METHOD_ODEX78=(Token)match(input,INSTRUCTION_FORMAT35c_METHOD_ODEX,FOLLOW_INSTRUCTION_FORMAT35c_METHOD_ODEX_in_simple_name2145); 3533 stream_INSTRUCTION_FORMAT35c_METHOD_ODEX.add(INSTRUCTION_FORMAT35c_METHOD_ODEX78); 3534 3535 // AST REWRITE 3536 // elements: 3537 // token labels: 3538 // rule labels: retval 3539 // token list labels: 3540 // rule list labels: 3541 // wildcard labels: 3542 retval.tree = root_0; 3543 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3544 3545 root_0 = (CommonTree)adaptor.nil(); 3546 // 572:39: -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_METHOD_ODEX] 3547 { 3548 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT35c_METHOD_ODEX78)); 3549 } 3550 3551 3552 retval.tree = root_0; 3553 3554 } 3555 break; 3556 case 36 : 3557 // smaliParser.g:573:5: INSTRUCTION_FORMAT35c_TYPE 3558 { 3559 INSTRUCTION_FORMAT35c_TYPE79=(Token)match(input,INSTRUCTION_FORMAT35c_TYPE,FOLLOW_INSTRUCTION_FORMAT35c_TYPE_in_simple_name2156); 3560 stream_INSTRUCTION_FORMAT35c_TYPE.add(INSTRUCTION_FORMAT35c_TYPE79); 3561 3562 // AST REWRITE 3563 // elements: 3564 // token labels: 3565 // rule labels: retval 3566 // token list labels: 3567 // rule list labels: 3568 // wildcard labels: 3569 retval.tree = root_0; 3570 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3571 3572 root_0 = (CommonTree)adaptor.nil(); 3573 // 573:32: -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_TYPE] 3574 { 3575 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT35c_TYPE79)); 3576 } 3577 3578 3579 retval.tree = root_0; 3580 3581 } 3582 break; 3583 case 37 : 3584 // smaliParser.g:574:5: INSTRUCTION_FORMAT35mi_METHOD 3585 { 3586 INSTRUCTION_FORMAT35mi_METHOD80=(Token)match(input,INSTRUCTION_FORMAT35mi_METHOD,FOLLOW_INSTRUCTION_FORMAT35mi_METHOD_in_simple_name2167); 3587 stream_INSTRUCTION_FORMAT35mi_METHOD.add(INSTRUCTION_FORMAT35mi_METHOD80); 3588 3589 // AST REWRITE 3590 // elements: 3591 // token labels: 3592 // rule labels: retval 3593 // token list labels: 3594 // rule list labels: 3595 // wildcard labels: 3596 retval.tree = root_0; 3597 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3598 3599 root_0 = (CommonTree)adaptor.nil(); 3600 // 574:35: -> SIMPLE_NAME[$INSTRUCTION_FORMAT35mi_METHOD] 3601 { 3602 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT35mi_METHOD80)); 3603 } 3604 3605 3606 retval.tree = root_0; 3607 3608 } 3609 break; 3610 case 38 : 3611 // smaliParser.g:575:5: INSTRUCTION_FORMAT35ms_METHOD 3612 { 3613 INSTRUCTION_FORMAT35ms_METHOD81=(Token)match(input,INSTRUCTION_FORMAT35ms_METHOD,FOLLOW_INSTRUCTION_FORMAT35ms_METHOD_in_simple_name2178); 3614 stream_INSTRUCTION_FORMAT35ms_METHOD.add(INSTRUCTION_FORMAT35ms_METHOD81); 3615 3616 // AST REWRITE 3617 // elements: 3618 // token labels: 3619 // rule labels: retval 3620 // token list labels: 3621 // rule list labels: 3622 // wildcard labels: 3623 retval.tree = root_0; 3624 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3625 3626 root_0 = (CommonTree)adaptor.nil(); 3627 // 575:35: -> SIMPLE_NAME[$INSTRUCTION_FORMAT35ms_METHOD] 3628 { 3629 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT35ms_METHOD81)); 3630 } 3631 3632 3633 retval.tree = root_0; 3634 3635 } 3636 break; 3637 case 39 : 3638 // smaliParser.g:576:5: INSTRUCTION_FORMAT45cc_METHOD 3639 { 3640 INSTRUCTION_FORMAT45cc_METHOD82=(Token)match(input,INSTRUCTION_FORMAT45cc_METHOD,FOLLOW_INSTRUCTION_FORMAT45cc_METHOD_in_simple_name2189); 3641 stream_INSTRUCTION_FORMAT45cc_METHOD.add(INSTRUCTION_FORMAT45cc_METHOD82); 3642 3643 // AST REWRITE 3644 // elements: 3645 // token labels: 3646 // rule labels: retval 3647 // token list labels: 3648 // rule list labels: 3649 // wildcard labels: 3650 retval.tree = root_0; 3651 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3652 3653 root_0 = (CommonTree)adaptor.nil(); 3654 // 576:35: -> SIMPLE_NAME[$INSTRUCTION_FORMAT45cc_METHOD] 3655 { 3656 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT45cc_METHOD82)); 3657 } 3658 3659 3660 retval.tree = root_0; 3661 3662 } 3663 break; 3664 case 40 : 3665 // smaliParser.g:577:5: INSTRUCTION_FORMAT4rcc_METHOD 3666 { 3667 INSTRUCTION_FORMAT4rcc_METHOD83=(Token)match(input,INSTRUCTION_FORMAT4rcc_METHOD,FOLLOW_INSTRUCTION_FORMAT4rcc_METHOD_in_simple_name2200); 3668 stream_INSTRUCTION_FORMAT4rcc_METHOD.add(INSTRUCTION_FORMAT4rcc_METHOD83); 3669 3670 // AST REWRITE 3671 // elements: 3672 // token labels: 3673 // rule labels: retval 3674 // token list labels: 3675 // rule list labels: 3676 // wildcard labels: 3677 retval.tree = root_0; 3678 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3679 3680 root_0 = (CommonTree)adaptor.nil(); 3681 // 577:35: -> SIMPLE_NAME[$INSTRUCTION_FORMAT4rcc_METHOD] 3682 { 3683 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT4rcc_METHOD83)); 3684 } 3685 3686 3687 retval.tree = root_0; 3688 3689 } 3690 break; 3691 case 41 : 3692 // smaliParser.g:578:5: INSTRUCTION_FORMAT51l 3693 { 3694 INSTRUCTION_FORMAT51l84=(Token)match(input,INSTRUCTION_FORMAT51l,FOLLOW_INSTRUCTION_FORMAT51l_in_simple_name2211); 3695 stream_INSTRUCTION_FORMAT51l.add(INSTRUCTION_FORMAT51l84); 3696 3697 // AST REWRITE 3698 // elements: 3699 // token labels: 3700 // rule labels: retval 3701 // token list labels: 3702 // rule list labels: 3703 // wildcard labels: 3704 retval.tree = root_0; 3705 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3706 3707 root_0 = (CommonTree)adaptor.nil(); 3708 // 578:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT51l] 3709 { 3710 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT51l84)); 3711 } 3712 3713 3714 retval.tree = root_0; 3715 3716 } 3717 break; 3718 3719 } 3720 retval.stop = input.LT(-1); 3721 3722 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 3723 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 3724 3725 } 3726 catch (RecognitionException re) { 3727 reportError(re); 3728 recover(input,re); 3729 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 3730 } 3731 finally { 3732 // do for sure before leaving 3733 } 3734 return retval; 3735 } 3736 // $ANTLR end "simple_name" 3737 3738 3739 public static class member_name_return extends ParserRuleReturnScope { 3740 CommonTree tree; 3741 @Override 3742 public CommonTree getTree() { return tree; } 3743 }; 3744 3745 3746 // $ANTLR start "member_name" 3747 // smaliParser.g:580:1: member_name : ( simple_name | MEMBER_NAME -> SIMPLE_NAME[$MEMBER_NAME] ); 3748 public final smaliParser.member_name_return member_name() throws RecognitionException { 3749 smaliParser.member_name_return retval = new smaliParser.member_name_return(); 3750 retval.start = input.LT(1); 3751 3752 CommonTree root_0 = null; 3753 3754 Token MEMBER_NAME86=null; 3755 ParserRuleReturnScope simple_name85 =null; 3756 3757 CommonTree MEMBER_NAME86_tree=null; 3758 RewriteRuleTokenStream stream_MEMBER_NAME=new RewriteRuleTokenStream(adaptor,"token MEMBER_NAME"); 3759 3760 try { 3761 // smaliParser.g:581:3: ( simple_name | MEMBER_NAME -> SIMPLE_NAME[$MEMBER_NAME] ) 3762 int alt11=2; 3763 int LA11_0 = input.LA(1); 3764 if ( (LA11_0==ACCESS_SPEC||LA11_0==ANNOTATION_VISIBILITY||LA11_0==BOOL_LITERAL||LA11_0==DOUBLE_LITERAL_OR_ID||LA11_0==FLOAT_LITERAL_OR_ID||(LA11_0 >= INSTRUCTION_FORMAT10t && LA11_0 <= INSTRUCTION_FORMAT10x_ODEX)||LA11_0==INSTRUCTION_FORMAT11x||LA11_0==INSTRUCTION_FORMAT12x_OR_ID||(LA11_0 >= INSTRUCTION_FORMAT21c_FIELD && LA11_0 <= INSTRUCTION_FORMAT21c_TYPE)||LA11_0==INSTRUCTION_FORMAT21t||(LA11_0 >= INSTRUCTION_FORMAT22c_FIELD && LA11_0 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA11_0 >= INSTRUCTION_FORMAT22s_OR_ID && LA11_0 <= INSTRUCTION_FORMAT22t)||LA11_0==INSTRUCTION_FORMAT23x||(LA11_0 >= INSTRUCTION_FORMAT31i_OR_ID && LA11_0 <= INSTRUCTION_FORMAT31t)||(LA11_0 >= INSTRUCTION_FORMAT35c_METHOD && LA11_0 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA11_0 >= INSTRUCTION_FORMAT45cc_METHOD && LA11_0 <= INSTRUCTION_FORMAT51l)||(LA11_0 >= NEGATIVE_INTEGER_LITERAL && LA11_0 <= NULL_LITERAL)||(LA11_0 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA11_0 <= PRIMITIVE_TYPE)||LA11_0==REGISTER||LA11_0==SIMPLE_NAME||(LA11_0 >= VERIFICATION_ERROR_TYPE && LA11_0 <= VOID_TYPE)) ) { 3765 alt11=1; 3766 } 3767 else if ( (LA11_0==MEMBER_NAME) ) { 3768 alt11=2; 3769 } 3770 3771 else { 3772 NoViableAltException nvae = 3773 new NoViableAltException("", 11, 0, input); 3774 throw nvae; 3775 } 3776 3777 switch (alt11) { 3778 case 1 : 3779 // smaliParser.g:581:5: simple_name 3780 { 3781 root_0 = (CommonTree)adaptor.nil(); 3782 3783 3784 pushFollow(FOLLOW_simple_name_in_member_name2226); 3785 simple_name85=simple_name(); 3786 state._fsp--; 3787 3788 adaptor.addChild(root_0, simple_name85.getTree()); 3789 3790 } 3791 break; 3792 case 2 : 3793 // smaliParser.g:582:5: MEMBER_NAME 3794 { 3795 MEMBER_NAME86=(Token)match(input,MEMBER_NAME,FOLLOW_MEMBER_NAME_in_member_name2232); 3796 stream_MEMBER_NAME.add(MEMBER_NAME86); 3797 3798 // AST REWRITE 3799 // elements: 3800 // token labels: 3801 // rule labels: retval 3802 // token list labels: 3803 // rule list labels: 3804 // wildcard labels: 3805 retval.tree = root_0; 3806 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3807 3808 root_0 = (CommonTree)adaptor.nil(); 3809 // 582:17: -> SIMPLE_NAME[$MEMBER_NAME] 3810 { 3811 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, MEMBER_NAME86)); 3812 } 3813 3814 3815 retval.tree = root_0; 3816 3817 } 3818 break; 3819 3820 } 3821 retval.stop = input.LT(-1); 3822 3823 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 3824 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 3825 3826 } 3827 catch (RecognitionException re) { 3828 reportError(re); 3829 recover(input,re); 3830 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 3831 } 3832 finally { 3833 // do for sure before leaving 3834 } 3835 return retval; 3836 } 3837 // $ANTLR end "member_name" 3838 3839 3840 public static class method_prototype_return extends ParserRuleReturnScope { 3841 CommonTree tree; 3842 @Override 3843 public CommonTree getTree() { return tree; } 3844 }; 3845 3846 3847 // $ANTLR start "method_prototype" 3848 // smaliParser.g:584:1: method_prototype : OPEN_PAREN param_list CLOSE_PAREN type_descriptor -> ^( I_METHOD_PROTOTYPE[$start, \"I_METHOD_PROTOTYPE\"] ^( I_METHOD_RETURN_TYPE type_descriptor ) ( param_list )? ) ; 3849 public final smaliParser.method_prototype_return method_prototype() throws RecognitionException { 3850 smaliParser.method_prototype_return retval = new smaliParser.method_prototype_return(); 3851 retval.start = input.LT(1); 3852 3853 CommonTree root_0 = null; 3854 3855 Token OPEN_PAREN87=null; 3856 Token CLOSE_PAREN89=null; 3857 ParserRuleReturnScope param_list88 =null; 3858 ParserRuleReturnScope type_descriptor90 =null; 3859 3860 CommonTree OPEN_PAREN87_tree=null; 3861 CommonTree CLOSE_PAREN89_tree=null; 3862 RewriteRuleTokenStream stream_OPEN_PAREN=new RewriteRuleTokenStream(adaptor,"token OPEN_PAREN"); 3863 RewriteRuleTokenStream stream_CLOSE_PAREN=new RewriteRuleTokenStream(adaptor,"token CLOSE_PAREN"); 3864 RewriteRuleSubtreeStream stream_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule type_descriptor"); 3865 RewriteRuleSubtreeStream stream_param_list=new RewriteRuleSubtreeStream(adaptor,"rule param_list"); 3866 3867 try { 3868 // smaliParser.g:585:3: ( OPEN_PAREN param_list CLOSE_PAREN type_descriptor -> ^( I_METHOD_PROTOTYPE[$start, \"I_METHOD_PROTOTYPE\"] ^( I_METHOD_RETURN_TYPE type_descriptor ) ( param_list )? ) ) 3869 // smaliParser.g:585:5: OPEN_PAREN param_list CLOSE_PAREN type_descriptor 3870 { 3871 OPEN_PAREN87=(Token)match(input,OPEN_PAREN,FOLLOW_OPEN_PAREN_in_method_prototype2247); 3872 stream_OPEN_PAREN.add(OPEN_PAREN87); 3873 3874 pushFollow(FOLLOW_param_list_in_method_prototype2249); 3875 param_list88=param_list(); 3876 state._fsp--; 3877 3878 stream_param_list.add(param_list88.getTree()); 3879 CLOSE_PAREN89=(Token)match(input,CLOSE_PAREN,FOLLOW_CLOSE_PAREN_in_method_prototype2251); 3880 stream_CLOSE_PAREN.add(CLOSE_PAREN89); 3881 3882 pushFollow(FOLLOW_type_descriptor_in_method_prototype2253); 3883 type_descriptor90=type_descriptor(); 3884 state._fsp--; 3885 3886 stream_type_descriptor.add(type_descriptor90.getTree()); 3887 // AST REWRITE 3888 // elements: type_descriptor, param_list 3889 // token labels: 3890 // rule labels: retval 3891 // token list labels: 3892 // rule list labels: 3893 // wildcard labels: 3894 retval.tree = root_0; 3895 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3896 3897 root_0 = (CommonTree)adaptor.nil(); 3898 // 586:5: -> ^( I_METHOD_PROTOTYPE[$start, \"I_METHOD_PROTOTYPE\"] ^( I_METHOD_RETURN_TYPE type_descriptor ) ( param_list )? ) 3899 { 3900 // smaliParser.g:586:8: ^( I_METHOD_PROTOTYPE[$start, \"I_METHOD_PROTOTYPE\"] ^( I_METHOD_RETURN_TYPE type_descriptor ) ( param_list )? ) 3901 { 3902 CommonTree root_1 = (CommonTree)adaptor.nil(); 3903 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_METHOD_PROTOTYPE, (retval.start), "I_METHOD_PROTOTYPE"), root_1); 3904 // smaliParser.g:586:59: ^( I_METHOD_RETURN_TYPE type_descriptor ) 3905 { 3906 CommonTree root_2 = (CommonTree)adaptor.nil(); 3907 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_METHOD_RETURN_TYPE, "I_METHOD_RETURN_TYPE"), root_2); 3908 adaptor.addChild(root_2, stream_type_descriptor.nextTree()); 3909 adaptor.addChild(root_1, root_2); 3910 } 3911 3912 // smaliParser.g:586:99: ( param_list )? 3913 if ( stream_param_list.hasNext() ) { 3914 adaptor.addChild(root_1, stream_param_list.nextTree()); 3915 } 3916 stream_param_list.reset(); 3917 3918 adaptor.addChild(root_0, root_1); 3919 } 3920 3921 } 3922 3923 3924 retval.tree = root_0; 3925 3926 } 3927 3928 retval.stop = input.LT(-1); 3929 3930 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 3931 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 3932 3933 } 3934 catch (RecognitionException re) { 3935 reportError(re); 3936 recover(input,re); 3937 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 3938 } 3939 finally { 3940 // do for sure before leaving 3941 } 3942 return retval; 3943 } 3944 // $ANTLR end "method_prototype" 3945 3946 3947 public static class param_list_or_id_primitive_type_return extends ParserRuleReturnScope { 3948 CommonTree tree; 3949 @Override 3950 public CommonTree getTree() { return tree; } 3951 }; 3952 3953 3954 // $ANTLR start "param_list_or_id_primitive_type" 3955 // smaliParser.g:588:1: param_list_or_id_primitive_type : PARAM_LIST_OR_ID_PRIMITIVE_TYPE -> PRIMITIVE_TYPE[$PARAM_LIST_OR_ID_PRIMITIVE_TYPE] ; 3956 public final smaliParser.param_list_or_id_primitive_type_return param_list_or_id_primitive_type() throws RecognitionException { 3957 smaliParser.param_list_or_id_primitive_type_return retval = new smaliParser.param_list_or_id_primitive_type_return(); 3958 retval.start = input.LT(1); 3959 3960 CommonTree root_0 = null; 3961 3962 Token PARAM_LIST_OR_ID_PRIMITIVE_TYPE91=null; 3963 3964 CommonTree PARAM_LIST_OR_ID_PRIMITIVE_TYPE91_tree=null; 3965 RewriteRuleTokenStream stream_PARAM_LIST_OR_ID_PRIMITIVE_TYPE=new RewriteRuleTokenStream(adaptor,"token PARAM_LIST_OR_ID_PRIMITIVE_TYPE"); 3966 3967 try { 3968 // smaliParser.g:589:3: ( PARAM_LIST_OR_ID_PRIMITIVE_TYPE -> PRIMITIVE_TYPE[$PARAM_LIST_OR_ID_PRIMITIVE_TYPE] ) 3969 // smaliParser.g:589:5: PARAM_LIST_OR_ID_PRIMITIVE_TYPE 3970 { 3971 PARAM_LIST_OR_ID_PRIMITIVE_TYPE91=(Token)match(input,PARAM_LIST_OR_ID_PRIMITIVE_TYPE,FOLLOW_PARAM_LIST_OR_ID_PRIMITIVE_TYPE_in_param_list_or_id_primitive_type2283); 3972 stream_PARAM_LIST_OR_ID_PRIMITIVE_TYPE.add(PARAM_LIST_OR_ID_PRIMITIVE_TYPE91); 3973 3974 // AST REWRITE 3975 // elements: 3976 // token labels: 3977 // rule labels: retval 3978 // token list labels: 3979 // rule list labels: 3980 // wildcard labels: 3981 retval.tree = root_0; 3982 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3983 3984 root_0 = (CommonTree)adaptor.nil(); 3985 // 589:37: -> PRIMITIVE_TYPE[$PARAM_LIST_OR_ID_PRIMITIVE_TYPE] 3986 { 3987 adaptor.addChild(root_0, (CommonTree)adaptor.create(PRIMITIVE_TYPE, PARAM_LIST_OR_ID_PRIMITIVE_TYPE91)); 3988 } 3989 3990 3991 retval.tree = root_0; 3992 3993 } 3994 3995 retval.stop = input.LT(-1); 3996 3997 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 3998 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 3999 4000 } 4001 catch (RecognitionException re) { 4002 reportError(re); 4003 recover(input,re); 4004 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 4005 } 4006 finally { 4007 // do for sure before leaving 4008 } 4009 return retval; 4010 } 4011 // $ANTLR end "param_list_or_id_primitive_type" 4012 4013 4014 public static class param_list_return extends ParserRuleReturnScope { 4015 CommonTree tree; 4016 @Override 4017 public CommonTree getTree() { return tree; } 4018 }; 4019 4020 4021 // $ANTLR start "param_list" 4022 // smaliParser.g:591:1: param_list : ( ( param_list_or_id_primitive_type )+ | ( nonvoid_type_descriptor )* ); 4023 public final smaliParser.param_list_return param_list() throws RecognitionException { 4024 smaliParser.param_list_return retval = new smaliParser.param_list_return(); 4025 retval.start = input.LT(1); 4026 4027 CommonTree root_0 = null; 4028 4029 ParserRuleReturnScope param_list_or_id_primitive_type92 =null; 4030 ParserRuleReturnScope nonvoid_type_descriptor93 =null; 4031 4032 4033 try { 4034 // smaliParser.g:592:3: ( ( param_list_or_id_primitive_type )+ | ( nonvoid_type_descriptor )* ) 4035 int alt14=2; 4036 int LA14_0 = input.LA(1); 4037 if ( (LA14_0==PARAM_LIST_OR_ID_PRIMITIVE_TYPE) ) { 4038 alt14=1; 4039 } 4040 else if ( (LA14_0==ARRAY_TYPE_PREFIX||LA14_0==CLASS_DESCRIPTOR||LA14_0==CLOSE_PAREN||LA14_0==PRIMITIVE_TYPE) ) { 4041 alt14=2; 4042 } 4043 4044 else { 4045 NoViableAltException nvae = 4046 new NoViableAltException("", 14, 0, input); 4047 throw nvae; 4048 } 4049 4050 switch (alt14) { 4051 case 1 : 4052 // smaliParser.g:592:5: ( param_list_or_id_primitive_type )+ 4053 { 4054 root_0 = (CommonTree)adaptor.nil(); 4055 4056 4057 // smaliParser.g:592:5: ( param_list_or_id_primitive_type )+ 4058 int cnt12=0; 4059 loop12: 4060 while (true) { 4061 int alt12=2; 4062 int LA12_0 = input.LA(1); 4063 if ( (LA12_0==PARAM_LIST_OR_ID_PRIMITIVE_TYPE) ) { 4064 alt12=1; 4065 } 4066 4067 switch (alt12) { 4068 case 1 : 4069 // smaliParser.g:592:5: param_list_or_id_primitive_type 4070 { 4071 pushFollow(FOLLOW_param_list_or_id_primitive_type_in_param_list2298); 4072 param_list_or_id_primitive_type92=param_list_or_id_primitive_type(); 4073 state._fsp--; 4074 4075 adaptor.addChild(root_0, param_list_or_id_primitive_type92.getTree()); 4076 4077 } 4078 break; 4079 4080 default : 4081 if ( cnt12 >= 1 ) break loop12; 4082 EarlyExitException eee = new EarlyExitException(12, input); 4083 throw eee; 4084 } 4085 cnt12++; 4086 } 4087 4088 } 4089 break; 4090 case 2 : 4091 // smaliParser.g:593:5: ( nonvoid_type_descriptor )* 4092 { 4093 root_0 = (CommonTree)adaptor.nil(); 4094 4095 4096 // smaliParser.g:593:5: ( nonvoid_type_descriptor )* 4097 loop13: 4098 while (true) { 4099 int alt13=2; 4100 int LA13_0 = input.LA(1); 4101 if ( (LA13_0==ARRAY_TYPE_PREFIX||LA13_0==CLASS_DESCRIPTOR||LA13_0==PRIMITIVE_TYPE) ) { 4102 alt13=1; 4103 } 4104 4105 switch (alt13) { 4106 case 1 : 4107 // smaliParser.g:593:5: nonvoid_type_descriptor 4108 { 4109 pushFollow(FOLLOW_nonvoid_type_descriptor_in_param_list2305); 4110 nonvoid_type_descriptor93=nonvoid_type_descriptor(); 4111 state._fsp--; 4112 4113 adaptor.addChild(root_0, nonvoid_type_descriptor93.getTree()); 4114 4115 } 4116 break; 4117 4118 default : 4119 break loop13; 4120 } 4121 } 4122 4123 } 4124 break; 4125 4126 } 4127 retval.stop = input.LT(-1); 4128 4129 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 4130 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 4131 4132 } 4133 catch (RecognitionException re) { 4134 reportError(re); 4135 recover(input,re); 4136 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 4137 } 4138 finally { 4139 // do for sure before leaving 4140 } 4141 return retval; 4142 } 4143 // $ANTLR end "param_list" 4144 4145 4146 public static class array_descriptor_return extends ParserRuleReturnScope { 4147 CommonTree tree; 4148 @Override 4149 public CommonTree getTree() { return tree; } 4150 }; 4151 4152 4153 // $ANTLR start "array_descriptor" 4154 // smaliParser.g:595:1: array_descriptor : ARRAY_TYPE_PREFIX ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR ) ; 4155 public final smaliParser.array_descriptor_return array_descriptor() throws RecognitionException { 4156 smaliParser.array_descriptor_return retval = new smaliParser.array_descriptor_return(); 4157 retval.start = input.LT(1); 4158 4159 CommonTree root_0 = null; 4160 4161 Token ARRAY_TYPE_PREFIX94=null; 4162 Token set95=null; 4163 4164 CommonTree ARRAY_TYPE_PREFIX94_tree=null; 4165 CommonTree set95_tree=null; 4166 4167 try { 4168 // smaliParser.g:596:3: ( ARRAY_TYPE_PREFIX ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR ) ) 4169 // smaliParser.g:596:5: ARRAY_TYPE_PREFIX ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR ) 4170 { 4171 root_0 = (CommonTree)adaptor.nil(); 4172 4173 4174 ARRAY_TYPE_PREFIX94=(Token)match(input,ARRAY_TYPE_PREFIX,FOLLOW_ARRAY_TYPE_PREFIX_in_array_descriptor2316); 4175 ARRAY_TYPE_PREFIX94_tree = (CommonTree)adaptor.create(ARRAY_TYPE_PREFIX94); 4176 adaptor.addChild(root_0, ARRAY_TYPE_PREFIX94_tree); 4177 4178 set95=input.LT(1); 4179 if ( input.LA(1)==CLASS_DESCRIPTOR||input.LA(1)==PRIMITIVE_TYPE ) { 4180 input.consume(); 4181 adaptor.addChild(root_0, (CommonTree)adaptor.create(set95)); 4182 state.errorRecovery=false; 4183 } 4184 else { 4185 MismatchedSetException mse = new MismatchedSetException(null,input); 4186 throw mse; 4187 } 4188 } 4189 4190 retval.stop = input.LT(-1); 4191 4192 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 4193 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 4194 4195 } 4196 catch (RecognitionException re) { 4197 reportError(re); 4198 recover(input,re); 4199 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 4200 } 4201 finally { 4202 // do for sure before leaving 4203 } 4204 return retval; 4205 } 4206 // $ANTLR end "array_descriptor" 4207 4208 4209 public static class type_descriptor_return extends ParserRuleReturnScope { 4210 CommonTree tree; 4211 @Override 4212 public CommonTree getTree() { return tree; } 4213 }; 4214 4215 4216 // $ANTLR start "type_descriptor" 4217 // smaliParser.g:598:1: type_descriptor : ( VOID_TYPE | PRIMITIVE_TYPE | CLASS_DESCRIPTOR | array_descriptor ); 4218 public final smaliParser.type_descriptor_return type_descriptor() throws RecognitionException { 4219 smaliParser.type_descriptor_return retval = new smaliParser.type_descriptor_return(); 4220 retval.start = input.LT(1); 4221 4222 CommonTree root_0 = null; 4223 4224 Token VOID_TYPE96=null; 4225 Token PRIMITIVE_TYPE97=null; 4226 Token CLASS_DESCRIPTOR98=null; 4227 ParserRuleReturnScope array_descriptor99 =null; 4228 4229 CommonTree VOID_TYPE96_tree=null; 4230 CommonTree PRIMITIVE_TYPE97_tree=null; 4231 CommonTree CLASS_DESCRIPTOR98_tree=null; 4232 4233 try { 4234 // smaliParser.g:599:3: ( VOID_TYPE | PRIMITIVE_TYPE | CLASS_DESCRIPTOR | array_descriptor ) 4235 int alt15=4; 4236 switch ( input.LA(1) ) { 4237 case VOID_TYPE: 4238 { 4239 alt15=1; 4240 } 4241 break; 4242 case PRIMITIVE_TYPE: 4243 { 4244 alt15=2; 4245 } 4246 break; 4247 case CLASS_DESCRIPTOR: 4248 { 4249 alt15=3; 4250 } 4251 break; 4252 case ARRAY_TYPE_PREFIX: 4253 { 4254 alt15=4; 4255 } 4256 break; 4257 default: 4258 NoViableAltException nvae = 4259 new NoViableAltException("", 15, 0, input); 4260 throw nvae; 4261 } 4262 switch (alt15) { 4263 case 1 : 4264 // smaliParser.g:599:5: VOID_TYPE 4265 { 4266 root_0 = (CommonTree)adaptor.nil(); 4267 4268 4269 VOID_TYPE96=(Token)match(input,VOID_TYPE,FOLLOW_VOID_TYPE_in_type_descriptor2334); 4270 VOID_TYPE96_tree = (CommonTree)adaptor.create(VOID_TYPE96); 4271 adaptor.addChild(root_0, VOID_TYPE96_tree); 4272 4273 } 4274 break; 4275 case 2 : 4276 // smaliParser.g:600:5: PRIMITIVE_TYPE 4277 { 4278 root_0 = (CommonTree)adaptor.nil(); 4279 4280 4281 PRIMITIVE_TYPE97=(Token)match(input,PRIMITIVE_TYPE,FOLLOW_PRIMITIVE_TYPE_in_type_descriptor2340); 4282 PRIMITIVE_TYPE97_tree = (CommonTree)adaptor.create(PRIMITIVE_TYPE97); 4283 adaptor.addChild(root_0, PRIMITIVE_TYPE97_tree); 4284 4285 } 4286 break; 4287 case 3 : 4288 // smaliParser.g:601:5: CLASS_DESCRIPTOR 4289 { 4290 root_0 = (CommonTree)adaptor.nil(); 4291 4292 4293 CLASS_DESCRIPTOR98=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_type_descriptor2346); 4294 CLASS_DESCRIPTOR98_tree = (CommonTree)adaptor.create(CLASS_DESCRIPTOR98); 4295 adaptor.addChild(root_0, CLASS_DESCRIPTOR98_tree); 4296 4297 } 4298 break; 4299 case 4 : 4300 // smaliParser.g:602:5: array_descriptor 4301 { 4302 root_0 = (CommonTree)adaptor.nil(); 4303 4304 4305 pushFollow(FOLLOW_array_descriptor_in_type_descriptor2352); 4306 array_descriptor99=array_descriptor(); 4307 state._fsp--; 4308 4309 adaptor.addChild(root_0, array_descriptor99.getTree()); 4310 4311 } 4312 break; 4313 4314 } 4315 retval.stop = input.LT(-1); 4316 4317 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 4318 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 4319 4320 } 4321 catch (RecognitionException re) { 4322 reportError(re); 4323 recover(input,re); 4324 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 4325 } 4326 finally { 4327 // do for sure before leaving 4328 } 4329 return retval; 4330 } 4331 // $ANTLR end "type_descriptor" 4332 4333 4334 public static class nonvoid_type_descriptor_return extends ParserRuleReturnScope { 4335 CommonTree tree; 4336 @Override 4337 public CommonTree getTree() { return tree; } 4338 }; 4339 4340 4341 // $ANTLR start "nonvoid_type_descriptor" 4342 // smaliParser.g:604:1: nonvoid_type_descriptor : ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR | array_descriptor ); 4343 public final smaliParser.nonvoid_type_descriptor_return nonvoid_type_descriptor() throws RecognitionException { 4344 smaliParser.nonvoid_type_descriptor_return retval = new smaliParser.nonvoid_type_descriptor_return(); 4345 retval.start = input.LT(1); 4346 4347 CommonTree root_0 = null; 4348 4349 Token PRIMITIVE_TYPE100=null; 4350 Token CLASS_DESCRIPTOR101=null; 4351 ParserRuleReturnScope array_descriptor102 =null; 4352 4353 CommonTree PRIMITIVE_TYPE100_tree=null; 4354 CommonTree CLASS_DESCRIPTOR101_tree=null; 4355 4356 try { 4357 // smaliParser.g:605:3: ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR | array_descriptor ) 4358 int alt16=3; 4359 switch ( input.LA(1) ) { 4360 case PRIMITIVE_TYPE: 4361 { 4362 alt16=1; 4363 } 4364 break; 4365 case CLASS_DESCRIPTOR: 4366 { 4367 alt16=2; 4368 } 4369 break; 4370 case ARRAY_TYPE_PREFIX: 4371 { 4372 alt16=3; 4373 } 4374 break; 4375 default: 4376 NoViableAltException nvae = 4377 new NoViableAltException("", 16, 0, input); 4378 throw nvae; 4379 } 4380 switch (alt16) { 4381 case 1 : 4382 // smaliParser.g:605:5: PRIMITIVE_TYPE 4383 { 4384 root_0 = (CommonTree)adaptor.nil(); 4385 4386 4387 PRIMITIVE_TYPE100=(Token)match(input,PRIMITIVE_TYPE,FOLLOW_PRIMITIVE_TYPE_in_nonvoid_type_descriptor2362); 4388 PRIMITIVE_TYPE100_tree = (CommonTree)adaptor.create(PRIMITIVE_TYPE100); 4389 adaptor.addChild(root_0, PRIMITIVE_TYPE100_tree); 4390 4391 } 4392 break; 4393 case 2 : 4394 // smaliParser.g:606:5: CLASS_DESCRIPTOR 4395 { 4396 root_0 = (CommonTree)adaptor.nil(); 4397 4398 4399 CLASS_DESCRIPTOR101=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_nonvoid_type_descriptor2368); 4400 CLASS_DESCRIPTOR101_tree = (CommonTree)adaptor.create(CLASS_DESCRIPTOR101); 4401 adaptor.addChild(root_0, CLASS_DESCRIPTOR101_tree); 4402 4403 } 4404 break; 4405 case 3 : 4406 // smaliParser.g:607:5: array_descriptor 4407 { 4408 root_0 = (CommonTree)adaptor.nil(); 4409 4410 4411 pushFollow(FOLLOW_array_descriptor_in_nonvoid_type_descriptor2374); 4412 array_descriptor102=array_descriptor(); 4413 state._fsp--; 4414 4415 adaptor.addChild(root_0, array_descriptor102.getTree()); 4416 4417 } 4418 break; 4419 4420 } 4421 retval.stop = input.LT(-1); 4422 4423 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 4424 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 4425 4426 } 4427 catch (RecognitionException re) { 4428 reportError(re); 4429 recover(input,re); 4430 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 4431 } 4432 finally { 4433 // do for sure before leaving 4434 } 4435 return retval; 4436 } 4437 // $ANTLR end "nonvoid_type_descriptor" 4438 4439 4440 public static class reference_type_descriptor_return extends ParserRuleReturnScope { 4441 CommonTree tree; 4442 @Override 4443 public CommonTree getTree() { return tree; } 4444 }; 4445 4446 4447 // $ANTLR start "reference_type_descriptor" 4448 // smaliParser.g:609:1: reference_type_descriptor : ( CLASS_DESCRIPTOR | array_descriptor ); 4449 public final smaliParser.reference_type_descriptor_return reference_type_descriptor() throws RecognitionException { 4450 smaliParser.reference_type_descriptor_return retval = new smaliParser.reference_type_descriptor_return(); 4451 retval.start = input.LT(1); 4452 4453 CommonTree root_0 = null; 4454 4455 Token CLASS_DESCRIPTOR103=null; 4456 ParserRuleReturnScope array_descriptor104 =null; 4457 4458 CommonTree CLASS_DESCRIPTOR103_tree=null; 4459 4460 try { 4461 // smaliParser.g:610:3: ( CLASS_DESCRIPTOR | array_descriptor ) 4462 int alt17=2; 4463 int LA17_0 = input.LA(1); 4464 if ( (LA17_0==CLASS_DESCRIPTOR) ) { 4465 alt17=1; 4466 } 4467 else if ( (LA17_0==ARRAY_TYPE_PREFIX) ) { 4468 alt17=2; 4469 } 4470 4471 else { 4472 NoViableAltException nvae = 4473 new NoViableAltException("", 17, 0, input); 4474 throw nvae; 4475 } 4476 4477 switch (alt17) { 4478 case 1 : 4479 // smaliParser.g:610:5: CLASS_DESCRIPTOR 4480 { 4481 root_0 = (CommonTree)adaptor.nil(); 4482 4483 4484 CLASS_DESCRIPTOR103=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_reference_type_descriptor2384); 4485 CLASS_DESCRIPTOR103_tree = (CommonTree)adaptor.create(CLASS_DESCRIPTOR103); 4486 adaptor.addChild(root_0, CLASS_DESCRIPTOR103_tree); 4487 4488 } 4489 break; 4490 case 2 : 4491 // smaliParser.g:611:5: array_descriptor 4492 { 4493 root_0 = (CommonTree)adaptor.nil(); 4494 4495 4496 pushFollow(FOLLOW_array_descriptor_in_reference_type_descriptor2390); 4497 array_descriptor104=array_descriptor(); 4498 state._fsp--; 4499 4500 adaptor.addChild(root_0, array_descriptor104.getTree()); 4501 4502 } 4503 break; 4504 4505 } 4506 retval.stop = input.LT(-1); 4507 4508 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 4509 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 4510 4511 } 4512 catch (RecognitionException re) { 4513 reportError(re); 4514 recover(input,re); 4515 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 4516 } 4517 finally { 4518 // do for sure before leaving 4519 } 4520 return retval; 4521 } 4522 // $ANTLR end "reference_type_descriptor" 4523 4524 4525 public static class integer_literal_return extends ParserRuleReturnScope { 4526 CommonTree tree; 4527 @Override 4528 public CommonTree getTree() { return tree; } 4529 }; 4530 4531 4532 // $ANTLR start "integer_literal" 4533 // smaliParser.g:613:1: integer_literal : ( POSITIVE_INTEGER_LITERAL -> INTEGER_LITERAL[$POSITIVE_INTEGER_LITERAL] | NEGATIVE_INTEGER_LITERAL -> INTEGER_LITERAL[$NEGATIVE_INTEGER_LITERAL] ); 4534 public final smaliParser.integer_literal_return integer_literal() throws RecognitionException { 4535 smaliParser.integer_literal_return retval = new smaliParser.integer_literal_return(); 4536 retval.start = input.LT(1); 4537 4538 CommonTree root_0 = null; 4539 4540 Token POSITIVE_INTEGER_LITERAL105=null; 4541 Token NEGATIVE_INTEGER_LITERAL106=null; 4542 4543 CommonTree POSITIVE_INTEGER_LITERAL105_tree=null; 4544 CommonTree NEGATIVE_INTEGER_LITERAL106_tree=null; 4545 RewriteRuleTokenStream stream_NEGATIVE_INTEGER_LITERAL=new RewriteRuleTokenStream(adaptor,"token NEGATIVE_INTEGER_LITERAL"); 4546 RewriteRuleTokenStream stream_POSITIVE_INTEGER_LITERAL=new RewriteRuleTokenStream(adaptor,"token POSITIVE_INTEGER_LITERAL"); 4547 4548 try { 4549 // smaliParser.g:614:3: ( POSITIVE_INTEGER_LITERAL -> INTEGER_LITERAL[$POSITIVE_INTEGER_LITERAL] | NEGATIVE_INTEGER_LITERAL -> INTEGER_LITERAL[$NEGATIVE_INTEGER_LITERAL] ) 4550 int alt18=2; 4551 int LA18_0 = input.LA(1); 4552 if ( (LA18_0==POSITIVE_INTEGER_LITERAL) ) { 4553 alt18=1; 4554 } 4555 else if ( (LA18_0==NEGATIVE_INTEGER_LITERAL) ) { 4556 alt18=2; 4557 } 4558 4559 else { 4560 NoViableAltException nvae = 4561 new NoViableAltException("", 18, 0, input); 4562 throw nvae; 4563 } 4564 4565 switch (alt18) { 4566 case 1 : 4567 // smaliParser.g:614:5: POSITIVE_INTEGER_LITERAL 4568 { 4569 POSITIVE_INTEGER_LITERAL105=(Token)match(input,POSITIVE_INTEGER_LITERAL,FOLLOW_POSITIVE_INTEGER_LITERAL_in_integer_literal2400); 4570 stream_POSITIVE_INTEGER_LITERAL.add(POSITIVE_INTEGER_LITERAL105); 4571 4572 // AST REWRITE 4573 // elements: 4574 // token labels: 4575 // rule labels: retval 4576 // token list labels: 4577 // rule list labels: 4578 // wildcard labels: 4579 retval.tree = root_0; 4580 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 4581 4582 root_0 = (CommonTree)adaptor.nil(); 4583 // 614:30: -> INTEGER_LITERAL[$POSITIVE_INTEGER_LITERAL] 4584 { 4585 adaptor.addChild(root_0, (CommonTree)adaptor.create(INTEGER_LITERAL, POSITIVE_INTEGER_LITERAL105)); 4586 } 4587 4588 4589 retval.tree = root_0; 4590 4591 } 4592 break; 4593 case 2 : 4594 // smaliParser.g:615:5: NEGATIVE_INTEGER_LITERAL 4595 { 4596 NEGATIVE_INTEGER_LITERAL106=(Token)match(input,NEGATIVE_INTEGER_LITERAL,FOLLOW_NEGATIVE_INTEGER_LITERAL_in_integer_literal2411); 4597 stream_NEGATIVE_INTEGER_LITERAL.add(NEGATIVE_INTEGER_LITERAL106); 4598 4599 // AST REWRITE 4600 // elements: 4601 // token labels: 4602 // rule labels: retval 4603 // token list labels: 4604 // rule list labels: 4605 // wildcard labels: 4606 retval.tree = root_0; 4607 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 4608 4609 root_0 = (CommonTree)adaptor.nil(); 4610 // 615:30: -> INTEGER_LITERAL[$NEGATIVE_INTEGER_LITERAL] 4611 { 4612 adaptor.addChild(root_0, (CommonTree)adaptor.create(INTEGER_LITERAL, NEGATIVE_INTEGER_LITERAL106)); 4613 } 4614 4615 4616 retval.tree = root_0; 4617 4618 } 4619 break; 4620 4621 } 4622 retval.stop = input.LT(-1); 4623 4624 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 4625 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 4626 4627 } 4628 catch (RecognitionException re) { 4629 reportError(re); 4630 recover(input,re); 4631 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 4632 } 4633 finally { 4634 // do for sure before leaving 4635 } 4636 return retval; 4637 } 4638 // $ANTLR end "integer_literal" 4639 4640 4641 public static class float_literal_return extends ParserRuleReturnScope { 4642 CommonTree tree; 4643 @Override 4644 public CommonTree getTree() { return tree; } 4645 }; 4646 4647 4648 // $ANTLR start "float_literal" 4649 // smaliParser.g:617:1: float_literal : ( FLOAT_LITERAL_OR_ID -> FLOAT_LITERAL[$FLOAT_LITERAL_OR_ID] | FLOAT_LITERAL ); 4650 public final smaliParser.float_literal_return float_literal() throws RecognitionException { 4651 smaliParser.float_literal_return retval = new smaliParser.float_literal_return(); 4652 retval.start = input.LT(1); 4653 4654 CommonTree root_0 = null; 4655 4656 Token FLOAT_LITERAL_OR_ID107=null; 4657 Token FLOAT_LITERAL108=null; 4658 4659 CommonTree FLOAT_LITERAL_OR_ID107_tree=null; 4660 CommonTree FLOAT_LITERAL108_tree=null; 4661 RewriteRuleTokenStream stream_FLOAT_LITERAL_OR_ID=new RewriteRuleTokenStream(adaptor,"token FLOAT_LITERAL_OR_ID"); 4662 4663 try { 4664 // smaliParser.g:618:3: ( FLOAT_LITERAL_OR_ID -> FLOAT_LITERAL[$FLOAT_LITERAL_OR_ID] | FLOAT_LITERAL ) 4665 int alt19=2; 4666 int LA19_0 = input.LA(1); 4667 if ( (LA19_0==FLOAT_LITERAL_OR_ID) ) { 4668 alt19=1; 4669 } 4670 else if ( (LA19_0==FLOAT_LITERAL) ) { 4671 alt19=2; 4672 } 4673 4674 else { 4675 NoViableAltException nvae = 4676 new NoViableAltException("", 19, 0, input); 4677 throw nvae; 4678 } 4679 4680 switch (alt19) { 4681 case 1 : 4682 // smaliParser.g:618:5: FLOAT_LITERAL_OR_ID 4683 { 4684 FLOAT_LITERAL_OR_ID107=(Token)match(input,FLOAT_LITERAL_OR_ID,FOLLOW_FLOAT_LITERAL_OR_ID_in_float_literal2426); 4685 stream_FLOAT_LITERAL_OR_ID.add(FLOAT_LITERAL_OR_ID107); 4686 4687 // AST REWRITE 4688 // elements: 4689 // token labels: 4690 // rule labels: retval 4691 // token list labels: 4692 // rule list labels: 4693 // wildcard labels: 4694 retval.tree = root_0; 4695 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 4696 4697 root_0 = (CommonTree)adaptor.nil(); 4698 // 618:25: -> FLOAT_LITERAL[$FLOAT_LITERAL_OR_ID] 4699 { 4700 adaptor.addChild(root_0, (CommonTree)adaptor.create(FLOAT_LITERAL, FLOAT_LITERAL_OR_ID107)); 4701 } 4702 4703 4704 retval.tree = root_0; 4705 4706 } 4707 break; 4708 case 2 : 4709 // smaliParser.g:619:5: FLOAT_LITERAL 4710 { 4711 root_0 = (CommonTree)adaptor.nil(); 4712 4713 4714 FLOAT_LITERAL108=(Token)match(input,FLOAT_LITERAL,FOLLOW_FLOAT_LITERAL_in_float_literal2437); 4715 FLOAT_LITERAL108_tree = (CommonTree)adaptor.create(FLOAT_LITERAL108); 4716 adaptor.addChild(root_0, FLOAT_LITERAL108_tree); 4717 4718 } 4719 break; 4720 4721 } 4722 retval.stop = input.LT(-1); 4723 4724 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 4725 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 4726 4727 } 4728 catch (RecognitionException re) { 4729 reportError(re); 4730 recover(input,re); 4731 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 4732 } 4733 finally { 4734 // do for sure before leaving 4735 } 4736 return retval; 4737 } 4738 // $ANTLR end "float_literal" 4739 4740 4741 public static class double_literal_return extends ParserRuleReturnScope { 4742 CommonTree tree; 4743 @Override 4744 public CommonTree getTree() { return tree; } 4745 }; 4746 4747 4748 // $ANTLR start "double_literal" 4749 // smaliParser.g:621:1: double_literal : ( DOUBLE_LITERAL_OR_ID -> DOUBLE_LITERAL[$DOUBLE_LITERAL_OR_ID] | DOUBLE_LITERAL ); 4750 public final smaliParser.double_literal_return double_literal() throws RecognitionException { 4751 smaliParser.double_literal_return retval = new smaliParser.double_literal_return(); 4752 retval.start = input.LT(1); 4753 4754 CommonTree root_0 = null; 4755 4756 Token DOUBLE_LITERAL_OR_ID109=null; 4757 Token DOUBLE_LITERAL110=null; 4758 4759 CommonTree DOUBLE_LITERAL_OR_ID109_tree=null; 4760 CommonTree DOUBLE_LITERAL110_tree=null; 4761 RewriteRuleTokenStream stream_DOUBLE_LITERAL_OR_ID=new RewriteRuleTokenStream(adaptor,"token DOUBLE_LITERAL_OR_ID"); 4762 4763 try { 4764 // smaliParser.g:622:3: ( DOUBLE_LITERAL_OR_ID -> DOUBLE_LITERAL[$DOUBLE_LITERAL_OR_ID] | DOUBLE_LITERAL ) 4765 int alt20=2; 4766 int LA20_0 = input.LA(1); 4767 if ( (LA20_0==DOUBLE_LITERAL_OR_ID) ) { 4768 alt20=1; 4769 } 4770 else if ( (LA20_0==DOUBLE_LITERAL) ) { 4771 alt20=2; 4772 } 4773 4774 else { 4775 NoViableAltException nvae = 4776 new NoViableAltException("", 20, 0, input); 4777 throw nvae; 4778 } 4779 4780 switch (alt20) { 4781 case 1 : 4782 // smaliParser.g:622:5: DOUBLE_LITERAL_OR_ID 4783 { 4784 DOUBLE_LITERAL_OR_ID109=(Token)match(input,DOUBLE_LITERAL_OR_ID,FOLLOW_DOUBLE_LITERAL_OR_ID_in_double_literal2447); 4785 stream_DOUBLE_LITERAL_OR_ID.add(DOUBLE_LITERAL_OR_ID109); 4786 4787 // AST REWRITE 4788 // elements: 4789 // token labels: 4790 // rule labels: retval 4791 // token list labels: 4792 // rule list labels: 4793 // wildcard labels: 4794 retval.tree = root_0; 4795 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 4796 4797 root_0 = (CommonTree)adaptor.nil(); 4798 // 622:26: -> DOUBLE_LITERAL[$DOUBLE_LITERAL_OR_ID] 4799 { 4800 adaptor.addChild(root_0, (CommonTree)adaptor.create(DOUBLE_LITERAL, DOUBLE_LITERAL_OR_ID109)); 4801 } 4802 4803 4804 retval.tree = root_0; 4805 4806 } 4807 break; 4808 case 2 : 4809 // smaliParser.g:623:5: DOUBLE_LITERAL 4810 { 4811 root_0 = (CommonTree)adaptor.nil(); 4812 4813 4814 DOUBLE_LITERAL110=(Token)match(input,DOUBLE_LITERAL,FOLLOW_DOUBLE_LITERAL_in_double_literal2458); 4815 DOUBLE_LITERAL110_tree = (CommonTree)adaptor.create(DOUBLE_LITERAL110); 4816 adaptor.addChild(root_0, DOUBLE_LITERAL110_tree); 4817 4818 } 4819 break; 4820 4821 } 4822 retval.stop = input.LT(-1); 4823 4824 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 4825 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 4826 4827 } 4828 catch (RecognitionException re) { 4829 reportError(re); 4830 recover(input,re); 4831 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 4832 } 4833 finally { 4834 // do for sure before leaving 4835 } 4836 return retval; 4837 } 4838 // $ANTLR end "double_literal" 4839 4840 4841 public static class literal_return extends ParserRuleReturnScope { 4842 CommonTree tree; 4843 @Override 4844 public CommonTree getTree() { return tree; } 4845 }; 4846 4847 4848 // $ANTLR start "literal" 4849 // smaliParser.g:625:1: literal : ( LONG_LITERAL | integer_literal | SHORT_LITERAL | BYTE_LITERAL | float_literal | double_literal | CHAR_LITERAL | STRING_LITERAL | BOOL_LITERAL | NULL_LITERAL | array_literal | subannotation | type_field_method_literal | enum_literal ); 4850 public final smaliParser.literal_return literal() throws RecognitionException { 4851 smaliParser.literal_return retval = new smaliParser.literal_return(); 4852 retval.start = input.LT(1); 4853 4854 CommonTree root_0 = null; 4855 4856 Token LONG_LITERAL111=null; 4857 Token SHORT_LITERAL113=null; 4858 Token BYTE_LITERAL114=null; 4859 Token CHAR_LITERAL117=null; 4860 Token STRING_LITERAL118=null; 4861 Token BOOL_LITERAL119=null; 4862 Token NULL_LITERAL120=null; 4863 ParserRuleReturnScope integer_literal112 =null; 4864 ParserRuleReturnScope float_literal115 =null; 4865 ParserRuleReturnScope double_literal116 =null; 4866 ParserRuleReturnScope array_literal121 =null; 4867 ParserRuleReturnScope subannotation122 =null; 4868 ParserRuleReturnScope type_field_method_literal123 =null; 4869 ParserRuleReturnScope enum_literal124 =null; 4870 4871 CommonTree LONG_LITERAL111_tree=null; 4872 CommonTree SHORT_LITERAL113_tree=null; 4873 CommonTree BYTE_LITERAL114_tree=null; 4874 CommonTree CHAR_LITERAL117_tree=null; 4875 CommonTree STRING_LITERAL118_tree=null; 4876 CommonTree BOOL_LITERAL119_tree=null; 4877 CommonTree NULL_LITERAL120_tree=null; 4878 4879 try { 4880 // smaliParser.g:626:3: ( LONG_LITERAL | integer_literal | SHORT_LITERAL | BYTE_LITERAL | float_literal | double_literal | CHAR_LITERAL | STRING_LITERAL | BOOL_LITERAL | NULL_LITERAL | array_literal | subannotation | type_field_method_literal | enum_literal ) 4881 int alt21=14; 4882 switch ( input.LA(1) ) { 4883 case LONG_LITERAL: 4884 { 4885 alt21=1; 4886 } 4887 break; 4888 case POSITIVE_INTEGER_LITERAL: 4889 { 4890 int LA21_2 = input.LA(2); 4891 if ( (LA21_2==EOF||(LA21_2 >= ACCESS_SPEC && LA21_2 <= ANNOTATION_VISIBILITY)||LA21_2==BOOL_LITERAL||(LA21_2 >= CLASS_DIRECTIVE && LA21_2 <= CLOSE_BRACE)||LA21_2==COMMA||(LA21_2 >= DOUBLE_LITERAL_OR_ID && LA21_2 <= END_ANNOTATION_DIRECTIVE)||LA21_2==END_FIELD_DIRECTIVE||LA21_2==END_SUBANNOTATION_DIRECTIVE||LA21_2==FIELD_DIRECTIVE||(LA21_2 >= FLOAT_LITERAL_OR_ID && LA21_2 <= IMPLEMENTS_DIRECTIVE)||(LA21_2 >= INSTRUCTION_FORMAT10t && LA21_2 <= INSTRUCTION_FORMAT10x_ODEX)||LA21_2==INSTRUCTION_FORMAT11x||LA21_2==INSTRUCTION_FORMAT12x_OR_ID||(LA21_2 >= INSTRUCTION_FORMAT21c_FIELD && LA21_2 <= INSTRUCTION_FORMAT21c_TYPE)||LA21_2==INSTRUCTION_FORMAT21t||(LA21_2 >= INSTRUCTION_FORMAT22c_FIELD && LA21_2 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA21_2 >= INSTRUCTION_FORMAT22s_OR_ID && LA21_2 <= INSTRUCTION_FORMAT22t)||LA21_2==INSTRUCTION_FORMAT23x||(LA21_2 >= INSTRUCTION_FORMAT31i_OR_ID && LA21_2 <= INSTRUCTION_FORMAT31t)||(LA21_2 >= INSTRUCTION_FORMAT35c_METHOD && LA21_2 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA21_2 >= INSTRUCTION_FORMAT45cc_METHOD && LA21_2 <= INSTRUCTION_FORMAT51l)||(LA21_2 >= METHOD_DIRECTIVE && LA21_2 <= NULL_LITERAL)||(LA21_2 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA21_2 <= PRIMITIVE_TYPE)||LA21_2==REGISTER||(LA21_2 >= SIMPLE_NAME && LA21_2 <= SOURCE_DIRECTIVE)||(LA21_2 >= SUPER_DIRECTIVE && LA21_2 <= VOID_TYPE)) ) { 4892 alt21=2; 4893 } 4894 else if ( (LA21_2==COLON||LA21_2==OPEN_PAREN) ) { 4895 alt21=13; 4896 } 4897 4898 else { 4899 int nvaeMark = input.mark(); 4900 try { 4901 input.consume(); 4902 NoViableAltException nvae = 4903 new NoViableAltException("", 21, 2, input); 4904 throw nvae; 4905 } finally { 4906 input.rewind(nvaeMark); 4907 } 4908 } 4909 4910 } 4911 break; 4912 case NEGATIVE_INTEGER_LITERAL: 4913 { 4914 int LA21_3 = input.LA(2); 4915 if ( (LA21_3==EOF||(LA21_3 >= ACCESS_SPEC && LA21_3 <= ANNOTATION_VISIBILITY)||LA21_3==BOOL_LITERAL||(LA21_3 >= CLASS_DIRECTIVE && LA21_3 <= CLOSE_BRACE)||LA21_3==COMMA||(LA21_3 >= DOUBLE_LITERAL_OR_ID && LA21_3 <= END_ANNOTATION_DIRECTIVE)||LA21_3==END_FIELD_DIRECTIVE||LA21_3==END_SUBANNOTATION_DIRECTIVE||LA21_3==FIELD_DIRECTIVE||(LA21_3 >= FLOAT_LITERAL_OR_ID && LA21_3 <= IMPLEMENTS_DIRECTIVE)||(LA21_3 >= INSTRUCTION_FORMAT10t && LA21_3 <= INSTRUCTION_FORMAT10x_ODEX)||LA21_3==INSTRUCTION_FORMAT11x||LA21_3==INSTRUCTION_FORMAT12x_OR_ID||(LA21_3 >= INSTRUCTION_FORMAT21c_FIELD && LA21_3 <= INSTRUCTION_FORMAT21c_TYPE)||LA21_3==INSTRUCTION_FORMAT21t||(LA21_3 >= INSTRUCTION_FORMAT22c_FIELD && LA21_3 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA21_3 >= INSTRUCTION_FORMAT22s_OR_ID && LA21_3 <= INSTRUCTION_FORMAT22t)||LA21_3==INSTRUCTION_FORMAT23x||(LA21_3 >= INSTRUCTION_FORMAT31i_OR_ID && LA21_3 <= INSTRUCTION_FORMAT31t)||(LA21_3 >= INSTRUCTION_FORMAT35c_METHOD && LA21_3 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA21_3 >= INSTRUCTION_FORMAT45cc_METHOD && LA21_3 <= INSTRUCTION_FORMAT51l)||(LA21_3 >= METHOD_DIRECTIVE && LA21_3 <= NULL_LITERAL)||(LA21_3 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA21_3 <= PRIMITIVE_TYPE)||LA21_3==REGISTER||(LA21_3 >= SIMPLE_NAME && LA21_3 <= SOURCE_DIRECTIVE)||(LA21_3 >= SUPER_DIRECTIVE && LA21_3 <= VOID_TYPE)) ) { 4916 alt21=2; 4917 } 4918 else if ( (LA21_3==COLON||LA21_3==OPEN_PAREN) ) { 4919 alt21=13; 4920 } 4921 4922 else { 4923 int nvaeMark = input.mark(); 4924 try { 4925 input.consume(); 4926 NoViableAltException nvae = 4927 new NoViableAltException("", 21, 3, input); 4928 throw nvae; 4929 } finally { 4930 input.rewind(nvaeMark); 4931 } 4932 } 4933 4934 } 4935 break; 4936 case SHORT_LITERAL: 4937 { 4938 alt21=3; 4939 } 4940 break; 4941 case BYTE_LITERAL: 4942 { 4943 alt21=4; 4944 } 4945 break; 4946 case FLOAT_LITERAL_OR_ID: 4947 { 4948 int LA21_6 = input.LA(2); 4949 if ( (LA21_6==EOF||(LA21_6 >= ACCESS_SPEC && LA21_6 <= ANNOTATION_VISIBILITY)||LA21_6==BOOL_LITERAL||(LA21_6 >= CLASS_DIRECTIVE && LA21_6 <= CLOSE_BRACE)||LA21_6==COMMA||(LA21_6 >= DOUBLE_LITERAL_OR_ID && LA21_6 <= END_ANNOTATION_DIRECTIVE)||LA21_6==END_FIELD_DIRECTIVE||LA21_6==END_SUBANNOTATION_DIRECTIVE||LA21_6==FIELD_DIRECTIVE||(LA21_6 >= FLOAT_LITERAL_OR_ID && LA21_6 <= IMPLEMENTS_DIRECTIVE)||(LA21_6 >= INSTRUCTION_FORMAT10t && LA21_6 <= INSTRUCTION_FORMAT10x_ODEX)||LA21_6==INSTRUCTION_FORMAT11x||LA21_6==INSTRUCTION_FORMAT12x_OR_ID||(LA21_6 >= INSTRUCTION_FORMAT21c_FIELD && LA21_6 <= INSTRUCTION_FORMAT21c_TYPE)||LA21_6==INSTRUCTION_FORMAT21t||(LA21_6 >= INSTRUCTION_FORMAT22c_FIELD && LA21_6 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA21_6 >= INSTRUCTION_FORMAT22s_OR_ID && LA21_6 <= INSTRUCTION_FORMAT22t)||LA21_6==INSTRUCTION_FORMAT23x||(LA21_6 >= INSTRUCTION_FORMAT31i_OR_ID && LA21_6 <= INSTRUCTION_FORMAT31t)||(LA21_6 >= INSTRUCTION_FORMAT35c_METHOD && LA21_6 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA21_6 >= INSTRUCTION_FORMAT45cc_METHOD && LA21_6 <= INSTRUCTION_FORMAT51l)||(LA21_6 >= METHOD_DIRECTIVE && LA21_6 <= NULL_LITERAL)||(LA21_6 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA21_6 <= PRIMITIVE_TYPE)||LA21_6==REGISTER||(LA21_6 >= SIMPLE_NAME && LA21_6 <= SOURCE_DIRECTIVE)||(LA21_6 >= SUPER_DIRECTIVE && LA21_6 <= VOID_TYPE)) ) { 4950 alt21=5; 4951 } 4952 else if ( (LA21_6==COLON||LA21_6==OPEN_PAREN) ) { 4953 alt21=13; 4954 } 4955 4956 else { 4957 int nvaeMark = input.mark(); 4958 try { 4959 input.consume(); 4960 NoViableAltException nvae = 4961 new NoViableAltException("", 21, 6, input); 4962 throw nvae; 4963 } finally { 4964 input.rewind(nvaeMark); 4965 } 4966 } 4967 4968 } 4969 break; 4970 case FLOAT_LITERAL: 4971 { 4972 alt21=5; 4973 } 4974 break; 4975 case DOUBLE_LITERAL_OR_ID: 4976 { 4977 int LA21_8 = input.LA(2); 4978 if ( (LA21_8==EOF||(LA21_8 >= ACCESS_SPEC && LA21_8 <= ANNOTATION_VISIBILITY)||LA21_8==BOOL_LITERAL||(LA21_8 >= CLASS_DIRECTIVE && LA21_8 <= CLOSE_BRACE)||LA21_8==COMMA||(LA21_8 >= DOUBLE_LITERAL_OR_ID && LA21_8 <= END_ANNOTATION_DIRECTIVE)||LA21_8==END_FIELD_DIRECTIVE||LA21_8==END_SUBANNOTATION_DIRECTIVE||LA21_8==FIELD_DIRECTIVE||(LA21_8 >= FLOAT_LITERAL_OR_ID && LA21_8 <= IMPLEMENTS_DIRECTIVE)||(LA21_8 >= INSTRUCTION_FORMAT10t && LA21_8 <= INSTRUCTION_FORMAT10x_ODEX)||LA21_8==INSTRUCTION_FORMAT11x||LA21_8==INSTRUCTION_FORMAT12x_OR_ID||(LA21_8 >= INSTRUCTION_FORMAT21c_FIELD && LA21_8 <= INSTRUCTION_FORMAT21c_TYPE)||LA21_8==INSTRUCTION_FORMAT21t||(LA21_8 >= INSTRUCTION_FORMAT22c_FIELD && LA21_8 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA21_8 >= INSTRUCTION_FORMAT22s_OR_ID && LA21_8 <= INSTRUCTION_FORMAT22t)||LA21_8==INSTRUCTION_FORMAT23x||(LA21_8 >= INSTRUCTION_FORMAT31i_OR_ID && LA21_8 <= INSTRUCTION_FORMAT31t)||(LA21_8 >= INSTRUCTION_FORMAT35c_METHOD && LA21_8 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA21_8 >= INSTRUCTION_FORMAT45cc_METHOD && LA21_8 <= INSTRUCTION_FORMAT51l)||(LA21_8 >= METHOD_DIRECTIVE && LA21_8 <= NULL_LITERAL)||(LA21_8 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA21_8 <= PRIMITIVE_TYPE)||LA21_8==REGISTER||(LA21_8 >= SIMPLE_NAME && LA21_8 <= SOURCE_DIRECTIVE)||(LA21_8 >= SUPER_DIRECTIVE && LA21_8 <= VOID_TYPE)) ) { 4979 alt21=6; 4980 } 4981 else if ( (LA21_8==COLON||LA21_8==OPEN_PAREN) ) { 4982 alt21=13; 4983 } 4984 4985 else { 4986 int nvaeMark = input.mark(); 4987 try { 4988 input.consume(); 4989 NoViableAltException nvae = 4990 new NoViableAltException("", 21, 8, input); 4991 throw nvae; 4992 } finally { 4993 input.rewind(nvaeMark); 4994 } 4995 } 4996 4997 } 4998 break; 4999 case DOUBLE_LITERAL: 5000 { 5001 alt21=6; 5002 } 5003 break; 5004 case CHAR_LITERAL: 5005 { 5006 alt21=7; 5007 } 5008 break; 5009 case STRING_LITERAL: 5010 { 5011 alt21=8; 5012 } 5013 break; 5014 case BOOL_LITERAL: 5015 { 5016 int LA21_12 = input.LA(2); 5017 if ( (LA21_12==EOF||(LA21_12 >= ACCESS_SPEC && LA21_12 <= ANNOTATION_VISIBILITY)||LA21_12==BOOL_LITERAL||(LA21_12 >= CLASS_DIRECTIVE && LA21_12 <= CLOSE_BRACE)||LA21_12==COMMA||(LA21_12 >= DOUBLE_LITERAL_OR_ID && LA21_12 <= END_ANNOTATION_DIRECTIVE)||LA21_12==END_FIELD_DIRECTIVE||LA21_12==END_SUBANNOTATION_DIRECTIVE||LA21_12==FIELD_DIRECTIVE||(LA21_12 >= FLOAT_LITERAL_OR_ID && LA21_12 <= IMPLEMENTS_DIRECTIVE)||(LA21_12 >= INSTRUCTION_FORMAT10t && LA21_12 <= INSTRUCTION_FORMAT10x_ODEX)||LA21_12==INSTRUCTION_FORMAT11x||LA21_12==INSTRUCTION_FORMAT12x_OR_ID||(LA21_12 >= INSTRUCTION_FORMAT21c_FIELD && LA21_12 <= INSTRUCTION_FORMAT21c_TYPE)||LA21_12==INSTRUCTION_FORMAT21t||(LA21_12 >= INSTRUCTION_FORMAT22c_FIELD && LA21_12 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA21_12 >= INSTRUCTION_FORMAT22s_OR_ID && LA21_12 <= INSTRUCTION_FORMAT22t)||LA21_12==INSTRUCTION_FORMAT23x||(LA21_12 >= INSTRUCTION_FORMAT31i_OR_ID && LA21_12 <= INSTRUCTION_FORMAT31t)||(LA21_12 >= INSTRUCTION_FORMAT35c_METHOD && LA21_12 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA21_12 >= INSTRUCTION_FORMAT45cc_METHOD && LA21_12 <= INSTRUCTION_FORMAT51l)||(LA21_12 >= METHOD_DIRECTIVE && LA21_12 <= NULL_LITERAL)||(LA21_12 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA21_12 <= PRIMITIVE_TYPE)||LA21_12==REGISTER||(LA21_12 >= SIMPLE_NAME && LA21_12 <= SOURCE_DIRECTIVE)||(LA21_12 >= SUPER_DIRECTIVE && LA21_12 <= VOID_TYPE)) ) { 5018 alt21=9; 5019 } 5020 else if ( (LA21_12==COLON||LA21_12==OPEN_PAREN) ) { 5021 alt21=13; 5022 } 5023 5024 else { 5025 int nvaeMark = input.mark(); 5026 try { 5027 input.consume(); 5028 NoViableAltException nvae = 5029 new NoViableAltException("", 21, 12, input); 5030 throw nvae; 5031 } finally { 5032 input.rewind(nvaeMark); 5033 } 5034 } 5035 5036 } 5037 break; 5038 case NULL_LITERAL: 5039 { 5040 int LA21_13 = input.LA(2); 5041 if ( (LA21_13==EOF||(LA21_13 >= ACCESS_SPEC && LA21_13 <= ANNOTATION_VISIBILITY)||LA21_13==BOOL_LITERAL||(LA21_13 >= CLASS_DIRECTIVE && LA21_13 <= CLOSE_BRACE)||LA21_13==COMMA||(LA21_13 >= DOUBLE_LITERAL_OR_ID && LA21_13 <= END_ANNOTATION_DIRECTIVE)||LA21_13==END_FIELD_DIRECTIVE||LA21_13==END_SUBANNOTATION_DIRECTIVE||LA21_13==FIELD_DIRECTIVE||(LA21_13 >= FLOAT_LITERAL_OR_ID && LA21_13 <= IMPLEMENTS_DIRECTIVE)||(LA21_13 >= INSTRUCTION_FORMAT10t && LA21_13 <= INSTRUCTION_FORMAT10x_ODEX)||LA21_13==INSTRUCTION_FORMAT11x||LA21_13==INSTRUCTION_FORMAT12x_OR_ID||(LA21_13 >= INSTRUCTION_FORMAT21c_FIELD && LA21_13 <= INSTRUCTION_FORMAT21c_TYPE)||LA21_13==INSTRUCTION_FORMAT21t||(LA21_13 >= INSTRUCTION_FORMAT22c_FIELD && LA21_13 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA21_13 >= INSTRUCTION_FORMAT22s_OR_ID && LA21_13 <= INSTRUCTION_FORMAT22t)||LA21_13==INSTRUCTION_FORMAT23x||(LA21_13 >= INSTRUCTION_FORMAT31i_OR_ID && LA21_13 <= INSTRUCTION_FORMAT31t)||(LA21_13 >= INSTRUCTION_FORMAT35c_METHOD && LA21_13 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA21_13 >= INSTRUCTION_FORMAT45cc_METHOD && LA21_13 <= INSTRUCTION_FORMAT51l)||(LA21_13 >= METHOD_DIRECTIVE && LA21_13 <= NULL_LITERAL)||(LA21_13 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA21_13 <= PRIMITIVE_TYPE)||LA21_13==REGISTER||(LA21_13 >= SIMPLE_NAME && LA21_13 <= SOURCE_DIRECTIVE)||(LA21_13 >= SUPER_DIRECTIVE && LA21_13 <= VOID_TYPE)) ) { 5042 alt21=10; 5043 } 5044 else if ( (LA21_13==COLON||LA21_13==OPEN_PAREN) ) { 5045 alt21=13; 5046 } 5047 5048 else { 5049 int nvaeMark = input.mark(); 5050 try { 5051 input.consume(); 5052 NoViableAltException nvae = 5053 new NoViableAltException("", 21, 13, input); 5054 throw nvae; 5055 } finally { 5056 input.rewind(nvaeMark); 5057 } 5058 } 5059 5060 } 5061 break; 5062 case OPEN_BRACE: 5063 { 5064 alt21=11; 5065 } 5066 break; 5067 case SUBANNOTATION_DIRECTIVE: 5068 { 5069 alt21=12; 5070 } 5071 break; 5072 case ACCESS_SPEC: 5073 case ANNOTATION_VISIBILITY: 5074 case ARRAY_TYPE_PREFIX: 5075 case CLASS_DESCRIPTOR: 5076 case INSTRUCTION_FORMAT10t: 5077 case INSTRUCTION_FORMAT10x: 5078 case INSTRUCTION_FORMAT10x_ODEX: 5079 case INSTRUCTION_FORMAT11x: 5080 case INSTRUCTION_FORMAT12x_OR_ID: 5081 case INSTRUCTION_FORMAT21c_FIELD: 5082 case INSTRUCTION_FORMAT21c_FIELD_ODEX: 5083 case INSTRUCTION_FORMAT21c_STRING: 5084 case INSTRUCTION_FORMAT21c_TYPE: 5085 case INSTRUCTION_FORMAT21t: 5086 case INSTRUCTION_FORMAT22c_FIELD: 5087 case INSTRUCTION_FORMAT22c_FIELD_ODEX: 5088 case INSTRUCTION_FORMAT22c_TYPE: 5089 case INSTRUCTION_FORMAT22cs_FIELD: 5090 case INSTRUCTION_FORMAT22s_OR_ID: 5091 case INSTRUCTION_FORMAT22t: 5092 case INSTRUCTION_FORMAT23x: 5093 case INSTRUCTION_FORMAT31i_OR_ID: 5094 case INSTRUCTION_FORMAT31t: 5095 case INSTRUCTION_FORMAT35c_METHOD: 5096 case INSTRUCTION_FORMAT35c_METHOD_ODEX: 5097 case INSTRUCTION_FORMAT35c_TYPE: 5098 case INSTRUCTION_FORMAT35mi_METHOD: 5099 case INSTRUCTION_FORMAT35ms_METHOD: 5100 case INSTRUCTION_FORMAT45cc_METHOD: 5101 case INSTRUCTION_FORMAT4rcc_METHOD: 5102 case INSTRUCTION_FORMAT51l: 5103 case MEMBER_NAME: 5104 case PARAM_LIST_OR_ID_PRIMITIVE_TYPE: 5105 case PRIMITIVE_TYPE: 5106 case REGISTER: 5107 case SIMPLE_NAME: 5108 case VERIFICATION_ERROR_TYPE: 5109 case VOID_TYPE: 5110 { 5111 alt21=13; 5112 } 5113 break; 5114 case ENUM_DIRECTIVE: 5115 { 5116 alt21=14; 5117 } 5118 break; 5119 default: 5120 NoViableAltException nvae = 5121 new NoViableAltException("", 21, 0, input); 5122 throw nvae; 5123 } 5124 switch (alt21) { 5125 case 1 : 5126 // smaliParser.g:626:5: LONG_LITERAL 5127 { 5128 root_0 = (CommonTree)adaptor.nil(); 5129 5130 5131 LONG_LITERAL111=(Token)match(input,LONG_LITERAL,FOLLOW_LONG_LITERAL_in_literal2468); 5132 LONG_LITERAL111_tree = (CommonTree)adaptor.create(LONG_LITERAL111); 5133 adaptor.addChild(root_0, LONG_LITERAL111_tree); 5134 5135 } 5136 break; 5137 case 2 : 5138 // smaliParser.g:627:5: integer_literal 5139 { 5140 root_0 = (CommonTree)adaptor.nil(); 5141 5142 5143 pushFollow(FOLLOW_integer_literal_in_literal2474); 5144 integer_literal112=integer_literal(); 5145 state._fsp--; 5146 5147 adaptor.addChild(root_0, integer_literal112.getTree()); 5148 5149 } 5150 break; 5151 case 3 : 5152 // smaliParser.g:628:5: SHORT_LITERAL 5153 { 5154 root_0 = (CommonTree)adaptor.nil(); 5155 5156 5157 SHORT_LITERAL113=(Token)match(input,SHORT_LITERAL,FOLLOW_SHORT_LITERAL_in_literal2480); 5158 SHORT_LITERAL113_tree = (CommonTree)adaptor.create(SHORT_LITERAL113); 5159 adaptor.addChild(root_0, SHORT_LITERAL113_tree); 5160 5161 } 5162 break; 5163 case 4 : 5164 // smaliParser.g:629:5: BYTE_LITERAL 5165 { 5166 root_0 = (CommonTree)adaptor.nil(); 5167 5168 5169 BYTE_LITERAL114=(Token)match(input,BYTE_LITERAL,FOLLOW_BYTE_LITERAL_in_literal2486); 5170 BYTE_LITERAL114_tree = (CommonTree)adaptor.create(BYTE_LITERAL114); 5171 adaptor.addChild(root_0, BYTE_LITERAL114_tree); 5172 5173 } 5174 break; 5175 case 5 : 5176 // smaliParser.g:630:5: float_literal 5177 { 5178 root_0 = (CommonTree)adaptor.nil(); 5179 5180 5181 pushFollow(FOLLOW_float_literal_in_literal2492); 5182 float_literal115=float_literal(); 5183 state._fsp--; 5184 5185 adaptor.addChild(root_0, float_literal115.getTree()); 5186 5187 } 5188 break; 5189 case 6 : 5190 // smaliParser.g:631:5: double_literal 5191 { 5192 root_0 = (CommonTree)adaptor.nil(); 5193 5194 5195 pushFollow(FOLLOW_double_literal_in_literal2498); 5196 double_literal116=double_literal(); 5197 state._fsp--; 5198 5199 adaptor.addChild(root_0, double_literal116.getTree()); 5200 5201 } 5202 break; 5203 case 7 : 5204 // smaliParser.g:632:5: CHAR_LITERAL 5205 { 5206 root_0 = (CommonTree)adaptor.nil(); 5207 5208 5209 CHAR_LITERAL117=(Token)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_literal2504); 5210 CHAR_LITERAL117_tree = (CommonTree)adaptor.create(CHAR_LITERAL117); 5211 adaptor.addChild(root_0, CHAR_LITERAL117_tree); 5212 5213 } 5214 break; 5215 case 8 : 5216 // smaliParser.g:633:5: STRING_LITERAL 5217 { 5218 root_0 = (CommonTree)adaptor.nil(); 5219 5220 5221 STRING_LITERAL118=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_literal2510); 5222 STRING_LITERAL118_tree = (CommonTree)adaptor.create(STRING_LITERAL118); 5223 adaptor.addChild(root_0, STRING_LITERAL118_tree); 5224 5225 } 5226 break; 5227 case 9 : 5228 // smaliParser.g:634:5: BOOL_LITERAL 5229 { 5230 root_0 = (CommonTree)adaptor.nil(); 5231 5232 5233 BOOL_LITERAL119=(Token)match(input,BOOL_LITERAL,FOLLOW_BOOL_LITERAL_in_literal2516); 5234 BOOL_LITERAL119_tree = (CommonTree)adaptor.create(BOOL_LITERAL119); 5235 adaptor.addChild(root_0, BOOL_LITERAL119_tree); 5236 5237 } 5238 break; 5239 case 10 : 5240 // smaliParser.g:635:5: NULL_LITERAL 5241 { 5242 root_0 = (CommonTree)adaptor.nil(); 5243 5244 5245 NULL_LITERAL120=(Token)match(input,NULL_LITERAL,FOLLOW_NULL_LITERAL_in_literal2522); 5246 NULL_LITERAL120_tree = (CommonTree)adaptor.create(NULL_LITERAL120); 5247 adaptor.addChild(root_0, NULL_LITERAL120_tree); 5248 5249 } 5250 break; 5251 case 11 : 5252 // smaliParser.g:636:5: array_literal 5253 { 5254 root_0 = (CommonTree)adaptor.nil(); 5255 5256 5257 pushFollow(FOLLOW_array_literal_in_literal2528); 5258 array_literal121=array_literal(); 5259 state._fsp--; 5260 5261 adaptor.addChild(root_0, array_literal121.getTree()); 5262 5263 } 5264 break; 5265 case 12 : 5266 // smaliParser.g:637:5: subannotation 5267 { 5268 root_0 = (CommonTree)adaptor.nil(); 5269 5270 5271 pushFollow(FOLLOW_subannotation_in_literal2534); 5272 subannotation122=subannotation(); 5273 state._fsp--; 5274 5275 adaptor.addChild(root_0, subannotation122.getTree()); 5276 5277 } 5278 break; 5279 case 13 : 5280 // smaliParser.g:638:5: type_field_method_literal 5281 { 5282 root_0 = (CommonTree)adaptor.nil(); 5283 5284 5285 pushFollow(FOLLOW_type_field_method_literal_in_literal2540); 5286 type_field_method_literal123=type_field_method_literal(); 5287 state._fsp--; 5288 5289 adaptor.addChild(root_0, type_field_method_literal123.getTree()); 5290 5291 } 5292 break; 5293 case 14 : 5294 // smaliParser.g:639:5: enum_literal 5295 { 5296 root_0 = (CommonTree)adaptor.nil(); 5297 5298 5299 pushFollow(FOLLOW_enum_literal_in_literal2546); 5300 enum_literal124=enum_literal(); 5301 state._fsp--; 5302 5303 adaptor.addChild(root_0, enum_literal124.getTree()); 5304 5305 } 5306 break; 5307 5308 } 5309 retval.stop = input.LT(-1); 5310 5311 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 5312 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 5313 5314 } 5315 catch (RecognitionException re) { 5316 reportError(re); 5317 recover(input,re); 5318 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 5319 } 5320 finally { 5321 // do for sure before leaving 5322 } 5323 return retval; 5324 } 5325 // $ANTLR end "literal" 5326 5327 5328 public static class parsed_integer_literal_return extends ParserRuleReturnScope { 5329 public int value; 5330 CommonTree tree; 5331 @Override 5332 public CommonTree getTree() { return tree; } 5333 }; 5334 5335 5336 // $ANTLR start "parsed_integer_literal" 5337 // smaliParser.g:641:1: parsed_integer_literal returns [int value] : integer_literal ; 5338 public final smaliParser.parsed_integer_literal_return parsed_integer_literal() throws RecognitionException { 5339 smaliParser.parsed_integer_literal_return retval = new smaliParser.parsed_integer_literal_return(); 5340 retval.start = input.LT(1); 5341 5342 CommonTree root_0 = null; 5343 5344 ParserRuleReturnScope integer_literal125 =null; 5345 5346 5347 try { 5348 // smaliParser.g:642:3: ( integer_literal ) 5349 // smaliParser.g:642:5: integer_literal 5350 { 5351 root_0 = (CommonTree)adaptor.nil(); 5352 5353 5354 pushFollow(FOLLOW_integer_literal_in_parsed_integer_literal2559); 5355 integer_literal125=integer_literal(); 5356 state._fsp--; 5357 5358 adaptor.addChild(root_0, integer_literal125.getTree()); 5359 5360 retval.value = LiteralTools.parseInt((integer_literal125!=null?input.toString(integer_literal125.start,integer_literal125.stop):null)); 5361 } 5362 5363 retval.stop = input.LT(-1); 5364 5365 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 5366 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 5367 5368 } 5369 catch (RecognitionException re) { 5370 reportError(re); 5371 recover(input,re); 5372 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 5373 } 5374 finally { 5375 // do for sure before leaving 5376 } 5377 return retval; 5378 } 5379 // $ANTLR end "parsed_integer_literal" 5380 5381 5382 public static class integral_literal_return extends ParserRuleReturnScope { 5383 CommonTree tree; 5384 @Override 5385 public CommonTree getTree() { return tree; } 5386 }; 5387 5388 5389 // $ANTLR start "integral_literal" 5390 // smaliParser.g:644:1: integral_literal : ( LONG_LITERAL | integer_literal | SHORT_LITERAL | CHAR_LITERAL | BYTE_LITERAL ); 5391 public final smaliParser.integral_literal_return integral_literal() throws RecognitionException { 5392 smaliParser.integral_literal_return retval = new smaliParser.integral_literal_return(); 5393 retval.start = input.LT(1); 5394 5395 CommonTree root_0 = null; 5396 5397 Token LONG_LITERAL126=null; 5398 Token SHORT_LITERAL128=null; 5399 Token CHAR_LITERAL129=null; 5400 Token BYTE_LITERAL130=null; 5401 ParserRuleReturnScope integer_literal127 =null; 5402 5403 CommonTree LONG_LITERAL126_tree=null; 5404 CommonTree SHORT_LITERAL128_tree=null; 5405 CommonTree CHAR_LITERAL129_tree=null; 5406 CommonTree BYTE_LITERAL130_tree=null; 5407 5408 try { 5409 // smaliParser.g:645:3: ( LONG_LITERAL | integer_literal | SHORT_LITERAL | CHAR_LITERAL | BYTE_LITERAL ) 5410 int alt22=5; 5411 switch ( input.LA(1) ) { 5412 case LONG_LITERAL: 5413 { 5414 alt22=1; 5415 } 5416 break; 5417 case NEGATIVE_INTEGER_LITERAL: 5418 case POSITIVE_INTEGER_LITERAL: 5419 { 5420 alt22=2; 5421 } 5422 break; 5423 case SHORT_LITERAL: 5424 { 5425 alt22=3; 5426 } 5427 break; 5428 case CHAR_LITERAL: 5429 { 5430 alt22=4; 5431 } 5432 break; 5433 case BYTE_LITERAL: 5434 { 5435 alt22=5; 5436 } 5437 break; 5438 default: 5439 NoViableAltException nvae = 5440 new NoViableAltException("", 22, 0, input); 5441 throw nvae; 5442 } 5443 switch (alt22) { 5444 case 1 : 5445 // smaliParser.g:645:5: LONG_LITERAL 5446 { 5447 root_0 = (CommonTree)adaptor.nil(); 5448 5449 5450 LONG_LITERAL126=(Token)match(input,LONG_LITERAL,FOLLOW_LONG_LITERAL_in_integral_literal2571); 5451 LONG_LITERAL126_tree = (CommonTree)adaptor.create(LONG_LITERAL126); 5452 adaptor.addChild(root_0, LONG_LITERAL126_tree); 5453 5454 } 5455 break; 5456 case 2 : 5457 // smaliParser.g:646:5: integer_literal 5458 { 5459 root_0 = (CommonTree)adaptor.nil(); 5460 5461 5462 pushFollow(FOLLOW_integer_literal_in_integral_literal2577); 5463 integer_literal127=integer_literal(); 5464 state._fsp--; 5465 5466 adaptor.addChild(root_0, integer_literal127.getTree()); 5467 5468 } 5469 break; 5470 case 3 : 5471 // smaliParser.g:647:5: SHORT_LITERAL 5472 { 5473 root_0 = (CommonTree)adaptor.nil(); 5474 5475 5476 SHORT_LITERAL128=(Token)match(input,SHORT_LITERAL,FOLLOW_SHORT_LITERAL_in_integral_literal2583); 5477 SHORT_LITERAL128_tree = (CommonTree)adaptor.create(SHORT_LITERAL128); 5478 adaptor.addChild(root_0, SHORT_LITERAL128_tree); 5479 5480 } 5481 break; 5482 case 4 : 5483 // smaliParser.g:648:5: CHAR_LITERAL 5484 { 5485 root_0 = (CommonTree)adaptor.nil(); 5486 5487 5488 CHAR_LITERAL129=(Token)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_integral_literal2589); 5489 CHAR_LITERAL129_tree = (CommonTree)adaptor.create(CHAR_LITERAL129); 5490 adaptor.addChild(root_0, CHAR_LITERAL129_tree); 5491 5492 } 5493 break; 5494 case 5 : 5495 // smaliParser.g:649:5: BYTE_LITERAL 5496 { 5497 root_0 = (CommonTree)adaptor.nil(); 5498 5499 5500 BYTE_LITERAL130=(Token)match(input,BYTE_LITERAL,FOLLOW_BYTE_LITERAL_in_integral_literal2595); 5501 BYTE_LITERAL130_tree = (CommonTree)adaptor.create(BYTE_LITERAL130); 5502 adaptor.addChild(root_0, BYTE_LITERAL130_tree); 5503 5504 } 5505 break; 5506 5507 } 5508 retval.stop = input.LT(-1); 5509 5510 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 5511 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 5512 5513 } 5514 catch (RecognitionException re) { 5515 reportError(re); 5516 recover(input,re); 5517 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 5518 } 5519 finally { 5520 // do for sure before leaving 5521 } 5522 return retval; 5523 } 5524 // $ANTLR end "integral_literal" 5525 5526 5527 public static class fixed_32bit_literal_return extends ParserRuleReturnScope { 5528 CommonTree tree; 5529 @Override 5530 public CommonTree getTree() { return tree; } 5531 }; 5532 5533 5534 // $ANTLR start "fixed_32bit_literal" 5535 // smaliParser.g:651:1: fixed_32bit_literal : ( LONG_LITERAL | integer_literal | SHORT_LITERAL | BYTE_LITERAL | float_literal | CHAR_LITERAL | BOOL_LITERAL ); 5536 public final smaliParser.fixed_32bit_literal_return fixed_32bit_literal() throws RecognitionException { 5537 smaliParser.fixed_32bit_literal_return retval = new smaliParser.fixed_32bit_literal_return(); 5538 retval.start = input.LT(1); 5539 5540 CommonTree root_0 = null; 5541 5542 Token LONG_LITERAL131=null; 5543 Token SHORT_LITERAL133=null; 5544 Token BYTE_LITERAL134=null; 5545 Token CHAR_LITERAL136=null; 5546 Token BOOL_LITERAL137=null; 5547 ParserRuleReturnScope integer_literal132 =null; 5548 ParserRuleReturnScope float_literal135 =null; 5549 5550 CommonTree LONG_LITERAL131_tree=null; 5551 CommonTree SHORT_LITERAL133_tree=null; 5552 CommonTree BYTE_LITERAL134_tree=null; 5553 CommonTree CHAR_LITERAL136_tree=null; 5554 CommonTree BOOL_LITERAL137_tree=null; 5555 5556 try { 5557 // smaliParser.g:652:3: ( LONG_LITERAL | integer_literal | SHORT_LITERAL | BYTE_LITERAL | float_literal | CHAR_LITERAL | BOOL_LITERAL ) 5558 int alt23=7; 5559 switch ( input.LA(1) ) { 5560 case LONG_LITERAL: 5561 { 5562 alt23=1; 5563 } 5564 break; 5565 case NEGATIVE_INTEGER_LITERAL: 5566 case POSITIVE_INTEGER_LITERAL: 5567 { 5568 alt23=2; 5569 } 5570 break; 5571 case SHORT_LITERAL: 5572 { 5573 alt23=3; 5574 } 5575 break; 5576 case BYTE_LITERAL: 5577 { 5578 alt23=4; 5579 } 5580 break; 5581 case FLOAT_LITERAL: 5582 case FLOAT_LITERAL_OR_ID: 5583 { 5584 alt23=5; 5585 } 5586 break; 5587 case CHAR_LITERAL: 5588 { 5589 alt23=6; 5590 } 5591 break; 5592 case BOOL_LITERAL: 5593 { 5594 alt23=7; 5595 } 5596 break; 5597 default: 5598 NoViableAltException nvae = 5599 new NoViableAltException("", 23, 0, input); 5600 throw nvae; 5601 } 5602 switch (alt23) { 5603 case 1 : 5604 // smaliParser.g:652:5: LONG_LITERAL 5605 { 5606 root_0 = (CommonTree)adaptor.nil(); 5607 5608 5609 LONG_LITERAL131=(Token)match(input,LONG_LITERAL,FOLLOW_LONG_LITERAL_in_fixed_32bit_literal2605); 5610 LONG_LITERAL131_tree = (CommonTree)adaptor.create(LONG_LITERAL131); 5611 adaptor.addChild(root_0, LONG_LITERAL131_tree); 5612 5613 } 5614 break; 5615 case 2 : 5616 // smaliParser.g:653:5: integer_literal 5617 { 5618 root_0 = (CommonTree)adaptor.nil(); 5619 5620 5621 pushFollow(FOLLOW_integer_literal_in_fixed_32bit_literal2611); 5622 integer_literal132=integer_literal(); 5623 state._fsp--; 5624 5625 adaptor.addChild(root_0, integer_literal132.getTree()); 5626 5627 } 5628 break; 5629 case 3 : 5630 // smaliParser.g:654:5: SHORT_LITERAL 5631 { 5632 root_0 = (CommonTree)adaptor.nil(); 5633 5634 5635 SHORT_LITERAL133=(Token)match(input,SHORT_LITERAL,FOLLOW_SHORT_LITERAL_in_fixed_32bit_literal2617); 5636 SHORT_LITERAL133_tree = (CommonTree)adaptor.create(SHORT_LITERAL133); 5637 adaptor.addChild(root_0, SHORT_LITERAL133_tree); 5638 5639 } 5640 break; 5641 case 4 : 5642 // smaliParser.g:655:5: BYTE_LITERAL 5643 { 5644 root_0 = (CommonTree)adaptor.nil(); 5645 5646 5647 BYTE_LITERAL134=(Token)match(input,BYTE_LITERAL,FOLLOW_BYTE_LITERAL_in_fixed_32bit_literal2623); 5648 BYTE_LITERAL134_tree = (CommonTree)adaptor.create(BYTE_LITERAL134); 5649 adaptor.addChild(root_0, BYTE_LITERAL134_tree); 5650 5651 } 5652 break; 5653 case 5 : 5654 // smaliParser.g:656:5: float_literal 5655 { 5656 root_0 = (CommonTree)adaptor.nil(); 5657 5658 5659 pushFollow(FOLLOW_float_literal_in_fixed_32bit_literal2629); 5660 float_literal135=float_literal(); 5661 state._fsp--; 5662 5663 adaptor.addChild(root_0, float_literal135.getTree()); 5664 5665 } 5666 break; 5667 case 6 : 5668 // smaliParser.g:657:5: CHAR_LITERAL 5669 { 5670 root_0 = (CommonTree)adaptor.nil(); 5671 5672 5673 CHAR_LITERAL136=(Token)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_fixed_32bit_literal2635); 5674 CHAR_LITERAL136_tree = (CommonTree)adaptor.create(CHAR_LITERAL136); 5675 adaptor.addChild(root_0, CHAR_LITERAL136_tree); 5676 5677 } 5678 break; 5679 case 7 : 5680 // smaliParser.g:658:5: BOOL_LITERAL 5681 { 5682 root_0 = (CommonTree)adaptor.nil(); 5683 5684 5685 BOOL_LITERAL137=(Token)match(input,BOOL_LITERAL,FOLLOW_BOOL_LITERAL_in_fixed_32bit_literal2641); 5686 BOOL_LITERAL137_tree = (CommonTree)adaptor.create(BOOL_LITERAL137); 5687 adaptor.addChild(root_0, BOOL_LITERAL137_tree); 5688 5689 } 5690 break; 5691 5692 } 5693 retval.stop = input.LT(-1); 5694 5695 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 5696 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 5697 5698 } 5699 catch (RecognitionException re) { 5700 reportError(re); 5701 recover(input,re); 5702 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 5703 } 5704 finally { 5705 // do for sure before leaving 5706 } 5707 return retval; 5708 } 5709 // $ANTLR end "fixed_32bit_literal" 5710 5711 5712 public static class fixed_literal_return extends ParserRuleReturnScope { 5713 CommonTree tree; 5714 @Override 5715 public CommonTree getTree() { return tree; } 5716 }; 5717 5718 5719 // $ANTLR start "fixed_literal" 5720 // smaliParser.g:660:1: fixed_literal : ( integer_literal | LONG_LITERAL | SHORT_LITERAL | BYTE_LITERAL | float_literal | double_literal | CHAR_LITERAL | BOOL_LITERAL ); 5721 public final smaliParser.fixed_literal_return fixed_literal() throws RecognitionException { 5722 smaliParser.fixed_literal_return retval = new smaliParser.fixed_literal_return(); 5723 retval.start = input.LT(1); 5724 5725 CommonTree root_0 = null; 5726 5727 Token LONG_LITERAL139=null; 5728 Token SHORT_LITERAL140=null; 5729 Token BYTE_LITERAL141=null; 5730 Token CHAR_LITERAL144=null; 5731 Token BOOL_LITERAL145=null; 5732 ParserRuleReturnScope integer_literal138 =null; 5733 ParserRuleReturnScope float_literal142 =null; 5734 ParserRuleReturnScope double_literal143 =null; 5735 5736 CommonTree LONG_LITERAL139_tree=null; 5737 CommonTree SHORT_LITERAL140_tree=null; 5738 CommonTree BYTE_LITERAL141_tree=null; 5739 CommonTree CHAR_LITERAL144_tree=null; 5740 CommonTree BOOL_LITERAL145_tree=null; 5741 5742 try { 5743 // smaliParser.g:661:3: ( integer_literal | LONG_LITERAL | SHORT_LITERAL | BYTE_LITERAL | float_literal | double_literal | CHAR_LITERAL | BOOL_LITERAL ) 5744 int alt24=8; 5745 switch ( input.LA(1) ) { 5746 case NEGATIVE_INTEGER_LITERAL: 5747 case POSITIVE_INTEGER_LITERAL: 5748 { 5749 alt24=1; 5750 } 5751 break; 5752 case LONG_LITERAL: 5753 { 5754 alt24=2; 5755 } 5756 break; 5757 case SHORT_LITERAL: 5758 { 5759 alt24=3; 5760 } 5761 break; 5762 case BYTE_LITERAL: 5763 { 5764 alt24=4; 5765 } 5766 break; 5767 case FLOAT_LITERAL: 5768 case FLOAT_LITERAL_OR_ID: 5769 { 5770 alt24=5; 5771 } 5772 break; 5773 case DOUBLE_LITERAL: 5774 case DOUBLE_LITERAL_OR_ID: 5775 { 5776 alt24=6; 5777 } 5778 break; 5779 case CHAR_LITERAL: 5780 { 5781 alt24=7; 5782 } 5783 break; 5784 case BOOL_LITERAL: 5785 { 5786 alt24=8; 5787 } 5788 break; 5789 default: 5790 NoViableAltException nvae = 5791 new NoViableAltException("", 24, 0, input); 5792 throw nvae; 5793 } 5794 switch (alt24) { 5795 case 1 : 5796 // smaliParser.g:661:5: integer_literal 5797 { 5798 root_0 = (CommonTree)adaptor.nil(); 5799 5800 5801 pushFollow(FOLLOW_integer_literal_in_fixed_literal2651); 5802 integer_literal138=integer_literal(); 5803 state._fsp--; 5804 5805 adaptor.addChild(root_0, integer_literal138.getTree()); 5806 5807 } 5808 break; 5809 case 2 : 5810 // smaliParser.g:662:5: LONG_LITERAL 5811 { 5812 root_0 = (CommonTree)adaptor.nil(); 5813 5814 5815 LONG_LITERAL139=(Token)match(input,LONG_LITERAL,FOLLOW_LONG_LITERAL_in_fixed_literal2657); 5816 LONG_LITERAL139_tree = (CommonTree)adaptor.create(LONG_LITERAL139); 5817 adaptor.addChild(root_0, LONG_LITERAL139_tree); 5818 5819 } 5820 break; 5821 case 3 : 5822 // smaliParser.g:663:5: SHORT_LITERAL 5823 { 5824 root_0 = (CommonTree)adaptor.nil(); 5825 5826 5827 SHORT_LITERAL140=(Token)match(input,SHORT_LITERAL,FOLLOW_SHORT_LITERAL_in_fixed_literal2663); 5828 SHORT_LITERAL140_tree = (CommonTree)adaptor.create(SHORT_LITERAL140); 5829 adaptor.addChild(root_0, SHORT_LITERAL140_tree); 5830 5831 } 5832 break; 5833 case 4 : 5834 // smaliParser.g:664:5: BYTE_LITERAL 5835 { 5836 root_0 = (CommonTree)adaptor.nil(); 5837 5838 5839 BYTE_LITERAL141=(Token)match(input,BYTE_LITERAL,FOLLOW_BYTE_LITERAL_in_fixed_literal2669); 5840 BYTE_LITERAL141_tree = (CommonTree)adaptor.create(BYTE_LITERAL141); 5841 adaptor.addChild(root_0, BYTE_LITERAL141_tree); 5842 5843 } 5844 break; 5845 case 5 : 5846 // smaliParser.g:665:5: float_literal 5847 { 5848 root_0 = (CommonTree)adaptor.nil(); 5849 5850 5851 pushFollow(FOLLOW_float_literal_in_fixed_literal2675); 5852 float_literal142=float_literal(); 5853 state._fsp--; 5854 5855 adaptor.addChild(root_0, float_literal142.getTree()); 5856 5857 } 5858 break; 5859 case 6 : 5860 // smaliParser.g:666:5: double_literal 5861 { 5862 root_0 = (CommonTree)adaptor.nil(); 5863 5864 5865 pushFollow(FOLLOW_double_literal_in_fixed_literal2681); 5866 double_literal143=double_literal(); 5867 state._fsp--; 5868 5869 adaptor.addChild(root_0, double_literal143.getTree()); 5870 5871 } 5872 break; 5873 case 7 : 5874 // smaliParser.g:667:5: CHAR_LITERAL 5875 { 5876 root_0 = (CommonTree)adaptor.nil(); 5877 5878 5879 CHAR_LITERAL144=(Token)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_fixed_literal2687); 5880 CHAR_LITERAL144_tree = (CommonTree)adaptor.create(CHAR_LITERAL144); 5881 adaptor.addChild(root_0, CHAR_LITERAL144_tree); 5882 5883 } 5884 break; 5885 case 8 : 5886 // smaliParser.g:668:5: BOOL_LITERAL 5887 { 5888 root_0 = (CommonTree)adaptor.nil(); 5889 5890 5891 BOOL_LITERAL145=(Token)match(input,BOOL_LITERAL,FOLLOW_BOOL_LITERAL_in_fixed_literal2693); 5892 BOOL_LITERAL145_tree = (CommonTree)adaptor.create(BOOL_LITERAL145); 5893 adaptor.addChild(root_0, BOOL_LITERAL145_tree); 5894 5895 } 5896 break; 5897 5898 } 5899 retval.stop = input.LT(-1); 5900 5901 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 5902 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 5903 5904 } 5905 catch (RecognitionException re) { 5906 reportError(re); 5907 recover(input,re); 5908 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 5909 } 5910 finally { 5911 // do for sure before leaving 5912 } 5913 return retval; 5914 } 5915 // $ANTLR end "fixed_literal" 5916 5917 5918 public static class array_literal_return extends ParserRuleReturnScope { 5919 CommonTree tree; 5920 @Override 5921 public CommonTree getTree() { return tree; } 5922 }; 5923 5924 5925 // $ANTLR start "array_literal" 5926 // smaliParser.g:670:1: array_literal : OPEN_BRACE ( literal ( COMMA literal )* |) CLOSE_BRACE -> ^( I_ENCODED_ARRAY[$start, \"I_ENCODED_ARRAY\"] ( literal )* ) ; 5927 public final smaliParser.array_literal_return array_literal() throws RecognitionException { 5928 smaliParser.array_literal_return retval = new smaliParser.array_literal_return(); 5929 retval.start = input.LT(1); 5930 5931 CommonTree root_0 = null; 5932 5933 Token OPEN_BRACE146=null; 5934 Token COMMA148=null; 5935 Token CLOSE_BRACE150=null; 5936 ParserRuleReturnScope literal147 =null; 5937 ParserRuleReturnScope literal149 =null; 5938 5939 CommonTree OPEN_BRACE146_tree=null; 5940 CommonTree COMMA148_tree=null; 5941 CommonTree CLOSE_BRACE150_tree=null; 5942 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 5943 RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE"); 5944 RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE"); 5945 RewriteRuleSubtreeStream stream_literal=new RewriteRuleSubtreeStream(adaptor,"rule literal"); 5946 5947 try { 5948 // smaliParser.g:671:3: ( OPEN_BRACE ( literal ( COMMA literal )* |) CLOSE_BRACE -> ^( I_ENCODED_ARRAY[$start, \"I_ENCODED_ARRAY\"] ( literal )* ) ) 5949 // smaliParser.g:671:5: OPEN_BRACE ( literal ( COMMA literal )* |) CLOSE_BRACE 5950 { 5951 OPEN_BRACE146=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_array_literal2703); 5952 stream_OPEN_BRACE.add(OPEN_BRACE146); 5953 5954 // smaliParser.g:671:16: ( literal ( COMMA literal )* |) 5955 int alt26=2; 5956 int LA26_0 = input.LA(1); 5957 if ( (LA26_0==ACCESS_SPEC||LA26_0==ANNOTATION_VISIBILITY||LA26_0==ARRAY_TYPE_PREFIX||(LA26_0 >= BOOL_LITERAL && LA26_0 <= BYTE_LITERAL)||(LA26_0 >= CHAR_LITERAL && LA26_0 <= CLASS_DESCRIPTOR)||(LA26_0 >= DOUBLE_LITERAL && LA26_0 <= DOUBLE_LITERAL_OR_ID)||LA26_0==ENUM_DIRECTIVE||(LA26_0 >= FLOAT_LITERAL && LA26_0 <= FLOAT_LITERAL_OR_ID)||(LA26_0 >= INSTRUCTION_FORMAT10t && LA26_0 <= INSTRUCTION_FORMAT10x_ODEX)||LA26_0==INSTRUCTION_FORMAT11x||LA26_0==INSTRUCTION_FORMAT12x_OR_ID||(LA26_0 >= INSTRUCTION_FORMAT21c_FIELD && LA26_0 <= INSTRUCTION_FORMAT21c_TYPE)||LA26_0==INSTRUCTION_FORMAT21t||(LA26_0 >= INSTRUCTION_FORMAT22c_FIELD && LA26_0 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA26_0 >= INSTRUCTION_FORMAT22s_OR_ID && LA26_0 <= INSTRUCTION_FORMAT22t)||LA26_0==INSTRUCTION_FORMAT23x||(LA26_0 >= INSTRUCTION_FORMAT31i_OR_ID && LA26_0 <= INSTRUCTION_FORMAT31t)||(LA26_0 >= INSTRUCTION_FORMAT35c_METHOD && LA26_0 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA26_0 >= INSTRUCTION_FORMAT45cc_METHOD && LA26_0 <= INSTRUCTION_FORMAT51l)||(LA26_0 >= LONG_LITERAL && LA26_0 <= MEMBER_NAME)||(LA26_0 >= NEGATIVE_INTEGER_LITERAL && LA26_0 <= OPEN_BRACE)||(LA26_0 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA26_0 <= PRIMITIVE_TYPE)||LA26_0==REGISTER||(LA26_0 >= SHORT_LITERAL && LA26_0 <= SIMPLE_NAME)||(LA26_0 >= STRING_LITERAL && LA26_0 <= SUBANNOTATION_DIRECTIVE)||(LA26_0 >= VERIFICATION_ERROR_TYPE && LA26_0 <= VOID_TYPE)) ) { 5958 alt26=1; 5959 } 5960 else if ( (LA26_0==CLOSE_BRACE) ) { 5961 alt26=2; 5962 } 5963 5964 else { 5965 NoViableAltException nvae = 5966 new NoViableAltException("", 26, 0, input); 5967 throw nvae; 5968 } 5969 5970 switch (alt26) { 5971 case 1 : 5972 // smaliParser.g:671:17: literal ( COMMA literal )* 5973 { 5974 pushFollow(FOLLOW_literal_in_array_literal2706); 5975 literal147=literal(); 5976 state._fsp--; 5977 5978 stream_literal.add(literal147.getTree()); 5979 // smaliParser.g:671:25: ( COMMA literal )* 5980 loop25: 5981 while (true) { 5982 int alt25=2; 5983 int LA25_0 = input.LA(1); 5984 if ( (LA25_0==COMMA) ) { 5985 alt25=1; 5986 } 5987 5988 switch (alt25) { 5989 case 1 : 5990 // smaliParser.g:671:26: COMMA literal 5991 { 5992 COMMA148=(Token)match(input,COMMA,FOLLOW_COMMA_in_array_literal2709); 5993 stream_COMMA.add(COMMA148); 5994 5995 pushFollow(FOLLOW_literal_in_array_literal2711); 5996 literal149=literal(); 5997 state._fsp--; 5998 5999 stream_literal.add(literal149.getTree()); 6000 } 6001 break; 6002 6003 default : 6004 break loop25; 6005 } 6006 } 6007 6008 } 6009 break; 6010 case 2 : 6011 // smaliParser.g:671:44: 6012 { 6013 } 6014 break; 6015 6016 } 6017 6018 CLOSE_BRACE150=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_array_literal2719); 6019 stream_CLOSE_BRACE.add(CLOSE_BRACE150); 6020 6021 // AST REWRITE 6022 // elements: literal 6023 // token labels: 6024 // rule labels: retval 6025 // token list labels: 6026 // rule list labels: 6027 // wildcard labels: 6028 retval.tree = root_0; 6029 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 6030 6031 root_0 = (CommonTree)adaptor.nil(); 6032 // 672:5: -> ^( I_ENCODED_ARRAY[$start, \"I_ENCODED_ARRAY\"] ( literal )* ) 6033 { 6034 // smaliParser.g:672:8: ^( I_ENCODED_ARRAY[$start, \"I_ENCODED_ARRAY\"] ( literal )* ) 6035 { 6036 CommonTree root_1 = (CommonTree)adaptor.nil(); 6037 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ENCODED_ARRAY, (retval.start), "I_ENCODED_ARRAY"), root_1); 6038 // smaliParser.g:672:53: ( literal )* 6039 while ( stream_literal.hasNext() ) { 6040 adaptor.addChild(root_1, stream_literal.nextTree()); 6041 } 6042 stream_literal.reset(); 6043 6044 adaptor.addChild(root_0, root_1); 6045 } 6046 6047 } 6048 6049 6050 retval.tree = root_0; 6051 6052 } 6053 6054 retval.stop = input.LT(-1); 6055 6056 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 6057 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 6058 6059 } 6060 catch (RecognitionException re) { 6061 reportError(re); 6062 recover(input,re); 6063 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 6064 } 6065 finally { 6066 // do for sure before leaving 6067 } 6068 return retval; 6069 } 6070 // $ANTLR end "array_literal" 6071 6072 6073 public static class annotation_element_return extends ParserRuleReturnScope { 6074 CommonTree tree; 6075 @Override 6076 public CommonTree getTree() { return tree; } 6077 }; 6078 6079 6080 // $ANTLR start "annotation_element" 6081 // smaliParser.g:674:1: annotation_element : simple_name EQUAL literal -> ^( I_ANNOTATION_ELEMENT[$start, \"I_ANNOTATION_ELEMENT\"] simple_name literal ) ; 6082 public final smaliParser.annotation_element_return annotation_element() throws RecognitionException { 6083 smaliParser.annotation_element_return retval = new smaliParser.annotation_element_return(); 6084 retval.start = input.LT(1); 6085 6086 CommonTree root_0 = null; 6087 6088 Token EQUAL152=null; 6089 ParserRuleReturnScope simple_name151 =null; 6090 ParserRuleReturnScope literal153 =null; 6091 6092 CommonTree EQUAL152_tree=null; 6093 RewriteRuleTokenStream stream_EQUAL=new RewriteRuleTokenStream(adaptor,"token EQUAL"); 6094 RewriteRuleSubtreeStream stream_simple_name=new RewriteRuleSubtreeStream(adaptor,"rule simple_name"); 6095 RewriteRuleSubtreeStream stream_literal=new RewriteRuleSubtreeStream(adaptor,"rule literal"); 6096 6097 try { 6098 // smaliParser.g:675:3: ( simple_name EQUAL literal -> ^( I_ANNOTATION_ELEMENT[$start, \"I_ANNOTATION_ELEMENT\"] simple_name literal ) ) 6099 // smaliParser.g:675:5: simple_name EQUAL literal 6100 { 6101 pushFollow(FOLLOW_simple_name_in_annotation_element2743); 6102 simple_name151=simple_name(); 6103 state._fsp--; 6104 6105 stream_simple_name.add(simple_name151.getTree()); 6106 EQUAL152=(Token)match(input,EQUAL,FOLLOW_EQUAL_in_annotation_element2745); 6107 stream_EQUAL.add(EQUAL152); 6108 6109 pushFollow(FOLLOW_literal_in_annotation_element2747); 6110 literal153=literal(); 6111 state._fsp--; 6112 6113 stream_literal.add(literal153.getTree()); 6114 // AST REWRITE 6115 // elements: simple_name, literal 6116 // token labels: 6117 // rule labels: retval 6118 // token list labels: 6119 // rule list labels: 6120 // wildcard labels: 6121 retval.tree = root_0; 6122 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 6123 6124 root_0 = (CommonTree)adaptor.nil(); 6125 // 676:5: -> ^( I_ANNOTATION_ELEMENT[$start, \"I_ANNOTATION_ELEMENT\"] simple_name literal ) 6126 { 6127 // smaliParser.g:676:8: ^( I_ANNOTATION_ELEMENT[$start, \"I_ANNOTATION_ELEMENT\"] simple_name literal ) 6128 { 6129 CommonTree root_1 = (CommonTree)adaptor.nil(); 6130 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ANNOTATION_ELEMENT, (retval.start), "I_ANNOTATION_ELEMENT"), root_1); 6131 adaptor.addChild(root_1, stream_simple_name.nextTree()); 6132 adaptor.addChild(root_1, stream_literal.nextTree()); 6133 adaptor.addChild(root_0, root_1); 6134 } 6135 6136 } 6137 6138 6139 retval.tree = root_0; 6140 6141 } 6142 6143 retval.stop = input.LT(-1); 6144 6145 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 6146 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 6147 6148 } 6149 catch (RecognitionException re) { 6150 reportError(re); 6151 recover(input,re); 6152 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 6153 } 6154 finally { 6155 // do for sure before leaving 6156 } 6157 return retval; 6158 } 6159 // $ANTLR end "annotation_element" 6160 6161 6162 public static class annotation_return extends ParserRuleReturnScope { 6163 CommonTree tree; 6164 @Override 6165 public CommonTree getTree() { return tree; } 6166 }; 6167 6168 6169 // $ANTLR start "annotation" 6170 // smaliParser.g:678:1: annotation : ANNOTATION_DIRECTIVE ANNOTATION_VISIBILITY CLASS_DESCRIPTOR ( annotation_element )* END_ANNOTATION_DIRECTIVE -> ^( I_ANNOTATION[$start, \"I_ANNOTATION\"] ANNOTATION_VISIBILITY ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) ) ; 6171 public final smaliParser.annotation_return annotation() throws RecognitionException { 6172 smaliParser.annotation_return retval = new smaliParser.annotation_return(); 6173 retval.start = input.LT(1); 6174 6175 CommonTree root_0 = null; 6176 6177 Token ANNOTATION_DIRECTIVE154=null; 6178 Token ANNOTATION_VISIBILITY155=null; 6179 Token CLASS_DESCRIPTOR156=null; 6180 Token END_ANNOTATION_DIRECTIVE158=null; 6181 ParserRuleReturnScope annotation_element157 =null; 6182 6183 CommonTree ANNOTATION_DIRECTIVE154_tree=null; 6184 CommonTree ANNOTATION_VISIBILITY155_tree=null; 6185 CommonTree CLASS_DESCRIPTOR156_tree=null; 6186 CommonTree END_ANNOTATION_DIRECTIVE158_tree=null; 6187 RewriteRuleTokenStream stream_ANNOTATION_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token ANNOTATION_DIRECTIVE"); 6188 RewriteRuleTokenStream stream_ANNOTATION_VISIBILITY=new RewriteRuleTokenStream(adaptor,"token ANNOTATION_VISIBILITY"); 6189 RewriteRuleTokenStream stream_CLASS_DESCRIPTOR=new RewriteRuleTokenStream(adaptor,"token CLASS_DESCRIPTOR"); 6190 RewriteRuleTokenStream stream_END_ANNOTATION_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_ANNOTATION_DIRECTIVE"); 6191 RewriteRuleSubtreeStream stream_annotation_element=new RewriteRuleSubtreeStream(adaptor,"rule annotation_element"); 6192 6193 try { 6194 // smaliParser.g:679:3: ( ANNOTATION_DIRECTIVE ANNOTATION_VISIBILITY CLASS_DESCRIPTOR ( annotation_element )* END_ANNOTATION_DIRECTIVE -> ^( I_ANNOTATION[$start, \"I_ANNOTATION\"] ANNOTATION_VISIBILITY ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) ) ) 6195 // smaliParser.g:679:5: ANNOTATION_DIRECTIVE ANNOTATION_VISIBILITY CLASS_DESCRIPTOR ( annotation_element )* END_ANNOTATION_DIRECTIVE 6196 { 6197 ANNOTATION_DIRECTIVE154=(Token)match(input,ANNOTATION_DIRECTIVE,FOLLOW_ANNOTATION_DIRECTIVE_in_annotation2772); 6198 stream_ANNOTATION_DIRECTIVE.add(ANNOTATION_DIRECTIVE154); 6199 6200 ANNOTATION_VISIBILITY155=(Token)match(input,ANNOTATION_VISIBILITY,FOLLOW_ANNOTATION_VISIBILITY_in_annotation2774); 6201 stream_ANNOTATION_VISIBILITY.add(ANNOTATION_VISIBILITY155); 6202 6203 CLASS_DESCRIPTOR156=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_annotation2776); 6204 stream_CLASS_DESCRIPTOR.add(CLASS_DESCRIPTOR156); 6205 6206 // smaliParser.g:680:5: ( annotation_element )* 6207 loop27: 6208 while (true) { 6209 int alt27=2; 6210 int LA27_0 = input.LA(1); 6211 if ( (LA27_0==ACCESS_SPEC||LA27_0==ANNOTATION_VISIBILITY||LA27_0==BOOL_LITERAL||LA27_0==DOUBLE_LITERAL_OR_ID||LA27_0==FLOAT_LITERAL_OR_ID||(LA27_0 >= INSTRUCTION_FORMAT10t && LA27_0 <= INSTRUCTION_FORMAT10x_ODEX)||LA27_0==INSTRUCTION_FORMAT11x||LA27_0==INSTRUCTION_FORMAT12x_OR_ID||(LA27_0 >= INSTRUCTION_FORMAT21c_FIELD && LA27_0 <= INSTRUCTION_FORMAT21c_TYPE)||LA27_0==INSTRUCTION_FORMAT21t||(LA27_0 >= INSTRUCTION_FORMAT22c_FIELD && LA27_0 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA27_0 >= INSTRUCTION_FORMAT22s_OR_ID && LA27_0 <= INSTRUCTION_FORMAT22t)||LA27_0==INSTRUCTION_FORMAT23x||(LA27_0 >= INSTRUCTION_FORMAT31i_OR_ID && LA27_0 <= INSTRUCTION_FORMAT31t)||(LA27_0 >= INSTRUCTION_FORMAT35c_METHOD && LA27_0 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA27_0 >= INSTRUCTION_FORMAT45cc_METHOD && LA27_0 <= INSTRUCTION_FORMAT51l)||(LA27_0 >= NEGATIVE_INTEGER_LITERAL && LA27_0 <= NULL_LITERAL)||(LA27_0 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA27_0 <= PRIMITIVE_TYPE)||LA27_0==REGISTER||LA27_0==SIMPLE_NAME||(LA27_0 >= VERIFICATION_ERROR_TYPE && LA27_0 <= VOID_TYPE)) ) { 6212 alt27=1; 6213 } 6214 6215 switch (alt27) { 6216 case 1 : 6217 // smaliParser.g:680:5: annotation_element 6218 { 6219 pushFollow(FOLLOW_annotation_element_in_annotation2782); 6220 annotation_element157=annotation_element(); 6221 state._fsp--; 6222 6223 stream_annotation_element.add(annotation_element157.getTree()); 6224 } 6225 break; 6226 6227 default : 6228 break loop27; 6229 } 6230 } 6231 6232 END_ANNOTATION_DIRECTIVE158=(Token)match(input,END_ANNOTATION_DIRECTIVE,FOLLOW_END_ANNOTATION_DIRECTIVE_in_annotation2785); 6233 stream_END_ANNOTATION_DIRECTIVE.add(END_ANNOTATION_DIRECTIVE158); 6234 6235 // AST REWRITE 6236 // elements: CLASS_DESCRIPTOR, annotation_element, ANNOTATION_VISIBILITY 6237 // token labels: 6238 // rule labels: retval 6239 // token list labels: 6240 // rule list labels: 6241 // wildcard labels: 6242 retval.tree = root_0; 6243 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 6244 6245 root_0 = (CommonTree)adaptor.nil(); 6246 // 681:5: -> ^( I_ANNOTATION[$start, \"I_ANNOTATION\"] ANNOTATION_VISIBILITY ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) ) 6247 { 6248 // smaliParser.g:681:8: ^( I_ANNOTATION[$start, \"I_ANNOTATION\"] ANNOTATION_VISIBILITY ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) ) 6249 { 6250 CommonTree root_1 = (CommonTree)adaptor.nil(); 6251 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ANNOTATION, (retval.start), "I_ANNOTATION"), root_1); 6252 adaptor.addChild(root_1, stream_ANNOTATION_VISIBILITY.nextNode()); 6253 // smaliParser.g:681:69: ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) 6254 { 6255 CommonTree root_2 = (CommonTree)adaptor.nil(); 6256 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_SUBANNOTATION, (retval.start), "I_SUBANNOTATION"), root_2); 6257 adaptor.addChild(root_2, stream_CLASS_DESCRIPTOR.nextNode()); 6258 // smaliParser.g:681:131: ( annotation_element )* 6259 while ( stream_annotation_element.hasNext() ) { 6260 adaptor.addChild(root_2, stream_annotation_element.nextTree()); 6261 } 6262 stream_annotation_element.reset(); 6263 6264 adaptor.addChild(root_1, root_2); 6265 } 6266 6267 adaptor.addChild(root_0, root_1); 6268 } 6269 6270 } 6271 6272 6273 retval.tree = root_0; 6274 6275 } 6276 6277 retval.stop = input.LT(-1); 6278 6279 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 6280 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 6281 6282 } 6283 catch (RecognitionException re) { 6284 reportError(re); 6285 recover(input,re); 6286 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 6287 } 6288 finally { 6289 // do for sure before leaving 6290 } 6291 return retval; 6292 } 6293 // $ANTLR end "annotation" 6294 6295 6296 public static class subannotation_return extends ParserRuleReturnScope { 6297 CommonTree tree; 6298 @Override 6299 public CommonTree getTree() { return tree; } 6300 }; 6301 6302 6303 // $ANTLR start "subannotation" 6304 // smaliParser.g:683:1: subannotation : SUBANNOTATION_DIRECTIVE CLASS_DESCRIPTOR ( annotation_element )* END_SUBANNOTATION_DIRECTIVE -> ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) ; 6305 public final smaliParser.subannotation_return subannotation() throws RecognitionException { 6306 smaliParser.subannotation_return retval = new smaliParser.subannotation_return(); 6307 retval.start = input.LT(1); 6308 6309 CommonTree root_0 = null; 6310 6311 Token SUBANNOTATION_DIRECTIVE159=null; 6312 Token CLASS_DESCRIPTOR160=null; 6313 Token END_SUBANNOTATION_DIRECTIVE162=null; 6314 ParserRuleReturnScope annotation_element161 =null; 6315 6316 CommonTree SUBANNOTATION_DIRECTIVE159_tree=null; 6317 CommonTree CLASS_DESCRIPTOR160_tree=null; 6318 CommonTree END_SUBANNOTATION_DIRECTIVE162_tree=null; 6319 RewriteRuleTokenStream stream_SUBANNOTATION_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token SUBANNOTATION_DIRECTIVE"); 6320 RewriteRuleTokenStream stream_CLASS_DESCRIPTOR=new RewriteRuleTokenStream(adaptor,"token CLASS_DESCRIPTOR"); 6321 RewriteRuleTokenStream stream_END_SUBANNOTATION_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_SUBANNOTATION_DIRECTIVE"); 6322 RewriteRuleSubtreeStream stream_annotation_element=new RewriteRuleSubtreeStream(adaptor,"rule annotation_element"); 6323 6324 try { 6325 // smaliParser.g:684:3: ( SUBANNOTATION_DIRECTIVE CLASS_DESCRIPTOR ( annotation_element )* END_SUBANNOTATION_DIRECTIVE -> ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) ) 6326 // smaliParser.g:684:5: SUBANNOTATION_DIRECTIVE CLASS_DESCRIPTOR ( annotation_element )* END_SUBANNOTATION_DIRECTIVE 6327 { 6328 SUBANNOTATION_DIRECTIVE159=(Token)match(input,SUBANNOTATION_DIRECTIVE,FOLLOW_SUBANNOTATION_DIRECTIVE_in_subannotation2818); 6329 stream_SUBANNOTATION_DIRECTIVE.add(SUBANNOTATION_DIRECTIVE159); 6330 6331 CLASS_DESCRIPTOR160=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_subannotation2820); 6332 stream_CLASS_DESCRIPTOR.add(CLASS_DESCRIPTOR160); 6333 6334 // smaliParser.g:684:46: ( annotation_element )* 6335 loop28: 6336 while (true) { 6337 int alt28=2; 6338 int LA28_0 = input.LA(1); 6339 if ( (LA28_0==ACCESS_SPEC||LA28_0==ANNOTATION_VISIBILITY||LA28_0==BOOL_LITERAL||LA28_0==DOUBLE_LITERAL_OR_ID||LA28_0==FLOAT_LITERAL_OR_ID||(LA28_0 >= INSTRUCTION_FORMAT10t && LA28_0 <= INSTRUCTION_FORMAT10x_ODEX)||LA28_0==INSTRUCTION_FORMAT11x||LA28_0==INSTRUCTION_FORMAT12x_OR_ID||(LA28_0 >= INSTRUCTION_FORMAT21c_FIELD && LA28_0 <= INSTRUCTION_FORMAT21c_TYPE)||LA28_0==INSTRUCTION_FORMAT21t||(LA28_0 >= INSTRUCTION_FORMAT22c_FIELD && LA28_0 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA28_0 >= INSTRUCTION_FORMAT22s_OR_ID && LA28_0 <= INSTRUCTION_FORMAT22t)||LA28_0==INSTRUCTION_FORMAT23x||(LA28_0 >= INSTRUCTION_FORMAT31i_OR_ID && LA28_0 <= INSTRUCTION_FORMAT31t)||(LA28_0 >= INSTRUCTION_FORMAT35c_METHOD && LA28_0 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA28_0 >= INSTRUCTION_FORMAT45cc_METHOD && LA28_0 <= INSTRUCTION_FORMAT51l)||(LA28_0 >= NEGATIVE_INTEGER_LITERAL && LA28_0 <= NULL_LITERAL)||(LA28_0 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA28_0 <= PRIMITIVE_TYPE)||LA28_0==REGISTER||LA28_0==SIMPLE_NAME||(LA28_0 >= VERIFICATION_ERROR_TYPE && LA28_0 <= VOID_TYPE)) ) { 6340 alt28=1; 6341 } 6342 6343 switch (alt28) { 6344 case 1 : 6345 // smaliParser.g:684:46: annotation_element 6346 { 6347 pushFollow(FOLLOW_annotation_element_in_subannotation2822); 6348 annotation_element161=annotation_element(); 6349 state._fsp--; 6350 6351 stream_annotation_element.add(annotation_element161.getTree()); 6352 } 6353 break; 6354 6355 default : 6356 break loop28; 6357 } 6358 } 6359 6360 END_SUBANNOTATION_DIRECTIVE162=(Token)match(input,END_SUBANNOTATION_DIRECTIVE,FOLLOW_END_SUBANNOTATION_DIRECTIVE_in_subannotation2825); 6361 stream_END_SUBANNOTATION_DIRECTIVE.add(END_SUBANNOTATION_DIRECTIVE162); 6362 6363 // AST REWRITE 6364 // elements: CLASS_DESCRIPTOR, annotation_element 6365 // token labels: 6366 // rule labels: retval 6367 // token list labels: 6368 // rule list labels: 6369 // wildcard labels: 6370 retval.tree = root_0; 6371 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 6372 6373 root_0 = (CommonTree)adaptor.nil(); 6374 // 685:5: -> ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) 6375 { 6376 // smaliParser.g:685:8: ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) 6377 { 6378 CommonTree root_1 = (CommonTree)adaptor.nil(); 6379 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_SUBANNOTATION, (retval.start), "I_SUBANNOTATION"), root_1); 6380 adaptor.addChild(root_1, stream_CLASS_DESCRIPTOR.nextNode()); 6381 // smaliParser.g:685:70: ( annotation_element )* 6382 while ( stream_annotation_element.hasNext() ) { 6383 adaptor.addChild(root_1, stream_annotation_element.nextTree()); 6384 } 6385 stream_annotation_element.reset(); 6386 6387 adaptor.addChild(root_0, root_1); 6388 } 6389 6390 } 6391 6392 6393 retval.tree = root_0; 6394 6395 } 6396 6397 retval.stop = input.LT(-1); 6398 6399 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 6400 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 6401 6402 } 6403 catch (RecognitionException re) { 6404 reportError(re); 6405 recover(input,re); 6406 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 6407 } 6408 finally { 6409 // do for sure before leaving 6410 } 6411 return retval; 6412 } 6413 // $ANTLR end "subannotation" 6414 6415 6416 public static class enum_literal_return extends ParserRuleReturnScope { 6417 CommonTree tree; 6418 @Override 6419 public CommonTree getTree() { return tree; } 6420 }; 6421 6422 6423 // $ANTLR start "enum_literal" 6424 // smaliParser.g:688:1: enum_literal : ENUM_DIRECTIVE field_reference -> ^( I_ENCODED_ENUM field_reference ) ; 6425 public final smaliParser.enum_literal_return enum_literal() throws RecognitionException { 6426 smaliParser.enum_literal_return retval = new smaliParser.enum_literal_return(); 6427 retval.start = input.LT(1); 6428 6429 CommonTree root_0 = null; 6430 6431 Token ENUM_DIRECTIVE163=null; 6432 ParserRuleReturnScope field_reference164 =null; 6433 6434 CommonTree ENUM_DIRECTIVE163_tree=null; 6435 RewriteRuleTokenStream stream_ENUM_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token ENUM_DIRECTIVE"); 6436 RewriteRuleSubtreeStream stream_field_reference=new RewriteRuleSubtreeStream(adaptor,"rule field_reference"); 6437 6438 try { 6439 // smaliParser.g:689:3: ( ENUM_DIRECTIVE field_reference -> ^( I_ENCODED_ENUM field_reference ) ) 6440 // smaliParser.g:689:5: ENUM_DIRECTIVE field_reference 6441 { 6442 ENUM_DIRECTIVE163=(Token)match(input,ENUM_DIRECTIVE,FOLLOW_ENUM_DIRECTIVE_in_enum_literal2852); 6443 stream_ENUM_DIRECTIVE.add(ENUM_DIRECTIVE163); 6444 6445 pushFollow(FOLLOW_field_reference_in_enum_literal2854); 6446 field_reference164=field_reference(); 6447 state._fsp--; 6448 6449 stream_field_reference.add(field_reference164.getTree()); 6450 // AST REWRITE 6451 // elements: field_reference 6452 // token labels: 6453 // rule labels: retval 6454 // token list labels: 6455 // rule list labels: 6456 // wildcard labels: 6457 retval.tree = root_0; 6458 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 6459 6460 root_0 = (CommonTree)adaptor.nil(); 6461 // 690:3: -> ^( I_ENCODED_ENUM field_reference ) 6462 { 6463 // smaliParser.g:690:6: ^( I_ENCODED_ENUM field_reference ) 6464 { 6465 CommonTree root_1 = (CommonTree)adaptor.nil(); 6466 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ENCODED_ENUM, "I_ENCODED_ENUM"), root_1); 6467 adaptor.addChild(root_1, stream_field_reference.nextTree()); 6468 adaptor.addChild(root_0, root_1); 6469 } 6470 6471 } 6472 6473 6474 retval.tree = root_0; 6475 6476 } 6477 6478 retval.stop = input.LT(-1); 6479 6480 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 6481 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 6482 6483 } 6484 catch (RecognitionException re) { 6485 reportError(re); 6486 recover(input,re); 6487 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 6488 } 6489 finally { 6490 // do for sure before leaving 6491 } 6492 return retval; 6493 } 6494 // $ANTLR end "enum_literal" 6495 6496 6497 public static class type_field_method_literal_return extends ParserRuleReturnScope { 6498 CommonTree tree; 6499 @Override 6500 public CommonTree getTree() { return tree; } 6501 }; 6502 6503 6504 // $ANTLR start "type_field_method_literal" 6505 // smaliParser.g:692:1: type_field_method_literal : ( reference_type_descriptor | ( ( reference_type_descriptor ARROW )? ( member_name COLON nonvoid_type_descriptor -> ^( I_ENCODED_FIELD ( reference_type_descriptor )? member_name nonvoid_type_descriptor ) | member_name method_prototype -> ^( I_ENCODED_METHOD ( reference_type_descriptor )? member_name method_prototype ) ) ) | PRIMITIVE_TYPE | VOID_TYPE ); 6506 public final smaliParser.type_field_method_literal_return type_field_method_literal() throws RecognitionException { 6507 smaliParser.type_field_method_literal_return retval = new smaliParser.type_field_method_literal_return(); 6508 retval.start = input.LT(1); 6509 6510 CommonTree root_0 = null; 6511 6512 Token ARROW167=null; 6513 Token COLON169=null; 6514 Token PRIMITIVE_TYPE173=null; 6515 Token VOID_TYPE174=null; 6516 ParserRuleReturnScope reference_type_descriptor165 =null; 6517 ParserRuleReturnScope reference_type_descriptor166 =null; 6518 ParserRuleReturnScope member_name168 =null; 6519 ParserRuleReturnScope nonvoid_type_descriptor170 =null; 6520 ParserRuleReturnScope member_name171 =null; 6521 ParserRuleReturnScope method_prototype172 =null; 6522 6523 CommonTree ARROW167_tree=null; 6524 CommonTree COLON169_tree=null; 6525 CommonTree PRIMITIVE_TYPE173_tree=null; 6526 CommonTree VOID_TYPE174_tree=null; 6527 RewriteRuleTokenStream stream_ARROW=new RewriteRuleTokenStream(adaptor,"token ARROW"); 6528 RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON"); 6529 RewriteRuleSubtreeStream stream_method_prototype=new RewriteRuleSubtreeStream(adaptor,"rule method_prototype"); 6530 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 6531 RewriteRuleSubtreeStream stream_member_name=new RewriteRuleSubtreeStream(adaptor,"rule member_name"); 6532 RewriteRuleSubtreeStream stream_reference_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule reference_type_descriptor"); 6533 6534 try { 6535 // smaliParser.g:693:3: ( reference_type_descriptor | ( ( reference_type_descriptor ARROW )? ( member_name COLON nonvoid_type_descriptor -> ^( I_ENCODED_FIELD ( reference_type_descriptor )? member_name nonvoid_type_descriptor ) | member_name method_prototype -> ^( I_ENCODED_METHOD ( reference_type_descriptor )? member_name method_prototype ) ) ) | PRIMITIVE_TYPE | VOID_TYPE ) 6536 int alt31=4; 6537 switch ( input.LA(1) ) { 6538 case CLASS_DESCRIPTOR: 6539 { 6540 int LA31_1 = input.LA(2); 6541 if ( (LA31_1==EOF||(LA31_1 >= ACCESS_SPEC && LA31_1 <= ANNOTATION_VISIBILITY)||LA31_1==BOOL_LITERAL||(LA31_1 >= CLASS_DIRECTIVE && LA31_1 <= CLOSE_BRACE)||LA31_1==COMMA||(LA31_1 >= DOUBLE_LITERAL_OR_ID && LA31_1 <= END_ANNOTATION_DIRECTIVE)||LA31_1==END_FIELD_DIRECTIVE||LA31_1==END_SUBANNOTATION_DIRECTIVE||LA31_1==FIELD_DIRECTIVE||(LA31_1 >= FLOAT_LITERAL_OR_ID && LA31_1 <= IMPLEMENTS_DIRECTIVE)||(LA31_1 >= INSTRUCTION_FORMAT10t && LA31_1 <= INSTRUCTION_FORMAT10x_ODEX)||LA31_1==INSTRUCTION_FORMAT11x||LA31_1==INSTRUCTION_FORMAT12x_OR_ID||(LA31_1 >= INSTRUCTION_FORMAT21c_FIELD && LA31_1 <= INSTRUCTION_FORMAT21c_TYPE)||LA31_1==INSTRUCTION_FORMAT21t||(LA31_1 >= INSTRUCTION_FORMAT22c_FIELD && LA31_1 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA31_1 >= INSTRUCTION_FORMAT22s_OR_ID && LA31_1 <= INSTRUCTION_FORMAT22t)||LA31_1==INSTRUCTION_FORMAT23x||(LA31_1 >= INSTRUCTION_FORMAT31i_OR_ID && LA31_1 <= INSTRUCTION_FORMAT31t)||(LA31_1 >= INSTRUCTION_FORMAT35c_METHOD && LA31_1 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA31_1 >= INSTRUCTION_FORMAT45cc_METHOD && LA31_1 <= INSTRUCTION_FORMAT51l)||(LA31_1 >= METHOD_DIRECTIVE && LA31_1 <= NULL_LITERAL)||(LA31_1 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA31_1 <= PRIMITIVE_TYPE)||LA31_1==REGISTER||(LA31_1 >= SIMPLE_NAME && LA31_1 <= SOURCE_DIRECTIVE)||(LA31_1 >= SUPER_DIRECTIVE && LA31_1 <= VOID_TYPE)) ) { 6542 alt31=1; 6543 } 6544 else if ( (LA31_1==ARROW) ) { 6545 alt31=2; 6546 } 6547 6548 else { 6549 int nvaeMark = input.mark(); 6550 try { 6551 input.consume(); 6552 NoViableAltException nvae = 6553 new NoViableAltException("", 31, 1, input); 6554 throw nvae; 6555 } finally { 6556 input.rewind(nvaeMark); 6557 } 6558 } 6559 6560 } 6561 break; 6562 case ARRAY_TYPE_PREFIX: 6563 { 6564 int LA31_2 = input.LA(2); 6565 if ( (LA31_2==CLASS_DESCRIPTOR||LA31_2==PRIMITIVE_TYPE) ) { 6566 int LA31_7 = input.LA(3); 6567 if ( (LA31_7==EOF||(LA31_7 >= ACCESS_SPEC && LA31_7 <= ANNOTATION_VISIBILITY)||LA31_7==BOOL_LITERAL||(LA31_7 >= CLASS_DIRECTIVE && LA31_7 <= CLOSE_BRACE)||LA31_7==COMMA||(LA31_7 >= DOUBLE_LITERAL_OR_ID && LA31_7 <= END_ANNOTATION_DIRECTIVE)||LA31_7==END_FIELD_DIRECTIVE||LA31_7==END_SUBANNOTATION_DIRECTIVE||LA31_7==FIELD_DIRECTIVE||(LA31_7 >= FLOAT_LITERAL_OR_ID && LA31_7 <= IMPLEMENTS_DIRECTIVE)||(LA31_7 >= INSTRUCTION_FORMAT10t && LA31_7 <= INSTRUCTION_FORMAT10x_ODEX)||LA31_7==INSTRUCTION_FORMAT11x||LA31_7==INSTRUCTION_FORMAT12x_OR_ID||(LA31_7 >= INSTRUCTION_FORMAT21c_FIELD && LA31_7 <= INSTRUCTION_FORMAT21c_TYPE)||LA31_7==INSTRUCTION_FORMAT21t||(LA31_7 >= INSTRUCTION_FORMAT22c_FIELD && LA31_7 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA31_7 >= INSTRUCTION_FORMAT22s_OR_ID && LA31_7 <= INSTRUCTION_FORMAT22t)||LA31_7==INSTRUCTION_FORMAT23x||(LA31_7 >= INSTRUCTION_FORMAT31i_OR_ID && LA31_7 <= INSTRUCTION_FORMAT31t)||(LA31_7 >= INSTRUCTION_FORMAT35c_METHOD && LA31_7 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA31_7 >= INSTRUCTION_FORMAT45cc_METHOD && LA31_7 <= INSTRUCTION_FORMAT51l)||(LA31_7 >= METHOD_DIRECTIVE && LA31_7 <= NULL_LITERAL)||(LA31_7 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA31_7 <= PRIMITIVE_TYPE)||LA31_7==REGISTER||(LA31_7 >= SIMPLE_NAME && LA31_7 <= SOURCE_DIRECTIVE)||(LA31_7 >= SUPER_DIRECTIVE && LA31_7 <= VOID_TYPE)) ) { 6568 alt31=1; 6569 } 6570 else if ( (LA31_7==ARROW) ) { 6571 alt31=2; 6572 } 6573 6574 else { 6575 int nvaeMark = input.mark(); 6576 try { 6577 for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) { 6578 input.consume(); 6579 } 6580 NoViableAltException nvae = 6581 new NoViableAltException("", 31, 7, input); 6582 throw nvae; 6583 } finally { 6584 input.rewind(nvaeMark); 6585 } 6586 } 6587 6588 } 6589 6590 else { 6591 int nvaeMark = input.mark(); 6592 try { 6593 input.consume(); 6594 NoViableAltException nvae = 6595 new NoViableAltException("", 31, 2, input); 6596 throw nvae; 6597 } finally { 6598 input.rewind(nvaeMark); 6599 } 6600 } 6601 6602 } 6603 break; 6604 case ACCESS_SPEC: 6605 case ANNOTATION_VISIBILITY: 6606 case BOOL_LITERAL: 6607 case DOUBLE_LITERAL_OR_ID: 6608 case FLOAT_LITERAL_OR_ID: 6609 case INSTRUCTION_FORMAT10t: 6610 case INSTRUCTION_FORMAT10x: 6611 case INSTRUCTION_FORMAT10x_ODEX: 6612 case INSTRUCTION_FORMAT11x: 6613 case INSTRUCTION_FORMAT12x_OR_ID: 6614 case INSTRUCTION_FORMAT21c_FIELD: 6615 case INSTRUCTION_FORMAT21c_FIELD_ODEX: 6616 case INSTRUCTION_FORMAT21c_STRING: 6617 case INSTRUCTION_FORMAT21c_TYPE: 6618 case INSTRUCTION_FORMAT21t: 6619 case INSTRUCTION_FORMAT22c_FIELD: 6620 case INSTRUCTION_FORMAT22c_FIELD_ODEX: 6621 case INSTRUCTION_FORMAT22c_TYPE: 6622 case INSTRUCTION_FORMAT22cs_FIELD: 6623 case INSTRUCTION_FORMAT22s_OR_ID: 6624 case INSTRUCTION_FORMAT22t: 6625 case INSTRUCTION_FORMAT23x: 6626 case INSTRUCTION_FORMAT31i_OR_ID: 6627 case INSTRUCTION_FORMAT31t: 6628 case INSTRUCTION_FORMAT35c_METHOD: 6629 case INSTRUCTION_FORMAT35c_METHOD_ODEX: 6630 case INSTRUCTION_FORMAT35c_TYPE: 6631 case INSTRUCTION_FORMAT35mi_METHOD: 6632 case INSTRUCTION_FORMAT35ms_METHOD: 6633 case INSTRUCTION_FORMAT45cc_METHOD: 6634 case INSTRUCTION_FORMAT4rcc_METHOD: 6635 case INSTRUCTION_FORMAT51l: 6636 case MEMBER_NAME: 6637 case NEGATIVE_INTEGER_LITERAL: 6638 case NULL_LITERAL: 6639 case PARAM_LIST_OR_ID_PRIMITIVE_TYPE: 6640 case POSITIVE_INTEGER_LITERAL: 6641 case REGISTER: 6642 case SIMPLE_NAME: 6643 case VERIFICATION_ERROR_TYPE: 6644 { 6645 alt31=2; 6646 } 6647 break; 6648 case PRIMITIVE_TYPE: 6649 { 6650 int LA31_4 = input.LA(2); 6651 if ( (LA31_4==COLON||LA31_4==OPEN_PAREN) ) { 6652 alt31=2; 6653 } 6654 else if ( (LA31_4==EOF||(LA31_4 >= ACCESS_SPEC && LA31_4 <= ANNOTATION_VISIBILITY)||LA31_4==BOOL_LITERAL||(LA31_4 >= CLASS_DIRECTIVE && LA31_4 <= CLOSE_BRACE)||LA31_4==COMMA||(LA31_4 >= DOUBLE_LITERAL_OR_ID && LA31_4 <= END_ANNOTATION_DIRECTIVE)||LA31_4==END_FIELD_DIRECTIVE||LA31_4==END_SUBANNOTATION_DIRECTIVE||LA31_4==FIELD_DIRECTIVE||(LA31_4 >= FLOAT_LITERAL_OR_ID && LA31_4 <= IMPLEMENTS_DIRECTIVE)||(LA31_4 >= INSTRUCTION_FORMAT10t && LA31_4 <= INSTRUCTION_FORMAT10x_ODEX)||LA31_4==INSTRUCTION_FORMAT11x||LA31_4==INSTRUCTION_FORMAT12x_OR_ID||(LA31_4 >= INSTRUCTION_FORMAT21c_FIELD && LA31_4 <= INSTRUCTION_FORMAT21c_TYPE)||LA31_4==INSTRUCTION_FORMAT21t||(LA31_4 >= INSTRUCTION_FORMAT22c_FIELD && LA31_4 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA31_4 >= INSTRUCTION_FORMAT22s_OR_ID && LA31_4 <= INSTRUCTION_FORMAT22t)||LA31_4==INSTRUCTION_FORMAT23x||(LA31_4 >= INSTRUCTION_FORMAT31i_OR_ID && LA31_4 <= INSTRUCTION_FORMAT31t)||(LA31_4 >= INSTRUCTION_FORMAT35c_METHOD && LA31_4 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA31_4 >= INSTRUCTION_FORMAT45cc_METHOD && LA31_4 <= INSTRUCTION_FORMAT51l)||(LA31_4 >= METHOD_DIRECTIVE && LA31_4 <= NULL_LITERAL)||(LA31_4 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA31_4 <= PRIMITIVE_TYPE)||LA31_4==REGISTER||(LA31_4 >= SIMPLE_NAME && LA31_4 <= SOURCE_DIRECTIVE)||(LA31_4 >= SUPER_DIRECTIVE && LA31_4 <= VOID_TYPE)) ) { 6655 alt31=3; 6656 } 6657 6658 else { 6659 int nvaeMark = input.mark(); 6660 try { 6661 input.consume(); 6662 NoViableAltException nvae = 6663 new NoViableAltException("", 31, 4, input); 6664 throw nvae; 6665 } finally { 6666 input.rewind(nvaeMark); 6667 } 6668 } 6669 6670 } 6671 break; 6672 case VOID_TYPE: 6673 { 6674 int LA31_5 = input.LA(2); 6675 if ( (LA31_5==COLON||LA31_5==OPEN_PAREN) ) { 6676 alt31=2; 6677 } 6678 else if ( (LA31_5==EOF||(LA31_5 >= ACCESS_SPEC && LA31_5 <= ANNOTATION_VISIBILITY)||LA31_5==BOOL_LITERAL||(LA31_5 >= CLASS_DIRECTIVE && LA31_5 <= CLOSE_BRACE)||LA31_5==COMMA||(LA31_5 >= DOUBLE_LITERAL_OR_ID && LA31_5 <= END_ANNOTATION_DIRECTIVE)||LA31_5==END_FIELD_DIRECTIVE||LA31_5==END_SUBANNOTATION_DIRECTIVE||LA31_5==FIELD_DIRECTIVE||(LA31_5 >= FLOAT_LITERAL_OR_ID && LA31_5 <= IMPLEMENTS_DIRECTIVE)||(LA31_5 >= INSTRUCTION_FORMAT10t && LA31_5 <= INSTRUCTION_FORMAT10x_ODEX)||LA31_5==INSTRUCTION_FORMAT11x||LA31_5==INSTRUCTION_FORMAT12x_OR_ID||(LA31_5 >= INSTRUCTION_FORMAT21c_FIELD && LA31_5 <= INSTRUCTION_FORMAT21c_TYPE)||LA31_5==INSTRUCTION_FORMAT21t||(LA31_5 >= INSTRUCTION_FORMAT22c_FIELD && LA31_5 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA31_5 >= INSTRUCTION_FORMAT22s_OR_ID && LA31_5 <= INSTRUCTION_FORMAT22t)||LA31_5==INSTRUCTION_FORMAT23x||(LA31_5 >= INSTRUCTION_FORMAT31i_OR_ID && LA31_5 <= INSTRUCTION_FORMAT31t)||(LA31_5 >= INSTRUCTION_FORMAT35c_METHOD && LA31_5 <= INSTRUCTION_FORMAT35ms_METHOD)||(LA31_5 >= INSTRUCTION_FORMAT45cc_METHOD && LA31_5 <= INSTRUCTION_FORMAT51l)||(LA31_5 >= METHOD_DIRECTIVE && LA31_5 <= NULL_LITERAL)||(LA31_5 >= PARAM_LIST_OR_ID_PRIMITIVE_TYPE && LA31_5 <= PRIMITIVE_TYPE)||LA31_5==REGISTER||(LA31_5 >= SIMPLE_NAME && LA31_5 <= SOURCE_DIRECTIVE)||(LA31_5 >= SUPER_DIRECTIVE && LA31_5 <= VOID_TYPE)) ) { 6679 alt31=4; 6680 } 6681 6682 else { 6683 int nvaeMark = input.mark(); 6684 try { 6685 input.consume(); 6686 NoViableAltException nvae = 6687 new NoViableAltException("", 31, 5, input); 6688 throw nvae; 6689 } finally { 6690 input.rewind(nvaeMark); 6691 } 6692 } 6693 6694 } 6695 break; 6696 default: 6697 NoViableAltException nvae = 6698 new NoViableAltException("", 31, 0, input); 6699 throw nvae; 6700 } 6701 switch (alt31) { 6702 case 1 : 6703 // smaliParser.g:693:5: reference_type_descriptor 6704 { 6705 root_0 = (CommonTree)adaptor.nil(); 6706 6707 6708 pushFollow(FOLLOW_reference_type_descriptor_in_type_field_method_literal2874); 6709 reference_type_descriptor165=reference_type_descriptor(); 6710 state._fsp--; 6711 6712 adaptor.addChild(root_0, reference_type_descriptor165.getTree()); 6713 6714 } 6715 break; 6716 case 2 : 6717 // smaliParser.g:694:5: ( ( reference_type_descriptor ARROW )? ( member_name COLON nonvoid_type_descriptor -> ^( I_ENCODED_FIELD ( reference_type_descriptor )? member_name nonvoid_type_descriptor ) | member_name method_prototype -> ^( I_ENCODED_METHOD ( reference_type_descriptor )? member_name method_prototype ) ) ) 6718 { 6719 // smaliParser.g:694:5: ( ( reference_type_descriptor ARROW )? ( member_name COLON nonvoid_type_descriptor -> ^( I_ENCODED_FIELD ( reference_type_descriptor )? member_name nonvoid_type_descriptor ) | member_name method_prototype -> ^( I_ENCODED_METHOD ( reference_type_descriptor )? member_name method_prototype ) ) ) 6720 // smaliParser.g:694:7: ( reference_type_descriptor ARROW )? ( member_name COLON nonvoid_type_descriptor -> ^( I_ENCODED_FIELD ( reference_type_descriptor )? member_name nonvoid_type_descriptor ) | member_name method_prototype -> ^( I_ENCODED_METHOD ( reference_type_descriptor )? member_name method_prototype ) ) 6721 { 6722 // smaliParser.g:694:7: ( reference_type_descriptor ARROW )? 6723 int alt29=2; 6724 int LA29_0 = input.LA(1); 6725 if ( (LA29_0==ARRAY_TYPE_PREFIX||LA29_0==CLASS_DESCRIPTOR) ) { 6726 alt29=1; 6727 } 6728 switch (alt29) { 6729 case 1 : 6730 // smaliParser.g:694:8: reference_type_descriptor ARROW 6731 { 6732 pushFollow(FOLLOW_reference_type_descriptor_in_type_field_method_literal2883); 6733 reference_type_descriptor166=reference_type_descriptor(); 6734 state._fsp--; 6735 6736 stream_reference_type_descriptor.add(reference_type_descriptor166.getTree()); 6737 ARROW167=(Token)match(input,ARROW,FOLLOW_ARROW_in_type_field_method_literal2885); 6738 stream_ARROW.add(ARROW167); 6739 6740 } 6741 break; 6742 6743 } 6744 6745 // smaliParser.g:695:7: ( member_name COLON nonvoid_type_descriptor -> ^( I_ENCODED_FIELD ( reference_type_descriptor )? member_name nonvoid_type_descriptor ) | member_name method_prototype -> ^( I_ENCODED_METHOD ( reference_type_descriptor )? member_name method_prototype ) ) 6746 int alt30=2; 6747 alt30 = dfa30.predict(input); 6748 switch (alt30) { 6749 case 1 : 6750 // smaliParser.g:695:9: member_name COLON nonvoid_type_descriptor 6751 { 6752 pushFollow(FOLLOW_member_name_in_type_field_method_literal2897); 6753 member_name168=member_name(); 6754 state._fsp--; 6755 6756 stream_member_name.add(member_name168.getTree()); 6757 COLON169=(Token)match(input,COLON,FOLLOW_COLON_in_type_field_method_literal2899); 6758 stream_COLON.add(COLON169); 6759 6760 pushFollow(FOLLOW_nonvoid_type_descriptor_in_type_field_method_literal2901); 6761 nonvoid_type_descriptor170=nonvoid_type_descriptor(); 6762 state._fsp--; 6763 6764 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor170.getTree()); 6765 // AST REWRITE 6766 // elements: reference_type_descriptor, member_name, nonvoid_type_descriptor 6767 // token labels: 6768 // rule labels: retval 6769 // token list labels: 6770 // rule list labels: 6771 // wildcard labels: 6772 retval.tree = root_0; 6773 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 6774 6775 root_0 = (CommonTree)adaptor.nil(); 6776 // 695:51: -> ^( I_ENCODED_FIELD ( reference_type_descriptor )? member_name nonvoid_type_descriptor ) 6777 { 6778 // smaliParser.g:695:54: ^( I_ENCODED_FIELD ( reference_type_descriptor )? member_name nonvoid_type_descriptor ) 6779 { 6780 CommonTree root_1 = (CommonTree)adaptor.nil(); 6781 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ENCODED_FIELD, "I_ENCODED_FIELD"), root_1); 6782 // smaliParser.g:695:72: ( reference_type_descriptor )? 6783 if ( stream_reference_type_descriptor.hasNext() ) { 6784 adaptor.addChild(root_1, stream_reference_type_descriptor.nextTree()); 6785 } 6786 stream_reference_type_descriptor.reset(); 6787 6788 adaptor.addChild(root_1, stream_member_name.nextTree()); 6789 adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree()); 6790 adaptor.addChild(root_0, root_1); 6791 } 6792 6793 } 6794 6795 6796 retval.tree = root_0; 6797 6798 } 6799 break; 6800 case 2 : 6801 // smaliParser.g:696:9: member_name method_prototype 6802 { 6803 pushFollow(FOLLOW_member_name_in_type_field_method_literal2924); 6804 member_name171=member_name(); 6805 state._fsp--; 6806 6807 stream_member_name.add(member_name171.getTree()); 6808 pushFollow(FOLLOW_method_prototype_in_type_field_method_literal2926); 6809 method_prototype172=method_prototype(); 6810 state._fsp--; 6811 6812 stream_method_prototype.add(method_prototype172.getTree()); 6813 // AST REWRITE 6814 // elements: member_name, method_prototype, reference_type_descriptor 6815 // token labels: 6816 // rule labels: retval 6817 // token list labels: 6818 // rule list labels: 6819 // wildcard labels: 6820 retval.tree = root_0; 6821 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 6822 6823 root_0 = (CommonTree)adaptor.nil(); 6824 // 696:38: -> ^( I_ENCODED_METHOD ( reference_type_descriptor )? member_name method_prototype ) 6825 { 6826 // smaliParser.g:696:41: ^( I_ENCODED_METHOD ( reference_type_descriptor )? member_name method_prototype ) 6827 { 6828 CommonTree root_1 = (CommonTree)adaptor.nil(); 6829 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ENCODED_METHOD, "I_ENCODED_METHOD"), root_1); 6830 // smaliParser.g:696:60: ( reference_type_descriptor )? 6831 if ( stream_reference_type_descriptor.hasNext() ) { 6832 adaptor.addChild(root_1, stream_reference_type_descriptor.nextTree()); 6833 } 6834 stream_reference_type_descriptor.reset(); 6835 6836 adaptor.addChild(root_1, stream_member_name.nextTree()); 6837 adaptor.addChild(root_1, stream_method_prototype.nextTree()); 6838 adaptor.addChild(root_0, root_1); 6839 } 6840 6841 } 6842 6843 6844 retval.tree = root_0; 6845 6846 } 6847 break; 6848 6849 } 6850 6851 } 6852 6853 } 6854 break; 6855 case 3 : 6856 // smaliParser.g:699:5: PRIMITIVE_TYPE 6857 { 6858 root_0 = (CommonTree)adaptor.nil(); 6859 6860 6861 PRIMITIVE_TYPE173=(Token)match(input,PRIMITIVE_TYPE,FOLLOW_PRIMITIVE_TYPE_in_type_field_method_literal2959); 6862 PRIMITIVE_TYPE173_tree = (CommonTree)adaptor.create(PRIMITIVE_TYPE173); 6863 adaptor.addChild(root_0, PRIMITIVE_TYPE173_tree); 6864 6865 } 6866 break; 6867 case 4 : 6868 // smaliParser.g:700:5: VOID_TYPE 6869 { 6870 root_0 = (CommonTree)adaptor.nil(); 6871 6872 6873 VOID_TYPE174=(Token)match(input,VOID_TYPE,FOLLOW_VOID_TYPE_in_type_field_method_literal2965); 6874 VOID_TYPE174_tree = (CommonTree)adaptor.create(VOID_TYPE174); 6875 adaptor.addChild(root_0, VOID_TYPE174_tree); 6876 6877 } 6878 break; 6879 6880 } 6881 retval.stop = input.LT(-1); 6882 6883 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 6884 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 6885 6886 } 6887 catch (RecognitionException re) { 6888 reportError(re); 6889 recover(input,re); 6890 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 6891 } 6892 finally { 6893 // do for sure before leaving 6894 } 6895 return retval; 6896 } 6897 // $ANTLR end "type_field_method_literal" 6898 6899 6900 public static class method_reference_return extends ParserRuleReturnScope { 6901 CommonTree tree; 6902 @Override 6903 public CommonTree getTree() { return tree; } 6904 }; 6905 6906 6907 // $ANTLR start "method_reference" 6908 // smaliParser.g:702:1: method_reference : ( reference_type_descriptor ARROW )? member_name method_prototype -> ( reference_type_descriptor )? member_name method_prototype ; 6909 public final smaliParser.method_reference_return method_reference() throws RecognitionException { 6910 smaliParser.method_reference_return retval = new smaliParser.method_reference_return(); 6911 retval.start = input.LT(1); 6912 6913 CommonTree root_0 = null; 6914 6915 Token ARROW176=null; 6916 ParserRuleReturnScope reference_type_descriptor175 =null; 6917 ParserRuleReturnScope member_name177 =null; 6918 ParserRuleReturnScope method_prototype178 =null; 6919 6920 CommonTree ARROW176_tree=null; 6921 RewriteRuleTokenStream stream_ARROW=new RewriteRuleTokenStream(adaptor,"token ARROW"); 6922 RewriteRuleSubtreeStream stream_method_prototype=new RewriteRuleSubtreeStream(adaptor,"rule method_prototype"); 6923 RewriteRuleSubtreeStream stream_member_name=new RewriteRuleSubtreeStream(adaptor,"rule member_name"); 6924 RewriteRuleSubtreeStream stream_reference_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule reference_type_descriptor"); 6925 6926 try { 6927 // smaliParser.g:703:3: ( ( reference_type_descriptor ARROW )? member_name method_prototype -> ( reference_type_descriptor )? member_name method_prototype ) 6928 // smaliParser.g:703:5: ( reference_type_descriptor ARROW )? member_name method_prototype 6929 { 6930 // smaliParser.g:703:5: ( reference_type_descriptor ARROW )? 6931 int alt32=2; 6932 int LA32_0 = input.LA(1); 6933 if ( (LA32_0==ARRAY_TYPE_PREFIX||LA32_0==CLASS_DESCRIPTOR) ) { 6934 alt32=1; 6935 } 6936 switch (alt32) { 6937 case 1 : 6938 // smaliParser.g:703:6: reference_type_descriptor ARROW 6939 { 6940 pushFollow(FOLLOW_reference_type_descriptor_in_method_reference2976); 6941 reference_type_descriptor175=reference_type_descriptor(); 6942 state._fsp--; 6943 6944 stream_reference_type_descriptor.add(reference_type_descriptor175.getTree()); 6945 ARROW176=(Token)match(input,ARROW,FOLLOW_ARROW_in_method_reference2978); 6946 stream_ARROW.add(ARROW176); 6947 6948 } 6949 break; 6950 6951 } 6952 6953 pushFollow(FOLLOW_member_name_in_method_reference2982); 6954 member_name177=member_name(); 6955 state._fsp--; 6956 6957 stream_member_name.add(member_name177.getTree()); 6958 pushFollow(FOLLOW_method_prototype_in_method_reference2984); 6959 method_prototype178=method_prototype(); 6960 state._fsp--; 6961 6962 stream_method_prototype.add(method_prototype178.getTree()); 6963 // AST REWRITE 6964 // elements: method_prototype, reference_type_descriptor, member_name 6965 // token labels: 6966 // rule labels: retval 6967 // token list labels: 6968 // rule list labels: 6969 // wildcard labels: 6970 retval.tree = root_0; 6971 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 6972 6973 root_0 = (CommonTree)adaptor.nil(); 6974 // 704:3: -> ( reference_type_descriptor )? member_name method_prototype 6975 { 6976 // smaliParser.g:704:6: ( reference_type_descriptor )? 6977 if ( stream_reference_type_descriptor.hasNext() ) { 6978 adaptor.addChild(root_0, stream_reference_type_descriptor.nextTree()); 6979 } 6980 stream_reference_type_descriptor.reset(); 6981 6982 adaptor.addChild(root_0, stream_member_name.nextTree()); 6983 adaptor.addChild(root_0, stream_method_prototype.nextTree()); 6984 } 6985 6986 6987 retval.tree = root_0; 6988 6989 } 6990 6991 retval.stop = input.LT(-1); 6992 6993 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 6994 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 6995 6996 } 6997 catch (RecognitionException re) { 6998 reportError(re); 6999 recover(input,re); 7000 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 7001 } 7002 finally { 7003 // do for sure before leaving 7004 } 7005 return retval; 7006 } 7007 // $ANTLR end "method_reference" 7008 7009 7010 public static class field_reference_return extends ParserRuleReturnScope { 7011 CommonTree tree; 7012 @Override 7013 public CommonTree getTree() { return tree; } 7014 }; 7015 7016 7017 // $ANTLR start "field_reference" 7018 // smaliParser.g:706:1: field_reference : ( reference_type_descriptor ARROW )? member_name COLON nonvoid_type_descriptor -> ( reference_type_descriptor )? member_name nonvoid_type_descriptor ; 7019 public final smaliParser.field_reference_return field_reference() throws RecognitionException { 7020 smaliParser.field_reference_return retval = new smaliParser.field_reference_return(); 7021 retval.start = input.LT(1); 7022 7023 CommonTree root_0 = null; 7024 7025 Token ARROW180=null; 7026 Token COLON182=null; 7027 ParserRuleReturnScope reference_type_descriptor179 =null; 7028 ParserRuleReturnScope member_name181 =null; 7029 ParserRuleReturnScope nonvoid_type_descriptor183 =null; 7030 7031 CommonTree ARROW180_tree=null; 7032 CommonTree COLON182_tree=null; 7033 RewriteRuleTokenStream stream_ARROW=new RewriteRuleTokenStream(adaptor,"token ARROW"); 7034 RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON"); 7035 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 7036 RewriteRuleSubtreeStream stream_member_name=new RewriteRuleSubtreeStream(adaptor,"rule member_name"); 7037 RewriteRuleSubtreeStream stream_reference_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule reference_type_descriptor"); 7038 7039 try { 7040 // smaliParser.g:707:3: ( ( reference_type_descriptor ARROW )? member_name COLON nonvoid_type_descriptor -> ( reference_type_descriptor )? member_name nonvoid_type_descriptor ) 7041 // smaliParser.g:707:5: ( reference_type_descriptor ARROW )? member_name COLON nonvoid_type_descriptor 7042 { 7043 // smaliParser.g:707:5: ( reference_type_descriptor ARROW )? 7044 int alt33=2; 7045 int LA33_0 = input.LA(1); 7046 if ( (LA33_0==ARRAY_TYPE_PREFIX||LA33_0==CLASS_DESCRIPTOR) ) { 7047 alt33=1; 7048 } 7049 switch (alt33) { 7050 case 1 : 7051 // smaliParser.g:707:6: reference_type_descriptor ARROW 7052 { 7053 pushFollow(FOLLOW_reference_type_descriptor_in_field_reference3006); 7054 reference_type_descriptor179=reference_type_descriptor(); 7055 state._fsp--; 7056 7057 stream_reference_type_descriptor.add(reference_type_descriptor179.getTree()); 7058 ARROW180=(Token)match(input,ARROW,FOLLOW_ARROW_in_field_reference3008); 7059 stream_ARROW.add(ARROW180); 7060 7061 } 7062 break; 7063 7064 } 7065 7066 pushFollow(FOLLOW_member_name_in_field_reference3012); 7067 member_name181=member_name(); 7068 state._fsp--; 7069 7070 stream_member_name.add(member_name181.getTree()); 7071 COLON182=(Token)match(input,COLON,FOLLOW_COLON_in_field_reference3014); 7072 stream_COLON.add(COLON182); 7073 7074 pushFollow(FOLLOW_nonvoid_type_descriptor_in_field_reference3016); 7075 nonvoid_type_descriptor183=nonvoid_type_descriptor(); 7076 state._fsp--; 7077 7078 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor183.getTree()); 7079 // AST REWRITE 7080 // elements: reference_type_descriptor, nonvoid_type_descriptor, member_name 7081 // token labels: 7082 // rule labels: retval 7083 // token list labels: 7084 // rule list labels: 7085 // wildcard labels: 7086 retval.tree = root_0; 7087 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7088 7089 root_0 = (CommonTree)adaptor.nil(); 7090 // 708:3: -> ( reference_type_descriptor )? member_name nonvoid_type_descriptor 7091 { 7092 // smaliParser.g:708:6: ( reference_type_descriptor )? 7093 if ( stream_reference_type_descriptor.hasNext() ) { 7094 adaptor.addChild(root_0, stream_reference_type_descriptor.nextTree()); 7095 } 7096 stream_reference_type_descriptor.reset(); 7097 7098 adaptor.addChild(root_0, stream_member_name.nextTree()); 7099 adaptor.addChild(root_0, stream_nonvoid_type_descriptor.nextTree()); 7100 } 7101 7102 7103 retval.tree = root_0; 7104 7105 } 7106 7107 retval.stop = input.LT(-1); 7108 7109 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 7110 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 7111 7112 } 7113 catch (RecognitionException re) { 7114 reportError(re); 7115 recover(input,re); 7116 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 7117 } 7118 finally { 7119 // do for sure before leaving 7120 } 7121 return retval; 7122 } 7123 // $ANTLR end "field_reference" 7124 7125 7126 public static class label_return extends ParserRuleReturnScope { 7127 CommonTree tree; 7128 @Override 7129 public CommonTree getTree() { return tree; } 7130 }; 7131 7132 7133 // $ANTLR start "label" 7134 // smaliParser.g:710:1: label : COLON simple_name -> ^( I_LABEL[$COLON, \"I_LABEL\"] simple_name ) ; 7135 public final smaliParser.label_return label() throws RecognitionException { 7136 smaliParser.label_return retval = new smaliParser.label_return(); 7137 retval.start = input.LT(1); 7138 7139 CommonTree root_0 = null; 7140 7141 Token COLON184=null; 7142 ParserRuleReturnScope simple_name185 =null; 7143 7144 CommonTree COLON184_tree=null; 7145 RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON"); 7146 RewriteRuleSubtreeStream stream_simple_name=new RewriteRuleSubtreeStream(adaptor,"rule simple_name"); 7147 7148 try { 7149 // smaliParser.g:711:3: ( COLON simple_name -> ^( I_LABEL[$COLON, \"I_LABEL\"] simple_name ) ) 7150 // smaliParser.g:711:5: COLON simple_name 7151 { 7152 COLON184=(Token)match(input,COLON,FOLLOW_COLON_in_label3037); 7153 stream_COLON.add(COLON184); 7154 7155 pushFollow(FOLLOW_simple_name_in_label3039); 7156 simple_name185=simple_name(); 7157 state._fsp--; 7158 7159 stream_simple_name.add(simple_name185.getTree()); 7160 // AST REWRITE 7161 // elements: simple_name 7162 // token labels: 7163 // rule labels: retval 7164 // token list labels: 7165 // rule list labels: 7166 // wildcard labels: 7167 retval.tree = root_0; 7168 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7169 7170 root_0 = (CommonTree)adaptor.nil(); 7171 // 711:23: -> ^( I_LABEL[$COLON, \"I_LABEL\"] simple_name ) 7172 { 7173 // smaliParser.g:711:26: ^( I_LABEL[$COLON, \"I_LABEL\"] simple_name ) 7174 { 7175 CommonTree root_1 = (CommonTree)adaptor.nil(); 7176 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_LABEL, COLON184, "I_LABEL"), root_1); 7177 adaptor.addChild(root_1, stream_simple_name.nextTree()); 7178 adaptor.addChild(root_0, root_1); 7179 } 7180 7181 } 7182 7183 7184 retval.tree = root_0; 7185 7186 } 7187 7188 retval.stop = input.LT(-1); 7189 7190 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 7191 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 7192 7193 } 7194 catch (RecognitionException re) { 7195 reportError(re); 7196 recover(input,re); 7197 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 7198 } 7199 finally { 7200 // do for sure before leaving 7201 } 7202 return retval; 7203 } 7204 // $ANTLR end "label" 7205 7206 7207 public static class label_ref_return extends ParserRuleReturnScope { 7208 CommonTree tree; 7209 @Override 7210 public CommonTree getTree() { return tree; } 7211 }; 7212 7213 7214 // $ANTLR start "label_ref" 7215 // smaliParser.g:713:1: label_ref : COLON simple_name -> simple_name ; 7216 public final smaliParser.label_ref_return label_ref() throws RecognitionException { 7217 smaliParser.label_ref_return retval = new smaliParser.label_ref_return(); 7218 retval.start = input.LT(1); 7219 7220 CommonTree root_0 = null; 7221 7222 Token COLON186=null; 7223 ParserRuleReturnScope simple_name187 =null; 7224 7225 CommonTree COLON186_tree=null; 7226 RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON"); 7227 RewriteRuleSubtreeStream stream_simple_name=new RewriteRuleSubtreeStream(adaptor,"rule simple_name"); 7228 7229 try { 7230 // smaliParser.g:714:3: ( COLON simple_name -> simple_name ) 7231 // smaliParser.g:714:5: COLON simple_name 7232 { 7233 COLON186=(Token)match(input,COLON,FOLLOW_COLON_in_label_ref3058); 7234 stream_COLON.add(COLON186); 7235 7236 pushFollow(FOLLOW_simple_name_in_label_ref3060); 7237 simple_name187=simple_name(); 7238 state._fsp--; 7239 7240 stream_simple_name.add(simple_name187.getTree()); 7241 // AST REWRITE 7242 // elements: simple_name 7243 // token labels: 7244 // rule labels: retval 7245 // token list labels: 7246 // rule list labels: 7247 // wildcard labels: 7248 retval.tree = root_0; 7249 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7250 7251 root_0 = (CommonTree)adaptor.nil(); 7252 // 714:23: -> simple_name 7253 { 7254 adaptor.addChild(root_0, stream_simple_name.nextTree()); 7255 } 7256 7257 7258 retval.tree = root_0; 7259 7260 } 7261 7262 retval.stop = input.LT(-1); 7263 7264 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 7265 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 7266 7267 } 7268 catch (RecognitionException re) { 7269 reportError(re); 7270 recover(input,re); 7271 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 7272 } 7273 finally { 7274 // do for sure before leaving 7275 } 7276 return retval; 7277 } 7278 // $ANTLR end "label_ref" 7279 7280 7281 public static class register_list_return extends ParserRuleReturnScope { 7282 CommonTree tree; 7283 @Override 7284 public CommonTree getTree() { return tree; } 7285 }; 7286 7287 7288 // $ANTLR start "register_list" 7289 // smaliParser.g:716:1: register_list : ( REGISTER ( COMMA REGISTER )* -> ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ( REGISTER )* ) | -> ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ) ); 7290 public final smaliParser.register_list_return register_list() throws RecognitionException { 7291 smaliParser.register_list_return retval = new smaliParser.register_list_return(); 7292 retval.start = input.LT(1); 7293 7294 CommonTree root_0 = null; 7295 7296 Token REGISTER188=null; 7297 Token COMMA189=null; 7298 Token REGISTER190=null; 7299 7300 CommonTree REGISTER188_tree=null; 7301 CommonTree COMMA189_tree=null; 7302 CommonTree REGISTER190_tree=null; 7303 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 7304 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 7305 7306 try { 7307 // smaliParser.g:717:3: ( REGISTER ( COMMA REGISTER )* -> ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ( REGISTER )* ) | -> ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ) ) 7308 int alt35=2; 7309 int LA35_0 = input.LA(1); 7310 if ( (LA35_0==REGISTER) ) { 7311 alt35=1; 7312 } 7313 else if ( (LA35_0==CLOSE_BRACE) ) { 7314 alt35=2; 7315 } 7316 7317 else { 7318 NoViableAltException nvae = 7319 new NoViableAltException("", 35, 0, input); 7320 throw nvae; 7321 } 7322 7323 switch (alt35) { 7324 case 1 : 7325 // smaliParser.g:717:5: REGISTER ( COMMA REGISTER )* 7326 { 7327 REGISTER188=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_register_list3074); 7328 stream_REGISTER.add(REGISTER188); 7329 7330 // smaliParser.g:717:14: ( COMMA REGISTER )* 7331 loop34: 7332 while (true) { 7333 int alt34=2; 7334 int LA34_0 = input.LA(1); 7335 if ( (LA34_0==COMMA) ) { 7336 alt34=1; 7337 } 7338 7339 switch (alt34) { 7340 case 1 : 7341 // smaliParser.g:717:15: COMMA REGISTER 7342 { 7343 COMMA189=(Token)match(input,COMMA,FOLLOW_COMMA_in_register_list3077); 7344 stream_COMMA.add(COMMA189); 7345 7346 REGISTER190=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_register_list3079); 7347 stream_REGISTER.add(REGISTER190); 7348 7349 } 7350 break; 7351 7352 default : 7353 break loop34; 7354 } 7355 } 7356 7357 // AST REWRITE 7358 // elements: REGISTER 7359 // token labels: 7360 // rule labels: retval 7361 // token list labels: 7362 // rule list labels: 7363 // wildcard labels: 7364 retval.tree = root_0; 7365 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7366 7367 root_0 = (CommonTree)adaptor.nil(); 7368 // 717:32: -> ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ( REGISTER )* ) 7369 { 7370 // smaliParser.g:717:35: ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ( REGISTER )* ) 7371 { 7372 CommonTree root_1 = (CommonTree)adaptor.nil(); 7373 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_REGISTER_LIST, (retval.start), "I_REGISTER_LIST"), root_1); 7374 // smaliParser.g:717:80: ( REGISTER )* 7375 while ( stream_REGISTER.hasNext() ) { 7376 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 7377 } 7378 stream_REGISTER.reset(); 7379 7380 adaptor.addChild(root_0, root_1); 7381 } 7382 7383 } 7384 7385 7386 retval.tree = root_0; 7387 7388 } 7389 break; 7390 case 2 : 7391 // smaliParser.g:718:5: 7392 { 7393 // AST REWRITE 7394 // elements: 7395 // token labels: 7396 // rule labels: retval 7397 // token list labels: 7398 // rule list labels: 7399 // wildcard labels: 7400 retval.tree = root_0; 7401 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7402 7403 root_0 = (CommonTree)adaptor.nil(); 7404 // 718:5: -> ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ) 7405 { 7406 // smaliParser.g:718:7: ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ) 7407 { 7408 CommonTree root_1 = (CommonTree)adaptor.nil(); 7409 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_REGISTER_LIST, (retval.start), "I_REGISTER_LIST"), root_1); 7410 adaptor.addChild(root_0, root_1); 7411 } 7412 7413 } 7414 7415 7416 retval.tree = root_0; 7417 7418 } 7419 break; 7420 7421 } 7422 retval.stop = input.LT(-1); 7423 7424 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 7425 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 7426 7427 } 7428 catch (RecognitionException re) { 7429 reportError(re); 7430 recover(input,re); 7431 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 7432 } 7433 finally { 7434 // do for sure before leaving 7435 } 7436 return retval; 7437 } 7438 // $ANTLR end "register_list" 7439 7440 7441 public static class register_range_return extends ParserRuleReturnScope { 7442 CommonTree tree; 7443 @Override 7444 public CommonTree getTree() { return tree; } 7445 }; 7446 7447 7448 // $ANTLR start "register_range" 7449 // smaliParser.g:720:1: register_range : (startreg= REGISTER ( DOTDOT endreg= REGISTER )? )? -> ^( I_REGISTER_RANGE[$start, \"I_REGISTER_RANGE\"] ( $startreg)? ( $endreg)? ) ; 7450 public final smaliParser.register_range_return register_range() throws RecognitionException { 7451 smaliParser.register_range_return retval = new smaliParser.register_range_return(); 7452 retval.start = input.LT(1); 7453 7454 CommonTree root_0 = null; 7455 7456 Token startreg=null; 7457 Token endreg=null; 7458 Token DOTDOT191=null; 7459 7460 CommonTree startreg_tree=null; 7461 CommonTree endreg_tree=null; 7462 CommonTree DOTDOT191_tree=null; 7463 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 7464 RewriteRuleTokenStream stream_DOTDOT=new RewriteRuleTokenStream(adaptor,"token DOTDOT"); 7465 7466 try { 7467 // smaliParser.g:721:3: ( (startreg= REGISTER ( DOTDOT endreg= REGISTER )? )? -> ^( I_REGISTER_RANGE[$start, \"I_REGISTER_RANGE\"] ( $startreg)? ( $endreg)? ) ) 7468 // smaliParser.g:721:5: (startreg= REGISTER ( DOTDOT endreg= REGISTER )? )? 7469 { 7470 // smaliParser.g:721:5: (startreg= REGISTER ( DOTDOT endreg= REGISTER )? )? 7471 int alt37=2; 7472 int LA37_0 = input.LA(1); 7473 if ( (LA37_0==REGISTER) ) { 7474 alt37=1; 7475 } 7476 switch (alt37) { 7477 case 1 : 7478 // smaliParser.g:721:6: startreg= REGISTER ( DOTDOT endreg= REGISTER )? 7479 { 7480 startreg=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_register_range3114); 7481 stream_REGISTER.add(startreg); 7482 7483 // smaliParser.g:721:24: ( DOTDOT endreg= REGISTER )? 7484 int alt36=2; 7485 int LA36_0 = input.LA(1); 7486 if ( (LA36_0==DOTDOT) ) { 7487 alt36=1; 7488 } 7489 switch (alt36) { 7490 case 1 : 7491 // smaliParser.g:721:25: DOTDOT endreg= REGISTER 7492 { 7493 DOTDOT191=(Token)match(input,DOTDOT,FOLLOW_DOTDOT_in_register_range3117); 7494 stream_DOTDOT.add(DOTDOT191); 7495 7496 endreg=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_register_range3121); 7497 stream_REGISTER.add(endreg); 7498 7499 } 7500 break; 7501 7502 } 7503 7504 } 7505 break; 7506 7507 } 7508 7509 // AST REWRITE 7510 // elements: startreg, endreg 7511 // token labels: startreg, endreg 7512 // rule labels: retval 7513 // token list labels: 7514 // rule list labels: 7515 // wildcard labels: 7516 retval.tree = root_0; 7517 RewriteRuleTokenStream stream_startreg=new RewriteRuleTokenStream(adaptor,"token startreg",startreg); 7518 RewriteRuleTokenStream stream_endreg=new RewriteRuleTokenStream(adaptor,"token endreg",endreg); 7519 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7520 7521 root_0 = (CommonTree)adaptor.nil(); 7522 // 721:52: -> ^( I_REGISTER_RANGE[$start, \"I_REGISTER_RANGE\"] ( $startreg)? ( $endreg)? ) 7523 { 7524 // smaliParser.g:721:55: ^( I_REGISTER_RANGE[$start, \"I_REGISTER_RANGE\"] ( $startreg)? ( $endreg)? ) 7525 { 7526 CommonTree root_1 = (CommonTree)adaptor.nil(); 7527 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_REGISTER_RANGE, (retval.start), "I_REGISTER_RANGE"), root_1); 7528 // smaliParser.g:721:103: ( $startreg)? 7529 if ( stream_startreg.hasNext() ) { 7530 adaptor.addChild(root_1, stream_startreg.nextNode()); 7531 } 7532 stream_startreg.reset(); 7533 7534 // smaliParser.g:721:114: ( $endreg)? 7535 if ( stream_endreg.hasNext() ) { 7536 adaptor.addChild(root_1, stream_endreg.nextNode()); 7537 } 7538 stream_endreg.reset(); 7539 7540 adaptor.addChild(root_0, root_1); 7541 } 7542 7543 } 7544 7545 7546 retval.tree = root_0; 7547 7548 } 7549 7550 retval.stop = input.LT(-1); 7551 7552 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 7553 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 7554 7555 } 7556 catch (RecognitionException re) { 7557 reportError(re); 7558 recover(input,re); 7559 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 7560 } 7561 finally { 7562 // do for sure before leaving 7563 } 7564 return retval; 7565 } 7566 // $ANTLR end "register_range" 7567 7568 7569 public static class verification_error_reference_return extends ParserRuleReturnScope { 7570 CommonTree tree; 7571 @Override 7572 public CommonTree getTree() { return tree; } 7573 }; 7574 7575 7576 // $ANTLR start "verification_error_reference" 7577 // smaliParser.g:723:1: verification_error_reference : ( CLASS_DESCRIPTOR | field_reference | method_reference ); 7578 public final smaliParser.verification_error_reference_return verification_error_reference() throws RecognitionException { 7579 smaliParser.verification_error_reference_return retval = new smaliParser.verification_error_reference_return(); 7580 retval.start = input.LT(1); 7581 7582 CommonTree root_0 = null; 7583 7584 Token CLASS_DESCRIPTOR192=null; 7585 ParserRuleReturnScope field_reference193 =null; 7586 ParserRuleReturnScope method_reference194 =null; 7587 7588 CommonTree CLASS_DESCRIPTOR192_tree=null; 7589 7590 try { 7591 // smaliParser.g:724:3: ( CLASS_DESCRIPTOR | field_reference | method_reference ) 7592 int alt38=3; 7593 alt38 = dfa38.predict(input); 7594 switch (alt38) { 7595 case 1 : 7596 // smaliParser.g:724:5: CLASS_DESCRIPTOR 7597 { 7598 root_0 = (CommonTree)adaptor.nil(); 7599 7600 7601 CLASS_DESCRIPTOR192=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_verification_error_reference3150); 7602 CLASS_DESCRIPTOR192_tree = (CommonTree)adaptor.create(CLASS_DESCRIPTOR192); 7603 adaptor.addChild(root_0, CLASS_DESCRIPTOR192_tree); 7604 7605 } 7606 break; 7607 case 2 : 7608 // smaliParser.g:724:24: field_reference 7609 { 7610 root_0 = (CommonTree)adaptor.nil(); 7611 7612 7613 pushFollow(FOLLOW_field_reference_in_verification_error_reference3154); 7614 field_reference193=field_reference(); 7615 state._fsp--; 7616 7617 adaptor.addChild(root_0, field_reference193.getTree()); 7618 7619 } 7620 break; 7621 case 3 : 7622 // smaliParser.g:724:42: method_reference 7623 { 7624 root_0 = (CommonTree)adaptor.nil(); 7625 7626 7627 pushFollow(FOLLOW_method_reference_in_verification_error_reference3158); 7628 method_reference194=method_reference(); 7629 state._fsp--; 7630 7631 adaptor.addChild(root_0, method_reference194.getTree()); 7632 7633 } 7634 break; 7635 7636 } 7637 retval.stop = input.LT(-1); 7638 7639 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 7640 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 7641 7642 } 7643 catch (RecognitionException re) { 7644 reportError(re); 7645 recover(input,re); 7646 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 7647 } 7648 finally { 7649 // do for sure before leaving 7650 } 7651 return retval; 7652 } 7653 // $ANTLR end "verification_error_reference" 7654 7655 7656 public static class catch_directive_return extends ParserRuleReturnScope { 7657 CommonTree tree; 7658 @Override 7659 public CommonTree getTree() { return tree; } 7660 }; 7661 7662 7663 // $ANTLR start "catch_directive" 7664 // smaliParser.g:726:1: catch_directive : CATCH_DIRECTIVE nonvoid_type_descriptor OPEN_BRACE from= label_ref DOTDOT to= label_ref CLOSE_BRACE using= label_ref -> ^( I_CATCH[$start, \"I_CATCH\"] nonvoid_type_descriptor $from $to $using) ; 7665 public final smaliParser.catch_directive_return catch_directive() throws RecognitionException { 7666 smaliParser.catch_directive_return retval = new smaliParser.catch_directive_return(); 7667 retval.start = input.LT(1); 7668 7669 CommonTree root_0 = null; 7670 7671 Token CATCH_DIRECTIVE195=null; 7672 Token OPEN_BRACE197=null; 7673 Token DOTDOT198=null; 7674 Token CLOSE_BRACE199=null; 7675 ParserRuleReturnScope from =null; 7676 ParserRuleReturnScope to =null; 7677 ParserRuleReturnScope using =null; 7678 ParserRuleReturnScope nonvoid_type_descriptor196 =null; 7679 7680 CommonTree CATCH_DIRECTIVE195_tree=null; 7681 CommonTree OPEN_BRACE197_tree=null; 7682 CommonTree DOTDOT198_tree=null; 7683 CommonTree CLOSE_BRACE199_tree=null; 7684 RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE"); 7685 RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE"); 7686 RewriteRuleTokenStream stream_DOTDOT=new RewriteRuleTokenStream(adaptor,"token DOTDOT"); 7687 RewriteRuleTokenStream stream_CATCH_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token CATCH_DIRECTIVE"); 7688 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 7689 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 7690 7691 try { 7692 // smaliParser.g:727:3: ( CATCH_DIRECTIVE nonvoid_type_descriptor OPEN_BRACE from= label_ref DOTDOT to= label_ref CLOSE_BRACE using= label_ref -> ^( I_CATCH[$start, \"I_CATCH\"] nonvoid_type_descriptor $from $to $using) ) 7693 // smaliParser.g:727:5: CATCH_DIRECTIVE nonvoid_type_descriptor OPEN_BRACE from= label_ref DOTDOT to= label_ref CLOSE_BRACE using= label_ref 7694 { 7695 CATCH_DIRECTIVE195=(Token)match(input,CATCH_DIRECTIVE,FOLLOW_CATCH_DIRECTIVE_in_catch_directive3168); 7696 stream_CATCH_DIRECTIVE.add(CATCH_DIRECTIVE195); 7697 7698 pushFollow(FOLLOW_nonvoid_type_descriptor_in_catch_directive3170); 7699 nonvoid_type_descriptor196=nonvoid_type_descriptor(); 7700 state._fsp--; 7701 7702 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor196.getTree()); 7703 OPEN_BRACE197=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_catch_directive3172); 7704 stream_OPEN_BRACE.add(OPEN_BRACE197); 7705 7706 pushFollow(FOLLOW_label_ref_in_catch_directive3176); 7707 from=label_ref(); 7708 state._fsp--; 7709 7710 stream_label_ref.add(from.getTree()); 7711 DOTDOT198=(Token)match(input,DOTDOT,FOLLOW_DOTDOT_in_catch_directive3178); 7712 stream_DOTDOT.add(DOTDOT198); 7713 7714 pushFollow(FOLLOW_label_ref_in_catch_directive3182); 7715 to=label_ref(); 7716 state._fsp--; 7717 7718 stream_label_ref.add(to.getTree()); 7719 CLOSE_BRACE199=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_catch_directive3184); 7720 stream_CLOSE_BRACE.add(CLOSE_BRACE199); 7721 7722 pushFollow(FOLLOW_label_ref_in_catch_directive3188); 7723 using=label_ref(); 7724 state._fsp--; 7725 7726 stream_label_ref.add(using.getTree()); 7727 // AST REWRITE 7728 // elements: from, nonvoid_type_descriptor, using, to 7729 // token labels: 7730 // rule labels: using, from, to, retval 7731 // token list labels: 7732 // rule list labels: 7733 // wildcard labels: 7734 retval.tree = root_0; 7735 RewriteRuleSubtreeStream stream_using=new RewriteRuleSubtreeStream(adaptor,"rule using",using!=null?using.getTree():null); 7736 RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.getTree():null); 7737 RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.getTree():null); 7738 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7739 7740 root_0 = (CommonTree)adaptor.nil(); 7741 // 728:5: -> ^( I_CATCH[$start, \"I_CATCH\"] nonvoid_type_descriptor $from $to $using) 7742 { 7743 // smaliParser.g:728:8: ^( I_CATCH[$start, \"I_CATCH\"] nonvoid_type_descriptor $from $to $using) 7744 { 7745 CommonTree root_1 = (CommonTree)adaptor.nil(); 7746 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_CATCH, (retval.start), "I_CATCH"), root_1); 7747 adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree()); 7748 adaptor.addChild(root_1, stream_from.nextTree()); 7749 adaptor.addChild(root_1, stream_to.nextTree()); 7750 adaptor.addChild(root_1, stream_using.nextTree()); 7751 adaptor.addChild(root_0, root_1); 7752 } 7753 7754 } 7755 7756 7757 retval.tree = root_0; 7758 7759 } 7760 7761 retval.stop = input.LT(-1); 7762 7763 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 7764 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 7765 7766 } 7767 catch (RecognitionException re) { 7768 reportError(re); 7769 recover(input,re); 7770 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 7771 } 7772 finally { 7773 // do for sure before leaving 7774 } 7775 return retval; 7776 } 7777 // $ANTLR end "catch_directive" 7778 7779 7780 public static class catchall_directive_return extends ParserRuleReturnScope { 7781 CommonTree tree; 7782 @Override 7783 public CommonTree getTree() { return tree; } 7784 }; 7785 7786 7787 // $ANTLR start "catchall_directive" 7788 // smaliParser.g:730:1: catchall_directive : CATCHALL_DIRECTIVE OPEN_BRACE from= label_ref DOTDOT to= label_ref CLOSE_BRACE using= label_ref -> ^( I_CATCHALL[$start, \"I_CATCHALL\"] $from $to $using) ; 7789 public final smaliParser.catchall_directive_return catchall_directive() throws RecognitionException { 7790 smaliParser.catchall_directive_return retval = new smaliParser.catchall_directive_return(); 7791 retval.start = input.LT(1); 7792 7793 CommonTree root_0 = null; 7794 7795 Token CATCHALL_DIRECTIVE200=null; 7796 Token OPEN_BRACE201=null; 7797 Token DOTDOT202=null; 7798 Token CLOSE_BRACE203=null; 7799 ParserRuleReturnScope from =null; 7800 ParserRuleReturnScope to =null; 7801 ParserRuleReturnScope using =null; 7802 7803 CommonTree CATCHALL_DIRECTIVE200_tree=null; 7804 CommonTree OPEN_BRACE201_tree=null; 7805 CommonTree DOTDOT202_tree=null; 7806 CommonTree CLOSE_BRACE203_tree=null; 7807 RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE"); 7808 RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE"); 7809 RewriteRuleTokenStream stream_DOTDOT=new RewriteRuleTokenStream(adaptor,"token DOTDOT"); 7810 RewriteRuleTokenStream stream_CATCHALL_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token CATCHALL_DIRECTIVE"); 7811 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 7812 7813 try { 7814 // smaliParser.g:731:3: ( CATCHALL_DIRECTIVE OPEN_BRACE from= label_ref DOTDOT to= label_ref CLOSE_BRACE using= label_ref -> ^( I_CATCHALL[$start, \"I_CATCHALL\"] $from $to $using) ) 7815 // smaliParser.g:731:5: CATCHALL_DIRECTIVE OPEN_BRACE from= label_ref DOTDOT to= label_ref CLOSE_BRACE using= label_ref 7816 { 7817 CATCHALL_DIRECTIVE200=(Token)match(input,CATCHALL_DIRECTIVE,FOLLOW_CATCHALL_DIRECTIVE_in_catchall_directive3220); 7818 stream_CATCHALL_DIRECTIVE.add(CATCHALL_DIRECTIVE200); 7819 7820 OPEN_BRACE201=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_catchall_directive3222); 7821 stream_OPEN_BRACE.add(OPEN_BRACE201); 7822 7823 pushFollow(FOLLOW_label_ref_in_catchall_directive3226); 7824 from=label_ref(); 7825 state._fsp--; 7826 7827 stream_label_ref.add(from.getTree()); 7828 DOTDOT202=(Token)match(input,DOTDOT,FOLLOW_DOTDOT_in_catchall_directive3228); 7829 stream_DOTDOT.add(DOTDOT202); 7830 7831 pushFollow(FOLLOW_label_ref_in_catchall_directive3232); 7832 to=label_ref(); 7833 state._fsp--; 7834 7835 stream_label_ref.add(to.getTree()); 7836 CLOSE_BRACE203=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_catchall_directive3234); 7837 stream_CLOSE_BRACE.add(CLOSE_BRACE203); 7838 7839 pushFollow(FOLLOW_label_ref_in_catchall_directive3238); 7840 using=label_ref(); 7841 state._fsp--; 7842 7843 stream_label_ref.add(using.getTree()); 7844 // AST REWRITE 7845 // elements: using, to, from 7846 // token labels: 7847 // rule labels: using, from, to, retval 7848 // token list labels: 7849 // rule list labels: 7850 // wildcard labels: 7851 retval.tree = root_0; 7852 RewriteRuleSubtreeStream stream_using=new RewriteRuleSubtreeStream(adaptor,"rule using",using!=null?using.getTree():null); 7853 RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.getTree():null); 7854 RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.getTree():null); 7855 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7856 7857 root_0 = (CommonTree)adaptor.nil(); 7858 // 732:5: -> ^( I_CATCHALL[$start, \"I_CATCHALL\"] $from $to $using) 7859 { 7860 // smaliParser.g:732:8: ^( I_CATCHALL[$start, \"I_CATCHALL\"] $from $to $using) 7861 { 7862 CommonTree root_1 = (CommonTree)adaptor.nil(); 7863 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_CATCHALL, (retval.start), "I_CATCHALL"), root_1); 7864 adaptor.addChild(root_1, stream_from.nextTree()); 7865 adaptor.addChild(root_1, stream_to.nextTree()); 7866 adaptor.addChild(root_1, stream_using.nextTree()); 7867 adaptor.addChild(root_0, root_1); 7868 } 7869 7870 } 7871 7872 7873 retval.tree = root_0; 7874 7875 } 7876 7877 retval.stop = input.LT(-1); 7878 7879 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 7880 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 7881 7882 } 7883 catch (RecognitionException re) { 7884 reportError(re); 7885 recover(input,re); 7886 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 7887 } 7888 finally { 7889 // do for sure before leaving 7890 } 7891 return retval; 7892 } 7893 // $ANTLR end "catchall_directive" 7894 7895 7896 public static class parameter_directive_return extends ParserRuleReturnScope { 7897 CommonTree tree; 7898 @Override 7899 public CommonTree getTree() { return tree; } 7900 }; 7901 7902 7903 // $ANTLR start "parameter_directive" 7904 // smaliParser.g:738:1: parameter_directive : PARAMETER_DIRECTIVE REGISTER ( COMMA STRING_LITERAL )? ({...}? annotation )* ( END_PARAMETER_DIRECTIVE -> ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ( annotation )* ) ) | -> ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ) ) ) ; 7905 public final smaliParser.parameter_directive_return parameter_directive() throws RecognitionException { 7906 smaliParser.parameter_directive_return retval = new smaliParser.parameter_directive_return(); 7907 retval.start = input.LT(1); 7908 7909 CommonTree root_0 = null; 7910 7911 Token PARAMETER_DIRECTIVE204=null; 7912 Token REGISTER205=null; 7913 Token COMMA206=null; 7914 Token STRING_LITERAL207=null; 7915 Token END_PARAMETER_DIRECTIVE209=null; 7916 ParserRuleReturnScope annotation208 =null; 7917 7918 CommonTree PARAMETER_DIRECTIVE204_tree=null; 7919 CommonTree REGISTER205_tree=null; 7920 CommonTree COMMA206_tree=null; 7921 CommonTree STRING_LITERAL207_tree=null; 7922 CommonTree END_PARAMETER_DIRECTIVE209_tree=null; 7923 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 7924 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 7925 RewriteRuleTokenStream stream_PARAMETER_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token PARAMETER_DIRECTIVE"); 7926 RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL"); 7927 RewriteRuleTokenStream stream_END_PARAMETER_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_PARAMETER_DIRECTIVE"); 7928 RewriteRuleSubtreeStream stream_annotation=new RewriteRuleSubtreeStream(adaptor,"rule annotation"); 7929 7930 List<CommonTree> annotations = new ArrayList<CommonTree>(); 7931 try { 7932 // smaliParser.g:740:3: ( PARAMETER_DIRECTIVE REGISTER ( COMMA STRING_LITERAL )? ({...}? annotation )* ( END_PARAMETER_DIRECTIVE -> ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ( annotation )* ) ) | -> ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ) ) ) ) 7933 // smaliParser.g:740:5: PARAMETER_DIRECTIVE REGISTER ( COMMA STRING_LITERAL )? ({...}? annotation )* ( END_PARAMETER_DIRECTIVE -> ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ( annotation )* ) ) | -> ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ) ) ) 7934 { 7935 PARAMETER_DIRECTIVE204=(Token)match(input,PARAMETER_DIRECTIVE,FOLLOW_PARAMETER_DIRECTIVE_in_parameter_directive3277); 7936 stream_PARAMETER_DIRECTIVE.add(PARAMETER_DIRECTIVE204); 7937 7938 REGISTER205=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_parameter_directive3279); 7939 stream_REGISTER.add(REGISTER205); 7940 7941 // smaliParser.g:740:34: ( COMMA STRING_LITERAL )? 7942 int alt39=2; 7943 int LA39_0 = input.LA(1); 7944 if ( (LA39_0==COMMA) ) { 7945 alt39=1; 7946 } 7947 switch (alt39) { 7948 case 1 : 7949 // smaliParser.g:740:35: COMMA STRING_LITERAL 7950 { 7951 COMMA206=(Token)match(input,COMMA,FOLLOW_COMMA_in_parameter_directive3282); 7952 stream_COMMA.add(COMMA206); 7953 7954 STRING_LITERAL207=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_parameter_directive3284); 7955 stream_STRING_LITERAL.add(STRING_LITERAL207); 7956 7957 } 7958 break; 7959 7960 } 7961 7962 // smaliParser.g:741:5: ({...}? annotation )* 7963 loop40: 7964 while (true) { 7965 int alt40=2; 7966 alt40 = dfa40.predict(input); 7967 switch (alt40) { 7968 case 1 : 7969 // smaliParser.g:741:6: {...}? annotation 7970 { 7971 if ( !((input.LA(1) == ANNOTATION_DIRECTIVE)) ) { 7972 throw new FailedPredicateException(input, "parameter_directive", "input.LA(1) == ANNOTATION_DIRECTIVE"); 7973 } 7974 pushFollow(FOLLOW_annotation_in_parameter_directive3295); 7975 annotation208=annotation(); 7976 state._fsp--; 7977 7978 stream_annotation.add(annotation208.getTree()); 7979 annotations.add((annotation208!=null?((CommonTree)annotation208.getTree()):null)); 7980 } 7981 break; 7982 7983 default : 7984 break loop40; 7985 } 7986 } 7987 7988 // smaliParser.g:743:5: ( END_PARAMETER_DIRECTIVE -> ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ( annotation )* ) ) | -> ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ) ) ) 7989 int alt41=2; 7990 int LA41_0 = input.LA(1); 7991 if ( (LA41_0==END_PARAMETER_DIRECTIVE) ) { 7992 alt41=1; 7993 } 7994 else if ( (LA41_0==ANNOTATION_DIRECTIVE||LA41_0==ARRAY_DATA_DIRECTIVE||(LA41_0 >= CATCHALL_DIRECTIVE && LA41_0 <= CATCH_DIRECTIVE)||LA41_0==COLON||(LA41_0 >= END_LOCAL_DIRECTIVE && LA41_0 <= END_METHOD_DIRECTIVE)||LA41_0==EPILOGUE_DIRECTIVE||(LA41_0 >= INSTRUCTION_FORMAT10t && LA41_0 <= INSTRUCTION_FORMAT51l)||(LA41_0 >= LINE_DIRECTIVE && LA41_0 <= LOCAL_DIRECTIVE)||(LA41_0 >= PACKED_SWITCH_DIRECTIVE && LA41_0 <= PARAMETER_DIRECTIVE)||LA41_0==PROLOGUE_DIRECTIVE||(LA41_0 >= REGISTERS_DIRECTIVE && LA41_0 <= RESTART_LOCAL_DIRECTIVE)||(LA41_0 >= SOURCE_DIRECTIVE && LA41_0 <= SPARSE_SWITCH_DIRECTIVE)) ) { 7995 alt41=2; 7996 } 7997 7998 else { 7999 NoViableAltException nvae = 8000 new NoViableAltException("", 41, 0, input); 8001 throw nvae; 8002 } 8003 8004 switch (alt41) { 8005 case 1 : 8006 // smaliParser.g:743:7: END_PARAMETER_DIRECTIVE 8007 { 8008 END_PARAMETER_DIRECTIVE209=(Token)match(input,END_PARAMETER_DIRECTIVE,FOLLOW_END_PARAMETER_DIRECTIVE_in_parameter_directive3308); 8009 stream_END_PARAMETER_DIRECTIVE.add(END_PARAMETER_DIRECTIVE209); 8010 8011 // AST REWRITE 8012 // elements: STRING_LITERAL, annotation, REGISTER 8013 // token labels: 8014 // rule labels: retval 8015 // token list labels: 8016 // rule list labels: 8017 // wildcard labels: 8018 retval.tree = root_0; 8019 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 8020 8021 root_0 = (CommonTree)adaptor.nil(); 8022 // 744:7: -> ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ( annotation )* ) ) 8023 { 8024 // smaliParser.g:744:10: ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ( annotation )* ) ) 8025 { 8026 CommonTree root_1 = (CommonTree)adaptor.nil(); 8027 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_PARAMETER, (retval.start), "I_PARAMETER"), root_1); 8028 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 8029 // smaliParser.g:744:56: ( STRING_LITERAL )? 8030 if ( stream_STRING_LITERAL.hasNext() ) { 8031 adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode()); 8032 } 8033 stream_STRING_LITERAL.reset(); 8034 8035 // smaliParser.g:744:72: ^( I_ANNOTATIONS ( annotation )* ) 8036 { 8037 CommonTree root_2 = (CommonTree)adaptor.nil(); 8038 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ANNOTATIONS, "I_ANNOTATIONS"), root_2); 8039 // smaliParser.g:744:88: ( annotation )* 8040 while ( stream_annotation.hasNext() ) { 8041 adaptor.addChild(root_2, stream_annotation.nextTree()); 8042 } 8043 stream_annotation.reset(); 8044 8045 adaptor.addChild(root_1, root_2); 8046 } 8047 8048 adaptor.addChild(root_0, root_1); 8049 } 8050 8051 } 8052 8053 8054 retval.tree = root_0; 8055 8056 } 8057 break; 8058 case 2 : 8059 // smaliParser.g:745:19: 8060 { 8061 statements_and_directives_stack.peek().methodAnnotations.addAll(annotations); 8062 // AST REWRITE 8063 // elements: STRING_LITERAL, REGISTER 8064 // token labels: 8065 // rule labels: retval 8066 // token list labels: 8067 // rule list labels: 8068 // wildcard labels: 8069 retval.tree = root_0; 8070 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 8071 8072 root_0 = (CommonTree)adaptor.nil(); 8073 // 746:7: -> ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ) ) 8074 { 8075 // smaliParser.g:746:10: ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ) ) 8076 { 8077 CommonTree root_1 = (CommonTree)adaptor.nil(); 8078 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_PARAMETER, (retval.start), "I_PARAMETER"), root_1); 8079 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 8080 // smaliParser.g:746:56: ( STRING_LITERAL )? 8081 if ( stream_STRING_LITERAL.hasNext() ) { 8082 adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode()); 8083 } 8084 stream_STRING_LITERAL.reset(); 8085 8086 // smaliParser.g:746:72: ^( I_ANNOTATIONS ) 8087 { 8088 CommonTree root_2 = (CommonTree)adaptor.nil(); 8089 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ANNOTATIONS, "I_ANNOTATIONS"), root_2); 8090 adaptor.addChild(root_1, root_2); 8091 } 8092 8093 adaptor.addChild(root_0, root_1); 8094 } 8095 8096 } 8097 8098 8099 retval.tree = root_0; 8100 8101 } 8102 break; 8103 8104 } 8105 8106 } 8107 8108 retval.stop = input.LT(-1); 8109 8110 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8111 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8112 8113 } 8114 catch (RecognitionException re) { 8115 reportError(re); 8116 recover(input,re); 8117 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8118 } 8119 finally { 8120 // do for sure before leaving 8121 } 8122 return retval; 8123 } 8124 // $ANTLR end "parameter_directive" 8125 8126 8127 public static class debug_directive_return extends ParserRuleReturnScope { 8128 CommonTree tree; 8129 @Override 8130 public CommonTree getTree() { return tree; } 8131 }; 8132 8133 8134 // $ANTLR start "debug_directive" 8135 // smaliParser.g:749:1: debug_directive : ( line_directive | local_directive | end_local_directive | restart_local_directive | prologue_directive | epilogue_directive | source_directive ); 8136 public final smaliParser.debug_directive_return debug_directive() throws RecognitionException { 8137 smaliParser.debug_directive_return retval = new smaliParser.debug_directive_return(); 8138 retval.start = input.LT(1); 8139 8140 CommonTree root_0 = null; 8141 8142 ParserRuleReturnScope line_directive210 =null; 8143 ParserRuleReturnScope local_directive211 =null; 8144 ParserRuleReturnScope end_local_directive212 =null; 8145 ParserRuleReturnScope restart_local_directive213 =null; 8146 ParserRuleReturnScope prologue_directive214 =null; 8147 ParserRuleReturnScope epilogue_directive215 =null; 8148 ParserRuleReturnScope source_directive216 =null; 8149 8150 8151 try { 8152 // smaliParser.g:750:3: ( line_directive | local_directive | end_local_directive | restart_local_directive | prologue_directive | epilogue_directive | source_directive ) 8153 int alt42=7; 8154 switch ( input.LA(1) ) { 8155 case LINE_DIRECTIVE: 8156 { 8157 alt42=1; 8158 } 8159 break; 8160 case LOCAL_DIRECTIVE: 8161 { 8162 alt42=2; 8163 } 8164 break; 8165 case END_LOCAL_DIRECTIVE: 8166 { 8167 alt42=3; 8168 } 8169 break; 8170 case RESTART_LOCAL_DIRECTIVE: 8171 { 8172 alt42=4; 8173 } 8174 break; 8175 case PROLOGUE_DIRECTIVE: 8176 { 8177 alt42=5; 8178 } 8179 break; 8180 case EPILOGUE_DIRECTIVE: 8181 { 8182 alt42=6; 8183 } 8184 break; 8185 case SOURCE_DIRECTIVE: 8186 { 8187 alt42=7; 8188 } 8189 break; 8190 default: 8191 NoViableAltException nvae = 8192 new NoViableAltException("", 42, 0, input); 8193 throw nvae; 8194 } 8195 switch (alt42) { 8196 case 1 : 8197 // smaliParser.g:750:5: line_directive 8198 { 8199 root_0 = (CommonTree)adaptor.nil(); 8200 8201 8202 pushFollow(FOLLOW_line_directive_in_debug_directive3381); 8203 line_directive210=line_directive(); 8204 state._fsp--; 8205 8206 adaptor.addChild(root_0, line_directive210.getTree()); 8207 8208 } 8209 break; 8210 case 2 : 8211 // smaliParser.g:751:5: local_directive 8212 { 8213 root_0 = (CommonTree)adaptor.nil(); 8214 8215 8216 pushFollow(FOLLOW_local_directive_in_debug_directive3387); 8217 local_directive211=local_directive(); 8218 state._fsp--; 8219 8220 adaptor.addChild(root_0, local_directive211.getTree()); 8221 8222 } 8223 break; 8224 case 3 : 8225 // smaliParser.g:752:5: end_local_directive 8226 { 8227 root_0 = (CommonTree)adaptor.nil(); 8228 8229 8230 pushFollow(FOLLOW_end_local_directive_in_debug_directive3393); 8231 end_local_directive212=end_local_directive(); 8232 state._fsp--; 8233 8234 adaptor.addChild(root_0, end_local_directive212.getTree()); 8235 8236 } 8237 break; 8238 case 4 : 8239 // smaliParser.g:753:5: restart_local_directive 8240 { 8241 root_0 = (CommonTree)adaptor.nil(); 8242 8243 8244 pushFollow(FOLLOW_restart_local_directive_in_debug_directive3399); 8245 restart_local_directive213=restart_local_directive(); 8246 state._fsp--; 8247 8248 adaptor.addChild(root_0, restart_local_directive213.getTree()); 8249 8250 } 8251 break; 8252 case 5 : 8253 // smaliParser.g:754:5: prologue_directive 8254 { 8255 root_0 = (CommonTree)adaptor.nil(); 8256 8257 8258 pushFollow(FOLLOW_prologue_directive_in_debug_directive3405); 8259 prologue_directive214=prologue_directive(); 8260 state._fsp--; 8261 8262 adaptor.addChild(root_0, prologue_directive214.getTree()); 8263 8264 } 8265 break; 8266 case 6 : 8267 // smaliParser.g:755:5: epilogue_directive 8268 { 8269 root_0 = (CommonTree)adaptor.nil(); 8270 8271 8272 pushFollow(FOLLOW_epilogue_directive_in_debug_directive3411); 8273 epilogue_directive215=epilogue_directive(); 8274 state._fsp--; 8275 8276 adaptor.addChild(root_0, epilogue_directive215.getTree()); 8277 8278 } 8279 break; 8280 case 7 : 8281 // smaliParser.g:756:5: source_directive 8282 { 8283 root_0 = (CommonTree)adaptor.nil(); 8284 8285 8286 pushFollow(FOLLOW_source_directive_in_debug_directive3417); 8287 source_directive216=source_directive(); 8288 state._fsp--; 8289 8290 adaptor.addChild(root_0, source_directive216.getTree()); 8291 8292 } 8293 break; 8294 8295 } 8296 retval.stop = input.LT(-1); 8297 8298 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8299 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8300 8301 } 8302 catch (RecognitionException re) { 8303 reportError(re); 8304 recover(input,re); 8305 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8306 } 8307 finally { 8308 // do for sure before leaving 8309 } 8310 return retval; 8311 } 8312 // $ANTLR end "debug_directive" 8313 8314 8315 public static class line_directive_return extends ParserRuleReturnScope { 8316 CommonTree tree; 8317 @Override 8318 public CommonTree getTree() { return tree; } 8319 }; 8320 8321 8322 // $ANTLR start "line_directive" 8323 // smaliParser.g:758:1: line_directive : LINE_DIRECTIVE integral_literal -> ^( I_LINE[$start, \"I_LINE\"] integral_literal ) ; 8324 public final smaliParser.line_directive_return line_directive() throws RecognitionException { 8325 smaliParser.line_directive_return retval = new smaliParser.line_directive_return(); 8326 retval.start = input.LT(1); 8327 8328 CommonTree root_0 = null; 8329 8330 Token LINE_DIRECTIVE217=null; 8331 ParserRuleReturnScope integral_literal218 =null; 8332 8333 CommonTree LINE_DIRECTIVE217_tree=null; 8334 RewriteRuleTokenStream stream_LINE_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token LINE_DIRECTIVE"); 8335 RewriteRuleSubtreeStream stream_integral_literal=new RewriteRuleSubtreeStream(adaptor,"rule integral_literal"); 8336 8337 try { 8338 // smaliParser.g:759:3: ( LINE_DIRECTIVE integral_literal -> ^( I_LINE[$start, \"I_LINE\"] integral_literal ) ) 8339 // smaliParser.g:759:5: LINE_DIRECTIVE integral_literal 8340 { 8341 LINE_DIRECTIVE217=(Token)match(input,LINE_DIRECTIVE,FOLLOW_LINE_DIRECTIVE_in_line_directive3427); 8342 stream_LINE_DIRECTIVE.add(LINE_DIRECTIVE217); 8343 8344 pushFollow(FOLLOW_integral_literal_in_line_directive3429); 8345 integral_literal218=integral_literal(); 8346 state._fsp--; 8347 8348 stream_integral_literal.add(integral_literal218.getTree()); 8349 // AST REWRITE 8350 // elements: integral_literal 8351 // token labels: 8352 // rule labels: retval 8353 // token list labels: 8354 // rule list labels: 8355 // wildcard labels: 8356 retval.tree = root_0; 8357 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 8358 8359 root_0 = (CommonTree)adaptor.nil(); 8360 // 760:5: -> ^( I_LINE[$start, \"I_LINE\"] integral_literal ) 8361 { 8362 // smaliParser.g:760:8: ^( I_LINE[$start, \"I_LINE\"] integral_literal ) 8363 { 8364 CommonTree root_1 = (CommonTree)adaptor.nil(); 8365 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_LINE, (retval.start), "I_LINE"), root_1); 8366 adaptor.addChild(root_1, stream_integral_literal.nextTree()); 8367 adaptor.addChild(root_0, root_1); 8368 } 8369 8370 } 8371 8372 8373 retval.tree = root_0; 8374 8375 } 8376 8377 retval.stop = input.LT(-1); 8378 8379 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8380 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8381 8382 } 8383 catch (RecognitionException re) { 8384 reportError(re); 8385 recover(input,re); 8386 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8387 } 8388 finally { 8389 // do for sure before leaving 8390 } 8391 return retval; 8392 } 8393 // $ANTLR end "line_directive" 8394 8395 8396 public static class local_directive_return extends ParserRuleReturnScope { 8397 CommonTree tree; 8398 @Override 8399 public CommonTree getTree() { return tree; } 8400 }; 8401 8402 8403 // $ANTLR start "local_directive" 8404 // smaliParser.g:762:1: local_directive : LOCAL_DIRECTIVE REGISTER ( COMMA ( NULL_LITERAL |name= STRING_LITERAL ) COLON ( VOID_TYPE | nonvoid_type_descriptor ) ( COMMA signature= STRING_LITERAL )? )? -> ^( I_LOCAL[$start, \"I_LOCAL\"] REGISTER ( NULL_LITERAL )? ( $name)? ( nonvoid_type_descriptor )? ( $signature)? ) ; 8405 public final smaliParser.local_directive_return local_directive() throws RecognitionException { 8406 smaliParser.local_directive_return retval = new smaliParser.local_directive_return(); 8407 retval.start = input.LT(1); 8408 8409 CommonTree root_0 = null; 8410 8411 Token name=null; 8412 Token signature=null; 8413 Token LOCAL_DIRECTIVE219=null; 8414 Token REGISTER220=null; 8415 Token COMMA221=null; 8416 Token NULL_LITERAL222=null; 8417 Token COLON223=null; 8418 Token VOID_TYPE224=null; 8419 Token COMMA226=null; 8420 ParserRuleReturnScope nonvoid_type_descriptor225 =null; 8421 8422 CommonTree name_tree=null; 8423 CommonTree signature_tree=null; 8424 CommonTree LOCAL_DIRECTIVE219_tree=null; 8425 CommonTree REGISTER220_tree=null; 8426 CommonTree COMMA221_tree=null; 8427 CommonTree NULL_LITERAL222_tree=null; 8428 CommonTree COLON223_tree=null; 8429 CommonTree VOID_TYPE224_tree=null; 8430 CommonTree COMMA226_tree=null; 8431 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 8432 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 8433 RewriteRuleTokenStream stream_LOCAL_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token LOCAL_DIRECTIVE"); 8434 RewriteRuleTokenStream stream_VOID_TYPE=new RewriteRuleTokenStream(adaptor,"token VOID_TYPE"); 8435 RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL"); 8436 RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON"); 8437 RewriteRuleTokenStream stream_NULL_LITERAL=new RewriteRuleTokenStream(adaptor,"token NULL_LITERAL"); 8438 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 8439 8440 try { 8441 // smaliParser.g:763:3: ( LOCAL_DIRECTIVE REGISTER ( COMMA ( NULL_LITERAL |name= STRING_LITERAL ) COLON ( VOID_TYPE | nonvoid_type_descriptor ) ( COMMA signature= STRING_LITERAL )? )? -> ^( I_LOCAL[$start, \"I_LOCAL\"] REGISTER ( NULL_LITERAL )? ( $name)? ( nonvoid_type_descriptor )? ( $signature)? ) ) 8442 // smaliParser.g:763:5: LOCAL_DIRECTIVE REGISTER ( COMMA ( NULL_LITERAL |name= STRING_LITERAL ) COLON ( VOID_TYPE | nonvoid_type_descriptor ) ( COMMA signature= STRING_LITERAL )? )? 8443 { 8444 LOCAL_DIRECTIVE219=(Token)match(input,LOCAL_DIRECTIVE,FOLLOW_LOCAL_DIRECTIVE_in_local_directive3452); 8445 stream_LOCAL_DIRECTIVE.add(LOCAL_DIRECTIVE219); 8446 8447 REGISTER220=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_local_directive3454); 8448 stream_REGISTER.add(REGISTER220); 8449 8450 // smaliParser.g:763:30: ( COMMA ( NULL_LITERAL |name= STRING_LITERAL ) COLON ( VOID_TYPE | nonvoid_type_descriptor ) ( COMMA signature= STRING_LITERAL )? )? 8451 int alt46=2; 8452 int LA46_0 = input.LA(1); 8453 if ( (LA46_0==COMMA) ) { 8454 alt46=1; 8455 } 8456 switch (alt46) { 8457 case 1 : 8458 // smaliParser.g:763:31: COMMA ( NULL_LITERAL |name= STRING_LITERAL ) COLON ( VOID_TYPE | nonvoid_type_descriptor ) ( COMMA signature= STRING_LITERAL )? 8459 { 8460 COMMA221=(Token)match(input,COMMA,FOLLOW_COMMA_in_local_directive3457); 8461 stream_COMMA.add(COMMA221); 8462 8463 // smaliParser.g:763:37: ( NULL_LITERAL |name= STRING_LITERAL ) 8464 int alt43=2; 8465 int LA43_0 = input.LA(1); 8466 if ( (LA43_0==NULL_LITERAL) ) { 8467 alt43=1; 8468 } 8469 else if ( (LA43_0==STRING_LITERAL) ) { 8470 alt43=2; 8471 } 8472 8473 else { 8474 NoViableAltException nvae = 8475 new NoViableAltException("", 43, 0, input); 8476 throw nvae; 8477 } 8478 8479 switch (alt43) { 8480 case 1 : 8481 // smaliParser.g:763:38: NULL_LITERAL 8482 { 8483 NULL_LITERAL222=(Token)match(input,NULL_LITERAL,FOLLOW_NULL_LITERAL_in_local_directive3460); 8484 stream_NULL_LITERAL.add(NULL_LITERAL222); 8485 8486 } 8487 break; 8488 case 2 : 8489 // smaliParser.g:763:53: name= STRING_LITERAL 8490 { 8491 name=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_local_directive3466); 8492 stream_STRING_LITERAL.add(name); 8493 8494 } 8495 break; 8496 8497 } 8498 8499 COLON223=(Token)match(input,COLON,FOLLOW_COLON_in_local_directive3469); 8500 stream_COLON.add(COLON223); 8501 8502 // smaliParser.g:763:80: ( VOID_TYPE | nonvoid_type_descriptor ) 8503 int alt44=2; 8504 int LA44_0 = input.LA(1); 8505 if ( (LA44_0==VOID_TYPE) ) { 8506 alt44=1; 8507 } 8508 else if ( (LA44_0==ARRAY_TYPE_PREFIX||LA44_0==CLASS_DESCRIPTOR||LA44_0==PRIMITIVE_TYPE) ) { 8509 alt44=2; 8510 } 8511 8512 else { 8513 NoViableAltException nvae = 8514 new NoViableAltException("", 44, 0, input); 8515 throw nvae; 8516 } 8517 8518 switch (alt44) { 8519 case 1 : 8520 // smaliParser.g:763:81: VOID_TYPE 8521 { 8522 VOID_TYPE224=(Token)match(input,VOID_TYPE,FOLLOW_VOID_TYPE_in_local_directive3472); 8523 stream_VOID_TYPE.add(VOID_TYPE224); 8524 8525 } 8526 break; 8527 case 2 : 8528 // smaliParser.g:763:93: nonvoid_type_descriptor 8529 { 8530 pushFollow(FOLLOW_nonvoid_type_descriptor_in_local_directive3476); 8531 nonvoid_type_descriptor225=nonvoid_type_descriptor(); 8532 state._fsp--; 8533 8534 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor225.getTree()); 8535 } 8536 break; 8537 8538 } 8539 8540 // smaliParser.g:764:31: ( COMMA signature= STRING_LITERAL )? 8541 int alt45=2; 8542 int LA45_0 = input.LA(1); 8543 if ( (LA45_0==COMMA) ) { 8544 alt45=1; 8545 } 8546 switch (alt45) { 8547 case 1 : 8548 // smaliParser.g:764:32: COMMA signature= STRING_LITERAL 8549 { 8550 COMMA226=(Token)match(input,COMMA,FOLLOW_COMMA_in_local_directive3510); 8551 stream_COMMA.add(COMMA226); 8552 8553 signature=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_local_directive3514); 8554 stream_STRING_LITERAL.add(signature); 8555 8556 } 8557 break; 8558 8559 } 8560 8561 } 8562 break; 8563 8564 } 8565 8566 // AST REWRITE 8567 // elements: name, NULL_LITERAL, nonvoid_type_descriptor, REGISTER, signature 8568 // token labels: signature, name 8569 // rule labels: retval 8570 // token list labels: 8571 // rule list labels: 8572 // wildcard labels: 8573 retval.tree = root_0; 8574 RewriteRuleTokenStream stream_signature=new RewriteRuleTokenStream(adaptor,"token signature",signature); 8575 RewriteRuleTokenStream stream_name=new RewriteRuleTokenStream(adaptor,"token name",name); 8576 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 8577 8578 root_0 = (CommonTree)adaptor.nil(); 8579 // 765:5: -> ^( I_LOCAL[$start, \"I_LOCAL\"] REGISTER ( NULL_LITERAL )? ( $name)? ( nonvoid_type_descriptor )? ( $signature)? ) 8580 { 8581 // smaliParser.g:765:8: ^( I_LOCAL[$start, \"I_LOCAL\"] REGISTER ( NULL_LITERAL )? ( $name)? ( nonvoid_type_descriptor )? ( $signature)? ) 8582 { 8583 CommonTree root_1 = (CommonTree)adaptor.nil(); 8584 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_LOCAL, (retval.start), "I_LOCAL"), root_1); 8585 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 8586 // smaliParser.g:765:46: ( NULL_LITERAL )? 8587 if ( stream_NULL_LITERAL.hasNext() ) { 8588 adaptor.addChild(root_1, stream_NULL_LITERAL.nextNode()); 8589 } 8590 stream_NULL_LITERAL.reset(); 8591 8592 // smaliParser.g:765:61: ( $name)? 8593 if ( stream_name.hasNext() ) { 8594 adaptor.addChild(root_1, stream_name.nextNode()); 8595 } 8596 stream_name.reset(); 8597 8598 // smaliParser.g:765:67: ( nonvoid_type_descriptor )? 8599 if ( stream_nonvoid_type_descriptor.hasNext() ) { 8600 adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree()); 8601 } 8602 stream_nonvoid_type_descriptor.reset(); 8603 8604 // smaliParser.g:765:93: ( $signature)? 8605 if ( stream_signature.hasNext() ) { 8606 adaptor.addChild(root_1, stream_signature.nextNode()); 8607 } 8608 stream_signature.reset(); 8609 8610 adaptor.addChild(root_0, root_1); 8611 } 8612 8613 } 8614 8615 8616 retval.tree = root_0; 8617 8618 } 8619 8620 retval.stop = input.LT(-1); 8621 8622 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8623 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8624 8625 } 8626 catch (RecognitionException re) { 8627 reportError(re); 8628 recover(input,re); 8629 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8630 } 8631 finally { 8632 // do for sure before leaving 8633 } 8634 return retval; 8635 } 8636 // $ANTLR end "local_directive" 8637 8638 8639 public static class end_local_directive_return extends ParserRuleReturnScope { 8640 CommonTree tree; 8641 @Override 8642 public CommonTree getTree() { return tree; } 8643 }; 8644 8645 8646 // $ANTLR start "end_local_directive" 8647 // smaliParser.g:767:1: end_local_directive : END_LOCAL_DIRECTIVE REGISTER -> ^( I_END_LOCAL[$start, \"I_END_LOCAL\"] REGISTER ) ; 8648 public final smaliParser.end_local_directive_return end_local_directive() throws RecognitionException { 8649 smaliParser.end_local_directive_return retval = new smaliParser.end_local_directive_return(); 8650 retval.start = input.LT(1); 8651 8652 CommonTree root_0 = null; 8653 8654 Token END_LOCAL_DIRECTIVE227=null; 8655 Token REGISTER228=null; 8656 8657 CommonTree END_LOCAL_DIRECTIVE227_tree=null; 8658 CommonTree REGISTER228_tree=null; 8659 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 8660 RewriteRuleTokenStream stream_END_LOCAL_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_LOCAL_DIRECTIVE"); 8661 8662 try { 8663 // smaliParser.g:768:3: ( END_LOCAL_DIRECTIVE REGISTER -> ^( I_END_LOCAL[$start, \"I_END_LOCAL\"] REGISTER ) ) 8664 // smaliParser.g:768:5: END_LOCAL_DIRECTIVE REGISTER 8665 { 8666 END_LOCAL_DIRECTIVE227=(Token)match(input,END_LOCAL_DIRECTIVE,FOLLOW_END_LOCAL_DIRECTIVE_in_end_local_directive3556); 8667 stream_END_LOCAL_DIRECTIVE.add(END_LOCAL_DIRECTIVE227); 8668 8669 REGISTER228=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_end_local_directive3558); 8670 stream_REGISTER.add(REGISTER228); 8671 8672 // AST REWRITE 8673 // elements: REGISTER 8674 // token labels: 8675 // rule labels: retval 8676 // token list labels: 8677 // rule list labels: 8678 // wildcard labels: 8679 retval.tree = root_0; 8680 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 8681 8682 root_0 = (CommonTree)adaptor.nil(); 8683 // 769:5: -> ^( I_END_LOCAL[$start, \"I_END_LOCAL\"] REGISTER ) 8684 { 8685 // smaliParser.g:769:8: ^( I_END_LOCAL[$start, \"I_END_LOCAL\"] REGISTER ) 8686 { 8687 CommonTree root_1 = (CommonTree)adaptor.nil(); 8688 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_END_LOCAL, (retval.start), "I_END_LOCAL"), root_1); 8689 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 8690 adaptor.addChild(root_0, root_1); 8691 } 8692 8693 } 8694 8695 8696 retval.tree = root_0; 8697 8698 } 8699 8700 retval.stop = input.LT(-1); 8701 8702 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8703 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8704 8705 } 8706 catch (RecognitionException re) { 8707 reportError(re); 8708 recover(input,re); 8709 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8710 } 8711 finally { 8712 // do for sure before leaving 8713 } 8714 return retval; 8715 } 8716 // $ANTLR end "end_local_directive" 8717 8718 8719 public static class restart_local_directive_return extends ParserRuleReturnScope { 8720 CommonTree tree; 8721 @Override 8722 public CommonTree getTree() { return tree; } 8723 }; 8724 8725 8726 // $ANTLR start "restart_local_directive" 8727 // smaliParser.g:771:1: restart_local_directive : RESTART_LOCAL_DIRECTIVE REGISTER -> ^( I_RESTART_LOCAL[$start, \"I_RESTART_LOCAL\"] REGISTER ) ; 8728 public final smaliParser.restart_local_directive_return restart_local_directive() throws RecognitionException { 8729 smaliParser.restart_local_directive_return retval = new smaliParser.restart_local_directive_return(); 8730 retval.start = input.LT(1); 8731 8732 CommonTree root_0 = null; 8733 8734 Token RESTART_LOCAL_DIRECTIVE229=null; 8735 Token REGISTER230=null; 8736 8737 CommonTree RESTART_LOCAL_DIRECTIVE229_tree=null; 8738 CommonTree REGISTER230_tree=null; 8739 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 8740 RewriteRuleTokenStream stream_RESTART_LOCAL_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token RESTART_LOCAL_DIRECTIVE"); 8741 8742 try { 8743 // smaliParser.g:772:3: ( RESTART_LOCAL_DIRECTIVE REGISTER -> ^( I_RESTART_LOCAL[$start, \"I_RESTART_LOCAL\"] REGISTER ) ) 8744 // smaliParser.g:772:5: RESTART_LOCAL_DIRECTIVE REGISTER 8745 { 8746 RESTART_LOCAL_DIRECTIVE229=(Token)match(input,RESTART_LOCAL_DIRECTIVE,FOLLOW_RESTART_LOCAL_DIRECTIVE_in_restart_local_directive3581); 8747 stream_RESTART_LOCAL_DIRECTIVE.add(RESTART_LOCAL_DIRECTIVE229); 8748 8749 REGISTER230=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_restart_local_directive3583); 8750 stream_REGISTER.add(REGISTER230); 8751 8752 // AST REWRITE 8753 // elements: REGISTER 8754 // token labels: 8755 // rule labels: retval 8756 // token list labels: 8757 // rule list labels: 8758 // wildcard labels: 8759 retval.tree = root_0; 8760 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 8761 8762 root_0 = (CommonTree)adaptor.nil(); 8763 // 773:5: -> ^( I_RESTART_LOCAL[$start, \"I_RESTART_LOCAL\"] REGISTER ) 8764 { 8765 // smaliParser.g:773:8: ^( I_RESTART_LOCAL[$start, \"I_RESTART_LOCAL\"] REGISTER ) 8766 { 8767 CommonTree root_1 = (CommonTree)adaptor.nil(); 8768 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_RESTART_LOCAL, (retval.start), "I_RESTART_LOCAL"), root_1); 8769 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 8770 adaptor.addChild(root_0, root_1); 8771 } 8772 8773 } 8774 8775 8776 retval.tree = root_0; 8777 8778 } 8779 8780 retval.stop = input.LT(-1); 8781 8782 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8783 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8784 8785 } 8786 catch (RecognitionException re) { 8787 reportError(re); 8788 recover(input,re); 8789 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8790 } 8791 finally { 8792 // do for sure before leaving 8793 } 8794 return retval; 8795 } 8796 // $ANTLR end "restart_local_directive" 8797 8798 8799 public static class prologue_directive_return extends ParserRuleReturnScope { 8800 CommonTree tree; 8801 @Override 8802 public CommonTree getTree() { return tree; } 8803 }; 8804 8805 8806 // $ANTLR start "prologue_directive" 8807 // smaliParser.g:775:1: prologue_directive : PROLOGUE_DIRECTIVE -> ^( I_PROLOGUE[$start, \"I_PROLOGUE\"] ) ; 8808 public final smaliParser.prologue_directive_return prologue_directive() throws RecognitionException { 8809 smaliParser.prologue_directive_return retval = new smaliParser.prologue_directive_return(); 8810 retval.start = input.LT(1); 8811 8812 CommonTree root_0 = null; 8813 8814 Token PROLOGUE_DIRECTIVE231=null; 8815 8816 CommonTree PROLOGUE_DIRECTIVE231_tree=null; 8817 RewriteRuleTokenStream stream_PROLOGUE_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token PROLOGUE_DIRECTIVE"); 8818 8819 try { 8820 // smaliParser.g:776:3: ( PROLOGUE_DIRECTIVE -> ^( I_PROLOGUE[$start, \"I_PROLOGUE\"] ) ) 8821 // smaliParser.g:776:5: PROLOGUE_DIRECTIVE 8822 { 8823 PROLOGUE_DIRECTIVE231=(Token)match(input,PROLOGUE_DIRECTIVE,FOLLOW_PROLOGUE_DIRECTIVE_in_prologue_directive3606); 8824 stream_PROLOGUE_DIRECTIVE.add(PROLOGUE_DIRECTIVE231); 8825 8826 // AST REWRITE 8827 // elements: 8828 // token labels: 8829 // rule labels: retval 8830 // token list labels: 8831 // rule list labels: 8832 // wildcard labels: 8833 retval.tree = root_0; 8834 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 8835 8836 root_0 = (CommonTree)adaptor.nil(); 8837 // 777:5: -> ^( I_PROLOGUE[$start, \"I_PROLOGUE\"] ) 8838 { 8839 // smaliParser.g:777:8: ^( I_PROLOGUE[$start, \"I_PROLOGUE\"] ) 8840 { 8841 CommonTree root_1 = (CommonTree)adaptor.nil(); 8842 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_PROLOGUE, (retval.start), "I_PROLOGUE"), root_1); 8843 adaptor.addChild(root_0, root_1); 8844 } 8845 8846 } 8847 8848 8849 retval.tree = root_0; 8850 8851 } 8852 8853 retval.stop = input.LT(-1); 8854 8855 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8856 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8857 8858 } 8859 catch (RecognitionException re) { 8860 reportError(re); 8861 recover(input,re); 8862 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8863 } 8864 finally { 8865 // do for sure before leaving 8866 } 8867 return retval; 8868 } 8869 // $ANTLR end "prologue_directive" 8870 8871 8872 public static class epilogue_directive_return extends ParserRuleReturnScope { 8873 CommonTree tree; 8874 @Override 8875 public CommonTree getTree() { return tree; } 8876 }; 8877 8878 8879 // $ANTLR start "epilogue_directive" 8880 // smaliParser.g:779:1: epilogue_directive : EPILOGUE_DIRECTIVE -> ^( I_EPILOGUE[$start, \"I_EPILOGUE\"] ) ; 8881 public final smaliParser.epilogue_directive_return epilogue_directive() throws RecognitionException { 8882 smaliParser.epilogue_directive_return retval = new smaliParser.epilogue_directive_return(); 8883 retval.start = input.LT(1); 8884 8885 CommonTree root_0 = null; 8886 8887 Token EPILOGUE_DIRECTIVE232=null; 8888 8889 CommonTree EPILOGUE_DIRECTIVE232_tree=null; 8890 RewriteRuleTokenStream stream_EPILOGUE_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token EPILOGUE_DIRECTIVE"); 8891 8892 try { 8893 // smaliParser.g:780:3: ( EPILOGUE_DIRECTIVE -> ^( I_EPILOGUE[$start, \"I_EPILOGUE\"] ) ) 8894 // smaliParser.g:780:5: EPILOGUE_DIRECTIVE 8895 { 8896 EPILOGUE_DIRECTIVE232=(Token)match(input,EPILOGUE_DIRECTIVE,FOLLOW_EPILOGUE_DIRECTIVE_in_epilogue_directive3627); 8897 stream_EPILOGUE_DIRECTIVE.add(EPILOGUE_DIRECTIVE232); 8898 8899 // AST REWRITE 8900 // elements: 8901 // token labels: 8902 // rule labels: retval 8903 // token list labels: 8904 // rule list labels: 8905 // wildcard labels: 8906 retval.tree = root_0; 8907 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 8908 8909 root_0 = (CommonTree)adaptor.nil(); 8910 // 781:5: -> ^( I_EPILOGUE[$start, \"I_EPILOGUE\"] ) 8911 { 8912 // smaliParser.g:781:8: ^( I_EPILOGUE[$start, \"I_EPILOGUE\"] ) 8913 { 8914 CommonTree root_1 = (CommonTree)adaptor.nil(); 8915 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_EPILOGUE, (retval.start), "I_EPILOGUE"), root_1); 8916 adaptor.addChild(root_0, root_1); 8917 } 8918 8919 } 8920 8921 8922 retval.tree = root_0; 8923 8924 } 8925 8926 retval.stop = input.LT(-1); 8927 8928 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8929 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8930 8931 } 8932 catch (RecognitionException re) { 8933 reportError(re); 8934 recover(input,re); 8935 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8936 } 8937 finally { 8938 // do for sure before leaving 8939 } 8940 return retval; 8941 } 8942 // $ANTLR end "epilogue_directive" 8943 8944 8945 public static class source_directive_return extends ParserRuleReturnScope { 8946 CommonTree tree; 8947 @Override 8948 public CommonTree getTree() { return tree; } 8949 }; 8950 8951 8952 // $ANTLR start "source_directive" 8953 // smaliParser.g:783:1: source_directive : SOURCE_DIRECTIVE ( STRING_LITERAL )? -> ^( I_SOURCE[$start, \"I_SOURCE\"] ( STRING_LITERAL )? ) ; 8954 public final smaliParser.source_directive_return source_directive() throws RecognitionException { 8955 smaliParser.source_directive_return retval = new smaliParser.source_directive_return(); 8956 retval.start = input.LT(1); 8957 8958 CommonTree root_0 = null; 8959 8960 Token SOURCE_DIRECTIVE233=null; 8961 Token STRING_LITERAL234=null; 8962 8963 CommonTree SOURCE_DIRECTIVE233_tree=null; 8964 CommonTree STRING_LITERAL234_tree=null; 8965 RewriteRuleTokenStream stream_SOURCE_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token SOURCE_DIRECTIVE"); 8966 RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL"); 8967 8968 try { 8969 // smaliParser.g:784:3: ( SOURCE_DIRECTIVE ( STRING_LITERAL )? -> ^( I_SOURCE[$start, \"I_SOURCE\"] ( STRING_LITERAL )? ) ) 8970 // smaliParser.g:784:5: SOURCE_DIRECTIVE ( STRING_LITERAL )? 8971 { 8972 SOURCE_DIRECTIVE233=(Token)match(input,SOURCE_DIRECTIVE,FOLLOW_SOURCE_DIRECTIVE_in_source_directive3648); 8973 stream_SOURCE_DIRECTIVE.add(SOURCE_DIRECTIVE233); 8974 8975 // smaliParser.g:784:22: ( STRING_LITERAL )? 8976 int alt47=2; 8977 int LA47_0 = input.LA(1); 8978 if ( (LA47_0==STRING_LITERAL) ) { 8979 alt47=1; 8980 } 8981 switch (alt47) { 8982 case 1 : 8983 // smaliParser.g:784:22: STRING_LITERAL 8984 { 8985 STRING_LITERAL234=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_source_directive3650); 8986 stream_STRING_LITERAL.add(STRING_LITERAL234); 8987 8988 } 8989 break; 8990 8991 } 8992 8993 // AST REWRITE 8994 // elements: STRING_LITERAL 8995 // token labels: 8996 // rule labels: retval 8997 // token list labels: 8998 // rule list labels: 8999 // wildcard labels: 9000 retval.tree = root_0; 9001 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 9002 9003 root_0 = (CommonTree)adaptor.nil(); 9004 // 785:5: -> ^( I_SOURCE[$start, \"I_SOURCE\"] ( STRING_LITERAL )? ) 9005 { 9006 // smaliParser.g:785:8: ^( I_SOURCE[$start, \"I_SOURCE\"] ( STRING_LITERAL )? ) 9007 { 9008 CommonTree root_1 = (CommonTree)adaptor.nil(); 9009 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_SOURCE, (retval.start), "I_SOURCE"), root_1); 9010 // smaliParser.g:785:39: ( STRING_LITERAL )? 9011 if ( stream_STRING_LITERAL.hasNext() ) { 9012 adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode()); 9013 } 9014 stream_STRING_LITERAL.reset(); 9015 9016 adaptor.addChild(root_0, root_1); 9017 } 9018 9019 } 9020 9021 9022 retval.tree = root_0; 9023 9024 } 9025 9026 retval.stop = input.LT(-1); 9027 9028 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 9029 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 9030 9031 } 9032 catch (RecognitionException re) { 9033 reportError(re); 9034 recover(input,re); 9035 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 9036 } 9037 finally { 9038 // do for sure before leaving 9039 } 9040 return retval; 9041 } 9042 // $ANTLR end "source_directive" 9043 9044 9045 public static class instruction_format12x_return extends ParserRuleReturnScope { 9046 CommonTree tree; 9047 @Override 9048 public CommonTree getTree() { return tree; } 9049 }; 9050 9051 9052 // $ANTLR start "instruction_format12x" 9053 // smaliParser.g:787:1: instruction_format12x : ( INSTRUCTION_FORMAT12x | INSTRUCTION_FORMAT12x_OR_ID -> INSTRUCTION_FORMAT12x[$INSTRUCTION_FORMAT12x_OR_ID] ); 9054 public final smaliParser.instruction_format12x_return instruction_format12x() throws RecognitionException { 9055 smaliParser.instruction_format12x_return retval = new smaliParser.instruction_format12x_return(); 9056 retval.start = input.LT(1); 9057 9058 CommonTree root_0 = null; 9059 9060 Token INSTRUCTION_FORMAT12x235=null; 9061 Token INSTRUCTION_FORMAT12x_OR_ID236=null; 9062 9063 CommonTree INSTRUCTION_FORMAT12x235_tree=null; 9064 CommonTree INSTRUCTION_FORMAT12x_OR_ID236_tree=null; 9065 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT12x_OR_ID=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT12x_OR_ID"); 9066 9067 try { 9068 // smaliParser.g:788:3: ( INSTRUCTION_FORMAT12x | INSTRUCTION_FORMAT12x_OR_ID -> INSTRUCTION_FORMAT12x[$INSTRUCTION_FORMAT12x_OR_ID] ) 9069 int alt48=2; 9070 int LA48_0 = input.LA(1); 9071 if ( (LA48_0==INSTRUCTION_FORMAT12x) ) { 9072 alt48=1; 9073 } 9074 else if ( (LA48_0==INSTRUCTION_FORMAT12x_OR_ID) ) { 9075 alt48=2; 9076 } 9077 9078 else { 9079 NoViableAltException nvae = 9080 new NoViableAltException("", 48, 0, input); 9081 throw nvae; 9082 } 9083 9084 switch (alt48) { 9085 case 1 : 9086 // smaliParser.g:788:5: INSTRUCTION_FORMAT12x 9087 { 9088 root_0 = (CommonTree)adaptor.nil(); 9089 9090 9091 INSTRUCTION_FORMAT12x235=(Token)match(input,INSTRUCTION_FORMAT12x,FOLLOW_INSTRUCTION_FORMAT12x_in_instruction_format12x3675); 9092 INSTRUCTION_FORMAT12x235_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT12x235); 9093 adaptor.addChild(root_0, INSTRUCTION_FORMAT12x235_tree); 9094 9095 } 9096 break; 9097 case 2 : 9098 // smaliParser.g:789:5: INSTRUCTION_FORMAT12x_OR_ID 9099 { 9100 INSTRUCTION_FORMAT12x_OR_ID236=(Token)match(input,INSTRUCTION_FORMAT12x_OR_ID,FOLLOW_INSTRUCTION_FORMAT12x_OR_ID_in_instruction_format12x3681); 9101 stream_INSTRUCTION_FORMAT12x_OR_ID.add(INSTRUCTION_FORMAT12x_OR_ID236); 9102 9103 // AST REWRITE 9104 // elements: 9105 // token labels: 9106 // rule labels: retval 9107 // token list labels: 9108 // rule list labels: 9109 // wildcard labels: 9110 retval.tree = root_0; 9111 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 9112 9113 root_0 = (CommonTree)adaptor.nil(); 9114 // 789:33: -> INSTRUCTION_FORMAT12x[$INSTRUCTION_FORMAT12x_OR_ID] 9115 { 9116 adaptor.addChild(root_0, (CommonTree)adaptor.create(INSTRUCTION_FORMAT12x, INSTRUCTION_FORMAT12x_OR_ID236)); 9117 } 9118 9119 9120 retval.tree = root_0; 9121 9122 } 9123 break; 9124 9125 } 9126 retval.stop = input.LT(-1); 9127 9128 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 9129 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 9130 9131 } 9132 catch (RecognitionException re) { 9133 reportError(re); 9134 recover(input,re); 9135 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 9136 } 9137 finally { 9138 // do for sure before leaving 9139 } 9140 return retval; 9141 } 9142 // $ANTLR end "instruction_format12x" 9143 9144 9145 public static class instruction_format22s_return extends ParserRuleReturnScope { 9146 CommonTree tree; 9147 @Override 9148 public CommonTree getTree() { return tree; } 9149 }; 9150 9151 9152 // $ANTLR start "instruction_format22s" 9153 // smaliParser.g:791:1: instruction_format22s : ( INSTRUCTION_FORMAT22s | INSTRUCTION_FORMAT22s_OR_ID -> INSTRUCTION_FORMAT22s[$INSTRUCTION_FORMAT22s_OR_ID] ); 9154 public final smaliParser.instruction_format22s_return instruction_format22s() throws RecognitionException { 9155 smaliParser.instruction_format22s_return retval = new smaliParser.instruction_format22s_return(); 9156 retval.start = input.LT(1); 9157 9158 CommonTree root_0 = null; 9159 9160 Token INSTRUCTION_FORMAT22s237=null; 9161 Token INSTRUCTION_FORMAT22s_OR_ID238=null; 9162 9163 CommonTree INSTRUCTION_FORMAT22s237_tree=null; 9164 CommonTree INSTRUCTION_FORMAT22s_OR_ID238_tree=null; 9165 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22s_OR_ID=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22s_OR_ID"); 9166 9167 try { 9168 // smaliParser.g:792:3: ( INSTRUCTION_FORMAT22s | INSTRUCTION_FORMAT22s_OR_ID -> INSTRUCTION_FORMAT22s[$INSTRUCTION_FORMAT22s_OR_ID] ) 9169 int alt49=2; 9170 int LA49_0 = input.LA(1); 9171 if ( (LA49_0==INSTRUCTION_FORMAT22s) ) { 9172 alt49=1; 9173 } 9174 else if ( (LA49_0==INSTRUCTION_FORMAT22s_OR_ID) ) { 9175 alt49=2; 9176 } 9177 9178 else { 9179 NoViableAltException nvae = 9180 new NoViableAltException("", 49, 0, input); 9181 throw nvae; 9182 } 9183 9184 switch (alt49) { 9185 case 1 : 9186 // smaliParser.g:792:5: INSTRUCTION_FORMAT22s 9187 { 9188 root_0 = (CommonTree)adaptor.nil(); 9189 9190 9191 INSTRUCTION_FORMAT22s237=(Token)match(input,INSTRUCTION_FORMAT22s,FOLLOW_INSTRUCTION_FORMAT22s_in_instruction_format22s3696); 9192 INSTRUCTION_FORMAT22s237_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT22s237); 9193 adaptor.addChild(root_0, INSTRUCTION_FORMAT22s237_tree); 9194 9195 } 9196 break; 9197 case 2 : 9198 // smaliParser.g:793:5: INSTRUCTION_FORMAT22s_OR_ID 9199 { 9200 INSTRUCTION_FORMAT22s_OR_ID238=(Token)match(input,INSTRUCTION_FORMAT22s_OR_ID,FOLLOW_INSTRUCTION_FORMAT22s_OR_ID_in_instruction_format22s3702); 9201 stream_INSTRUCTION_FORMAT22s_OR_ID.add(INSTRUCTION_FORMAT22s_OR_ID238); 9202 9203 // AST REWRITE 9204 // elements: 9205 // token labels: 9206 // rule labels: retval 9207 // token list labels: 9208 // rule list labels: 9209 // wildcard labels: 9210 retval.tree = root_0; 9211 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 9212 9213 root_0 = (CommonTree)adaptor.nil(); 9214 // 793:33: -> INSTRUCTION_FORMAT22s[$INSTRUCTION_FORMAT22s_OR_ID] 9215 { 9216 adaptor.addChild(root_0, (CommonTree)adaptor.create(INSTRUCTION_FORMAT22s, INSTRUCTION_FORMAT22s_OR_ID238)); 9217 } 9218 9219 9220 retval.tree = root_0; 9221 9222 } 9223 break; 9224 9225 } 9226 retval.stop = input.LT(-1); 9227 9228 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 9229 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 9230 9231 } 9232 catch (RecognitionException re) { 9233 reportError(re); 9234 recover(input,re); 9235 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 9236 } 9237 finally { 9238 // do for sure before leaving 9239 } 9240 return retval; 9241 } 9242 // $ANTLR end "instruction_format22s" 9243 9244 9245 public static class instruction_format31i_return extends ParserRuleReturnScope { 9246 CommonTree tree; 9247 @Override 9248 public CommonTree getTree() { return tree; } 9249 }; 9250 9251 9252 // $ANTLR start "instruction_format31i" 9253 // smaliParser.g:795:1: instruction_format31i : ( INSTRUCTION_FORMAT31i | INSTRUCTION_FORMAT31i_OR_ID -> INSTRUCTION_FORMAT31i[$INSTRUCTION_FORMAT31i_OR_ID] ); 9254 public final smaliParser.instruction_format31i_return instruction_format31i() throws RecognitionException { 9255 smaliParser.instruction_format31i_return retval = new smaliParser.instruction_format31i_return(); 9256 retval.start = input.LT(1); 9257 9258 CommonTree root_0 = null; 9259 9260 Token INSTRUCTION_FORMAT31i239=null; 9261 Token INSTRUCTION_FORMAT31i_OR_ID240=null; 9262 9263 CommonTree INSTRUCTION_FORMAT31i239_tree=null; 9264 CommonTree INSTRUCTION_FORMAT31i_OR_ID240_tree=null; 9265 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT31i_OR_ID=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT31i_OR_ID"); 9266 9267 try { 9268 // smaliParser.g:796:3: ( INSTRUCTION_FORMAT31i | INSTRUCTION_FORMAT31i_OR_ID -> INSTRUCTION_FORMAT31i[$INSTRUCTION_FORMAT31i_OR_ID] ) 9269 int alt50=2; 9270 int LA50_0 = input.LA(1); 9271 if ( (LA50_0==INSTRUCTION_FORMAT31i) ) { 9272 alt50=1; 9273 } 9274 else if ( (LA50_0==INSTRUCTION_FORMAT31i_OR_ID) ) { 9275 alt50=2; 9276 } 9277 9278 else { 9279 NoViableAltException nvae = 9280 new NoViableAltException("", 50, 0, input); 9281 throw nvae; 9282 } 9283 9284 switch (alt50) { 9285 case 1 : 9286 // smaliParser.g:796:5: INSTRUCTION_FORMAT31i 9287 { 9288 root_0 = (CommonTree)adaptor.nil(); 9289 9290 9291 INSTRUCTION_FORMAT31i239=(Token)match(input,INSTRUCTION_FORMAT31i,FOLLOW_INSTRUCTION_FORMAT31i_in_instruction_format31i3717); 9292 INSTRUCTION_FORMAT31i239_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT31i239); 9293 adaptor.addChild(root_0, INSTRUCTION_FORMAT31i239_tree); 9294 9295 } 9296 break; 9297 case 2 : 9298 // smaliParser.g:797:5: INSTRUCTION_FORMAT31i_OR_ID 9299 { 9300 INSTRUCTION_FORMAT31i_OR_ID240=(Token)match(input,INSTRUCTION_FORMAT31i_OR_ID,FOLLOW_INSTRUCTION_FORMAT31i_OR_ID_in_instruction_format31i3723); 9301 stream_INSTRUCTION_FORMAT31i_OR_ID.add(INSTRUCTION_FORMAT31i_OR_ID240); 9302 9303 // AST REWRITE 9304 // elements: 9305 // token labels: 9306 // rule labels: retval 9307 // token list labels: 9308 // rule list labels: 9309 // wildcard labels: 9310 retval.tree = root_0; 9311 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 9312 9313 root_0 = (CommonTree)adaptor.nil(); 9314 // 797:33: -> INSTRUCTION_FORMAT31i[$INSTRUCTION_FORMAT31i_OR_ID] 9315 { 9316 adaptor.addChild(root_0, (CommonTree)adaptor.create(INSTRUCTION_FORMAT31i, INSTRUCTION_FORMAT31i_OR_ID240)); 9317 } 9318 9319 9320 retval.tree = root_0; 9321 9322 } 9323 break; 9324 9325 } 9326 retval.stop = input.LT(-1); 9327 9328 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 9329 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 9330 9331 } 9332 catch (RecognitionException re) { 9333 reportError(re); 9334 recover(input,re); 9335 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 9336 } 9337 finally { 9338 // do for sure before leaving 9339 } 9340 return retval; 9341 } 9342 // $ANTLR end "instruction_format31i" 9343 9344 9345 public static class instruction_return extends ParserRuleReturnScope { 9346 CommonTree tree; 9347 @Override 9348 public CommonTree getTree() { return tree; } 9349 }; 9350 9351 9352 // $ANTLR start "instruction" 9353 // smaliParser.g:801:1: instruction : ( insn_format10t | insn_format10x | insn_format10x_odex | insn_format11n | insn_format11x | insn_format12x | insn_format20bc | insn_format20t | insn_format21c_field | insn_format21c_field_odex | insn_format21c_string | insn_format21c_type | insn_format21ih | insn_format21lh | insn_format21s | insn_format21t | insn_format22b | insn_format22c_field | insn_format22c_field_odex | insn_format22c_type | insn_format22cs_field | 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_format35c_method_odex | insn_format35mi_method | insn_format35ms_method | insn_format3rc_method | insn_format3rc_method_odex | insn_format3rc_type | insn_format3rmi_method | insn_format3rms_method | insn_format45cc_method | insn_format4rcc_method | insn_format51l | insn_array_data_directive | insn_packed_switch_directive | insn_sparse_switch_directive ); 9354 public final smaliParser.instruction_return instruction() throws RecognitionException { 9355 smaliParser.instruction_return retval = new smaliParser.instruction_return(); 9356 retval.start = input.LT(1); 9357 9358 CommonTree root_0 = null; 9359 9360 ParserRuleReturnScope insn_format10t241 =null; 9361 ParserRuleReturnScope insn_format10x242 =null; 9362 ParserRuleReturnScope insn_format10x_odex243 =null; 9363 ParserRuleReturnScope insn_format11n244 =null; 9364 ParserRuleReturnScope insn_format11x245 =null; 9365 ParserRuleReturnScope insn_format12x246 =null; 9366 ParserRuleReturnScope insn_format20bc247 =null; 9367 ParserRuleReturnScope insn_format20t248 =null; 9368 ParserRuleReturnScope insn_format21c_field249 =null; 9369 ParserRuleReturnScope insn_format21c_field_odex250 =null; 9370 ParserRuleReturnScope insn_format21c_string251 =null; 9371 ParserRuleReturnScope insn_format21c_type252 =null; 9372 ParserRuleReturnScope insn_format21ih253 =null; 9373 ParserRuleReturnScope insn_format21lh254 =null; 9374 ParserRuleReturnScope insn_format21s255 =null; 9375 ParserRuleReturnScope insn_format21t256 =null; 9376 ParserRuleReturnScope insn_format22b257 =null; 9377 ParserRuleReturnScope insn_format22c_field258 =null; 9378 ParserRuleReturnScope insn_format22c_field_odex259 =null; 9379 ParserRuleReturnScope insn_format22c_type260 =null; 9380 ParserRuleReturnScope insn_format22cs_field261 =null; 9381 ParserRuleReturnScope insn_format22s262 =null; 9382 ParserRuleReturnScope insn_format22t263 =null; 9383 ParserRuleReturnScope insn_format22x264 =null; 9384 ParserRuleReturnScope insn_format23x265 =null; 9385 ParserRuleReturnScope insn_format30t266 =null; 9386 ParserRuleReturnScope insn_format31c267 =null; 9387 ParserRuleReturnScope insn_format31i268 =null; 9388 ParserRuleReturnScope insn_format31t269 =null; 9389 ParserRuleReturnScope insn_format32x270 =null; 9390 ParserRuleReturnScope insn_format35c_method271 =null; 9391 ParserRuleReturnScope insn_format35c_type272 =null; 9392 ParserRuleReturnScope insn_format35c_method_odex273 =null; 9393 ParserRuleReturnScope insn_format35mi_method274 =null; 9394 ParserRuleReturnScope insn_format35ms_method275 =null; 9395 ParserRuleReturnScope insn_format3rc_method276 =null; 9396 ParserRuleReturnScope insn_format3rc_method_odex277 =null; 9397 ParserRuleReturnScope insn_format3rc_type278 =null; 9398 ParserRuleReturnScope insn_format3rmi_method279 =null; 9399 ParserRuleReturnScope insn_format3rms_method280 =null; 9400 ParserRuleReturnScope insn_format45cc_method281 =null; 9401 ParserRuleReturnScope insn_format4rcc_method282 =null; 9402 ParserRuleReturnScope insn_format51l283 =null; 9403 ParserRuleReturnScope insn_array_data_directive284 =null; 9404 ParserRuleReturnScope insn_packed_switch_directive285 =null; 9405 ParserRuleReturnScope insn_sparse_switch_directive286 =null; 9406 9407 9408 try { 9409 // smaliParser.g:802:3: ( insn_format10t | insn_format10x | insn_format10x_odex | insn_format11n | insn_format11x | insn_format12x | insn_format20bc | insn_format20t | insn_format21c_field | insn_format21c_field_odex | insn_format21c_string | insn_format21c_type | insn_format21ih | insn_format21lh | insn_format21s | insn_format21t | insn_format22b | insn_format22c_field | insn_format22c_field_odex | insn_format22c_type | insn_format22cs_field | 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_format35c_method_odex | insn_format35mi_method | insn_format35ms_method | insn_format3rc_method | insn_format3rc_method_odex | insn_format3rc_type | insn_format3rmi_method | insn_format3rms_method | insn_format45cc_method | insn_format4rcc_method | insn_format51l | insn_array_data_directive | insn_packed_switch_directive | insn_sparse_switch_directive ) 9410 int alt51=46; 9411 switch ( input.LA(1) ) { 9412 case INSTRUCTION_FORMAT10t: 9413 { 9414 alt51=1; 9415 } 9416 break; 9417 case INSTRUCTION_FORMAT10x: 9418 { 9419 alt51=2; 9420 } 9421 break; 9422 case INSTRUCTION_FORMAT10x_ODEX: 9423 { 9424 alt51=3; 9425 } 9426 break; 9427 case INSTRUCTION_FORMAT11n: 9428 { 9429 alt51=4; 9430 } 9431 break; 9432 case INSTRUCTION_FORMAT11x: 9433 { 9434 alt51=5; 9435 } 9436 break; 9437 case INSTRUCTION_FORMAT12x: 9438 case INSTRUCTION_FORMAT12x_OR_ID: 9439 { 9440 alt51=6; 9441 } 9442 break; 9443 case INSTRUCTION_FORMAT20bc: 9444 { 9445 alt51=7; 9446 } 9447 break; 9448 case INSTRUCTION_FORMAT20t: 9449 { 9450 alt51=8; 9451 } 9452 break; 9453 case INSTRUCTION_FORMAT21c_FIELD: 9454 { 9455 alt51=9; 9456 } 9457 break; 9458 case INSTRUCTION_FORMAT21c_FIELD_ODEX: 9459 { 9460 alt51=10; 9461 } 9462 break; 9463 case INSTRUCTION_FORMAT21c_STRING: 9464 { 9465 alt51=11; 9466 } 9467 break; 9468 case INSTRUCTION_FORMAT21c_TYPE: 9469 { 9470 alt51=12; 9471 } 9472 break; 9473 case INSTRUCTION_FORMAT21ih: 9474 { 9475 alt51=13; 9476 } 9477 break; 9478 case INSTRUCTION_FORMAT21lh: 9479 { 9480 alt51=14; 9481 } 9482 break; 9483 case INSTRUCTION_FORMAT21s: 9484 { 9485 alt51=15; 9486 } 9487 break; 9488 case INSTRUCTION_FORMAT21t: 9489 { 9490 alt51=16; 9491 } 9492 break; 9493 case INSTRUCTION_FORMAT22b: 9494 { 9495 alt51=17; 9496 } 9497 break; 9498 case INSTRUCTION_FORMAT22c_FIELD: 9499 { 9500 alt51=18; 9501 } 9502 break; 9503 case INSTRUCTION_FORMAT22c_FIELD_ODEX: 9504 { 9505 alt51=19; 9506 } 9507 break; 9508 case INSTRUCTION_FORMAT22c_TYPE: 9509 { 9510 alt51=20; 9511 } 9512 break; 9513 case INSTRUCTION_FORMAT22cs_FIELD: 9514 { 9515 alt51=21; 9516 } 9517 break; 9518 case INSTRUCTION_FORMAT22s: 9519 case INSTRUCTION_FORMAT22s_OR_ID: 9520 { 9521 alt51=22; 9522 } 9523 break; 9524 case INSTRUCTION_FORMAT22t: 9525 { 9526 alt51=23; 9527 } 9528 break; 9529 case INSTRUCTION_FORMAT22x: 9530 { 9531 alt51=24; 9532 } 9533 break; 9534 case INSTRUCTION_FORMAT23x: 9535 { 9536 alt51=25; 9537 } 9538 break; 9539 case INSTRUCTION_FORMAT30t: 9540 { 9541 alt51=26; 9542 } 9543 break; 9544 case INSTRUCTION_FORMAT31c: 9545 { 9546 alt51=27; 9547 } 9548 break; 9549 case INSTRUCTION_FORMAT31i: 9550 case INSTRUCTION_FORMAT31i_OR_ID: 9551 { 9552 alt51=28; 9553 } 9554 break; 9555 case INSTRUCTION_FORMAT31t: 9556 { 9557 alt51=29; 9558 } 9559 break; 9560 case INSTRUCTION_FORMAT32x: 9561 { 9562 alt51=30; 9563 } 9564 break; 9565 case INSTRUCTION_FORMAT35c_METHOD: 9566 { 9567 alt51=31; 9568 } 9569 break; 9570 case INSTRUCTION_FORMAT35c_TYPE: 9571 { 9572 alt51=32; 9573 } 9574 break; 9575 case INSTRUCTION_FORMAT35c_METHOD_ODEX: 9576 { 9577 alt51=33; 9578 } 9579 break; 9580 case INSTRUCTION_FORMAT35mi_METHOD: 9581 { 9582 alt51=34; 9583 } 9584 break; 9585 case INSTRUCTION_FORMAT35ms_METHOD: 9586 { 9587 alt51=35; 9588 } 9589 break; 9590 case INSTRUCTION_FORMAT3rc_METHOD: 9591 { 9592 alt51=36; 9593 } 9594 break; 9595 case INSTRUCTION_FORMAT3rc_METHOD_ODEX: 9596 { 9597 alt51=37; 9598 } 9599 break; 9600 case INSTRUCTION_FORMAT3rc_TYPE: 9601 { 9602 alt51=38; 9603 } 9604 break; 9605 case INSTRUCTION_FORMAT3rmi_METHOD: 9606 { 9607 alt51=39; 9608 } 9609 break; 9610 case INSTRUCTION_FORMAT3rms_METHOD: 9611 { 9612 alt51=40; 9613 } 9614 break; 9615 case INSTRUCTION_FORMAT45cc_METHOD: 9616 { 9617 alt51=41; 9618 } 9619 break; 9620 case INSTRUCTION_FORMAT4rcc_METHOD: 9621 { 9622 alt51=42; 9623 } 9624 break; 9625 case INSTRUCTION_FORMAT51l: 9626 { 9627 alt51=43; 9628 } 9629 break; 9630 case ARRAY_DATA_DIRECTIVE: 9631 { 9632 alt51=44; 9633 } 9634 break; 9635 case PACKED_SWITCH_DIRECTIVE: 9636 { 9637 alt51=45; 9638 } 9639 break; 9640 case SPARSE_SWITCH_DIRECTIVE: 9641 { 9642 alt51=46; 9643 } 9644 break; 9645 default: 9646 NoViableAltException nvae = 9647 new NoViableAltException("", 51, 0, input); 9648 throw nvae; 9649 } 9650 switch (alt51) { 9651 case 1 : 9652 // smaliParser.g:802:5: insn_format10t 9653 { 9654 root_0 = (CommonTree)adaptor.nil(); 9655 9656 9657 pushFollow(FOLLOW_insn_format10t_in_instruction3740); 9658 insn_format10t241=insn_format10t(); 9659 state._fsp--; 9660 9661 adaptor.addChild(root_0, insn_format10t241.getTree()); 9662 9663 } 9664 break; 9665 case 2 : 9666 // smaliParser.g:803:5: insn_format10x 9667 { 9668 root_0 = (CommonTree)adaptor.nil(); 9669 9670 9671 pushFollow(FOLLOW_insn_format10x_in_instruction3746); 9672 insn_format10x242=insn_format10x(); 9673 state._fsp--; 9674 9675 adaptor.addChild(root_0, insn_format10x242.getTree()); 9676 9677 } 9678 break; 9679 case 3 : 9680 // smaliParser.g:804:5: insn_format10x_odex 9681 { 9682 root_0 = (CommonTree)adaptor.nil(); 9683 9684 9685 pushFollow(FOLLOW_insn_format10x_odex_in_instruction3752); 9686 insn_format10x_odex243=insn_format10x_odex(); 9687 state._fsp--; 9688 9689 adaptor.addChild(root_0, insn_format10x_odex243.getTree()); 9690 9691 } 9692 break; 9693 case 4 : 9694 // smaliParser.g:805:5: insn_format11n 9695 { 9696 root_0 = (CommonTree)adaptor.nil(); 9697 9698 9699 pushFollow(FOLLOW_insn_format11n_in_instruction3758); 9700 insn_format11n244=insn_format11n(); 9701 state._fsp--; 9702 9703 adaptor.addChild(root_0, insn_format11n244.getTree()); 9704 9705 } 9706 break; 9707 case 5 : 9708 // smaliParser.g:806:5: insn_format11x 9709 { 9710 root_0 = (CommonTree)adaptor.nil(); 9711 9712 9713 pushFollow(FOLLOW_insn_format11x_in_instruction3764); 9714 insn_format11x245=insn_format11x(); 9715 state._fsp--; 9716 9717 adaptor.addChild(root_0, insn_format11x245.getTree()); 9718 9719 } 9720 break; 9721 case 6 : 9722 // smaliParser.g:807:5: insn_format12x 9723 { 9724 root_0 = (CommonTree)adaptor.nil(); 9725 9726 9727 pushFollow(FOLLOW_insn_format12x_in_instruction3770); 9728 insn_format12x246=insn_format12x(); 9729 state._fsp--; 9730 9731 adaptor.addChild(root_0, insn_format12x246.getTree()); 9732 9733 } 9734 break; 9735 case 7 : 9736 // smaliParser.g:808:5: insn_format20bc 9737 { 9738 root_0 = (CommonTree)adaptor.nil(); 9739 9740 9741 pushFollow(FOLLOW_insn_format20bc_in_instruction3776); 9742 insn_format20bc247=insn_format20bc(); 9743 state._fsp--; 9744 9745 adaptor.addChild(root_0, insn_format20bc247.getTree()); 9746 9747 } 9748 break; 9749 case 8 : 9750 // smaliParser.g:809:5: insn_format20t 9751 { 9752 root_0 = (CommonTree)adaptor.nil(); 9753 9754 9755 pushFollow(FOLLOW_insn_format20t_in_instruction3782); 9756 insn_format20t248=insn_format20t(); 9757 state._fsp--; 9758 9759 adaptor.addChild(root_0, insn_format20t248.getTree()); 9760 9761 } 9762 break; 9763 case 9 : 9764 // smaliParser.g:810:5: insn_format21c_field 9765 { 9766 root_0 = (CommonTree)adaptor.nil(); 9767 9768 9769 pushFollow(FOLLOW_insn_format21c_field_in_instruction3788); 9770 insn_format21c_field249=insn_format21c_field(); 9771 state._fsp--; 9772 9773 adaptor.addChild(root_0, insn_format21c_field249.getTree()); 9774 9775 } 9776 break; 9777 case 10 : 9778 // smaliParser.g:811:5: insn_format21c_field_odex 9779 { 9780 root_0 = (CommonTree)adaptor.nil(); 9781 9782 9783 pushFollow(FOLLOW_insn_format21c_field_odex_in_instruction3794); 9784 insn_format21c_field_odex250=insn_format21c_field_odex(); 9785 state._fsp--; 9786 9787 adaptor.addChild(root_0, insn_format21c_field_odex250.getTree()); 9788 9789 } 9790 break; 9791 case 11 : 9792 // smaliParser.g:812:5: insn_format21c_string 9793 { 9794 root_0 = (CommonTree)adaptor.nil(); 9795 9796 9797 pushFollow(FOLLOW_insn_format21c_string_in_instruction3800); 9798 insn_format21c_string251=insn_format21c_string(); 9799 state._fsp--; 9800 9801 adaptor.addChild(root_0, insn_format21c_string251.getTree()); 9802 9803 } 9804 break; 9805 case 12 : 9806 // smaliParser.g:813:5: insn_format21c_type 9807 { 9808 root_0 = (CommonTree)adaptor.nil(); 9809 9810 9811 pushFollow(FOLLOW_insn_format21c_type_in_instruction3806); 9812 insn_format21c_type252=insn_format21c_type(); 9813 state._fsp--; 9814 9815 adaptor.addChild(root_0, insn_format21c_type252.getTree()); 9816 9817 } 9818 break; 9819 case 13 : 9820 // smaliParser.g:814:5: insn_format21ih 9821 { 9822 root_0 = (CommonTree)adaptor.nil(); 9823 9824 9825 pushFollow(FOLLOW_insn_format21ih_in_instruction3812); 9826 insn_format21ih253=insn_format21ih(); 9827 state._fsp--; 9828 9829 adaptor.addChild(root_0, insn_format21ih253.getTree()); 9830 9831 } 9832 break; 9833 case 14 : 9834 // smaliParser.g:815:5: insn_format21lh 9835 { 9836 root_0 = (CommonTree)adaptor.nil(); 9837 9838 9839 pushFollow(FOLLOW_insn_format21lh_in_instruction3818); 9840 insn_format21lh254=insn_format21lh(); 9841 state._fsp--; 9842 9843 adaptor.addChild(root_0, insn_format21lh254.getTree()); 9844 9845 } 9846 break; 9847 case 15 : 9848 // smaliParser.g:816:5: insn_format21s 9849 { 9850 root_0 = (CommonTree)adaptor.nil(); 9851 9852 9853 pushFollow(FOLLOW_insn_format21s_in_instruction3824); 9854 insn_format21s255=insn_format21s(); 9855 state._fsp--; 9856 9857 adaptor.addChild(root_0, insn_format21s255.getTree()); 9858 9859 } 9860 break; 9861 case 16 : 9862 // smaliParser.g:817:5: insn_format21t 9863 { 9864 root_0 = (CommonTree)adaptor.nil(); 9865 9866 9867 pushFollow(FOLLOW_insn_format21t_in_instruction3830); 9868 insn_format21t256=insn_format21t(); 9869 state._fsp--; 9870 9871 adaptor.addChild(root_0, insn_format21t256.getTree()); 9872 9873 } 9874 break; 9875 case 17 : 9876 // smaliParser.g:818:5: insn_format22b 9877 { 9878 root_0 = (CommonTree)adaptor.nil(); 9879 9880 9881 pushFollow(FOLLOW_insn_format22b_in_instruction3836); 9882 insn_format22b257=insn_format22b(); 9883 state._fsp--; 9884 9885 adaptor.addChild(root_0, insn_format22b257.getTree()); 9886 9887 } 9888 break; 9889 case 18 : 9890 // smaliParser.g:819:5: insn_format22c_field 9891 { 9892 root_0 = (CommonTree)adaptor.nil(); 9893 9894 9895 pushFollow(FOLLOW_insn_format22c_field_in_instruction3842); 9896 insn_format22c_field258=insn_format22c_field(); 9897 state._fsp--; 9898 9899 adaptor.addChild(root_0, insn_format22c_field258.getTree()); 9900 9901 } 9902 break; 9903 case 19 : 9904 // smaliParser.g:820:5: insn_format22c_field_odex 9905 { 9906 root_0 = (CommonTree)adaptor.nil(); 9907 9908 9909 pushFollow(FOLLOW_insn_format22c_field_odex_in_instruction3848); 9910 insn_format22c_field_odex259=insn_format22c_field_odex(); 9911 state._fsp--; 9912 9913 adaptor.addChild(root_0, insn_format22c_field_odex259.getTree()); 9914 9915 } 9916 break; 9917 case 20 : 9918 // smaliParser.g:821:5: insn_format22c_type 9919 { 9920 root_0 = (CommonTree)adaptor.nil(); 9921 9922 9923 pushFollow(FOLLOW_insn_format22c_type_in_instruction3854); 9924 insn_format22c_type260=insn_format22c_type(); 9925 state._fsp--; 9926 9927 adaptor.addChild(root_0, insn_format22c_type260.getTree()); 9928 9929 } 9930 break; 9931 case 21 : 9932 // smaliParser.g:822:5: insn_format22cs_field 9933 { 9934 root_0 = (CommonTree)adaptor.nil(); 9935 9936 9937 pushFollow(FOLLOW_insn_format22cs_field_in_instruction3860); 9938 insn_format22cs_field261=insn_format22cs_field(); 9939 state._fsp--; 9940 9941 adaptor.addChild(root_0, insn_format22cs_field261.getTree()); 9942 9943 } 9944 break; 9945 case 22 : 9946 // smaliParser.g:823:5: insn_format22s 9947 { 9948 root_0 = (CommonTree)adaptor.nil(); 9949 9950 9951 pushFollow(FOLLOW_insn_format22s_in_instruction3866); 9952 insn_format22s262=insn_format22s(); 9953 state._fsp--; 9954 9955 adaptor.addChild(root_0, insn_format22s262.getTree()); 9956 9957 } 9958 break; 9959 case 23 : 9960 // smaliParser.g:824:5: insn_format22t 9961 { 9962 root_0 = (CommonTree)adaptor.nil(); 9963 9964 9965 pushFollow(FOLLOW_insn_format22t_in_instruction3872); 9966 insn_format22t263=insn_format22t(); 9967 state._fsp--; 9968 9969 adaptor.addChild(root_0, insn_format22t263.getTree()); 9970 9971 } 9972 break; 9973 case 24 : 9974 // smaliParser.g:825:5: insn_format22x 9975 { 9976 root_0 = (CommonTree)adaptor.nil(); 9977 9978 9979 pushFollow(FOLLOW_insn_format22x_in_instruction3878); 9980 insn_format22x264=insn_format22x(); 9981 state._fsp--; 9982 9983 adaptor.addChild(root_0, insn_format22x264.getTree()); 9984 9985 } 9986 break; 9987 case 25 : 9988 // smaliParser.g:826:5: insn_format23x 9989 { 9990 root_0 = (CommonTree)adaptor.nil(); 9991 9992 9993 pushFollow(FOLLOW_insn_format23x_in_instruction3884); 9994 insn_format23x265=insn_format23x(); 9995 state._fsp--; 9996 9997 adaptor.addChild(root_0, insn_format23x265.getTree()); 9998 9999 } 10000 break; 10001 case 26 : 10002 // smaliParser.g:827:5: insn_format30t 10003 { 10004 root_0 = (CommonTree)adaptor.nil(); 10005 10006 10007 pushFollow(FOLLOW_insn_format30t_in_instruction3890); 10008 insn_format30t266=insn_format30t(); 10009 state._fsp--; 10010 10011 adaptor.addChild(root_0, insn_format30t266.getTree()); 10012 10013 } 10014 break; 10015 case 27 : 10016 // smaliParser.g:828:5: insn_format31c 10017 { 10018 root_0 = (CommonTree)adaptor.nil(); 10019 10020 10021 pushFollow(FOLLOW_insn_format31c_in_instruction3896); 10022 insn_format31c267=insn_format31c(); 10023 state._fsp--; 10024 10025 adaptor.addChild(root_0, insn_format31c267.getTree()); 10026 10027 } 10028 break; 10029 case 28 : 10030 // smaliParser.g:829:5: insn_format31i 10031 { 10032 root_0 = (CommonTree)adaptor.nil(); 10033 10034 10035 pushFollow(FOLLOW_insn_format31i_in_instruction3902); 10036 insn_format31i268=insn_format31i(); 10037 state._fsp--; 10038 10039 adaptor.addChild(root_0, insn_format31i268.getTree()); 10040 10041 } 10042 break; 10043 case 29 : 10044 // smaliParser.g:830:5: insn_format31t 10045 { 10046 root_0 = (CommonTree)adaptor.nil(); 10047 10048 10049 pushFollow(FOLLOW_insn_format31t_in_instruction3908); 10050 insn_format31t269=insn_format31t(); 10051 state._fsp--; 10052 10053 adaptor.addChild(root_0, insn_format31t269.getTree()); 10054 10055 } 10056 break; 10057 case 30 : 10058 // smaliParser.g:831:5: insn_format32x 10059 { 10060 root_0 = (CommonTree)adaptor.nil(); 10061 10062 10063 pushFollow(FOLLOW_insn_format32x_in_instruction3914); 10064 insn_format32x270=insn_format32x(); 10065 state._fsp--; 10066 10067 adaptor.addChild(root_0, insn_format32x270.getTree()); 10068 10069 } 10070 break; 10071 case 31 : 10072 // smaliParser.g:832:5: insn_format35c_method 10073 { 10074 root_0 = (CommonTree)adaptor.nil(); 10075 10076 10077 pushFollow(FOLLOW_insn_format35c_method_in_instruction3920); 10078 insn_format35c_method271=insn_format35c_method(); 10079 state._fsp--; 10080 10081 adaptor.addChild(root_0, insn_format35c_method271.getTree()); 10082 10083 } 10084 break; 10085 case 32 : 10086 // smaliParser.g:833:5: insn_format35c_type 10087 { 10088 root_0 = (CommonTree)adaptor.nil(); 10089 10090 10091 pushFollow(FOLLOW_insn_format35c_type_in_instruction3926); 10092 insn_format35c_type272=insn_format35c_type(); 10093 state._fsp--; 10094 10095 adaptor.addChild(root_0, insn_format35c_type272.getTree()); 10096 10097 } 10098 break; 10099 case 33 : 10100 // smaliParser.g:834:5: insn_format35c_method_odex 10101 { 10102 root_0 = (CommonTree)adaptor.nil(); 10103 10104 10105 pushFollow(FOLLOW_insn_format35c_method_odex_in_instruction3932); 10106 insn_format35c_method_odex273=insn_format35c_method_odex(); 10107 state._fsp--; 10108 10109 adaptor.addChild(root_0, insn_format35c_method_odex273.getTree()); 10110 10111 } 10112 break; 10113 case 34 : 10114 // smaliParser.g:835:5: insn_format35mi_method 10115 { 10116 root_0 = (CommonTree)adaptor.nil(); 10117 10118 10119 pushFollow(FOLLOW_insn_format35mi_method_in_instruction3938); 10120 insn_format35mi_method274=insn_format35mi_method(); 10121 state._fsp--; 10122 10123 adaptor.addChild(root_0, insn_format35mi_method274.getTree()); 10124 10125 } 10126 break; 10127 case 35 : 10128 // smaliParser.g:836:5: insn_format35ms_method 10129 { 10130 root_0 = (CommonTree)adaptor.nil(); 10131 10132 10133 pushFollow(FOLLOW_insn_format35ms_method_in_instruction3944); 10134 insn_format35ms_method275=insn_format35ms_method(); 10135 state._fsp--; 10136 10137 adaptor.addChild(root_0, insn_format35ms_method275.getTree()); 10138 10139 } 10140 break; 10141 case 36 : 10142 // smaliParser.g:837:5: insn_format3rc_method 10143 { 10144 root_0 = (CommonTree)adaptor.nil(); 10145 10146 10147 pushFollow(FOLLOW_insn_format3rc_method_in_instruction3950); 10148 insn_format3rc_method276=insn_format3rc_method(); 10149 state._fsp--; 10150 10151 adaptor.addChild(root_0, insn_format3rc_method276.getTree()); 10152 10153 } 10154 break; 10155 case 37 : 10156 // smaliParser.g:838:5: insn_format3rc_method_odex 10157 { 10158 root_0 = (CommonTree)adaptor.nil(); 10159 10160 10161 pushFollow(FOLLOW_insn_format3rc_method_odex_in_instruction3956); 10162 insn_format3rc_method_odex277=insn_format3rc_method_odex(); 10163 state._fsp--; 10164 10165 adaptor.addChild(root_0, insn_format3rc_method_odex277.getTree()); 10166 10167 } 10168 break; 10169 case 38 : 10170 // smaliParser.g:839:5: insn_format3rc_type 10171 { 10172 root_0 = (CommonTree)adaptor.nil(); 10173 10174 10175 pushFollow(FOLLOW_insn_format3rc_type_in_instruction3962); 10176 insn_format3rc_type278=insn_format3rc_type(); 10177 state._fsp--; 10178 10179 adaptor.addChild(root_0, insn_format3rc_type278.getTree()); 10180 10181 } 10182 break; 10183 case 39 : 10184 // smaliParser.g:840:5: insn_format3rmi_method 10185 { 10186 root_0 = (CommonTree)adaptor.nil(); 10187 10188 10189 pushFollow(FOLLOW_insn_format3rmi_method_in_instruction3968); 10190 insn_format3rmi_method279=insn_format3rmi_method(); 10191 state._fsp--; 10192 10193 adaptor.addChild(root_0, insn_format3rmi_method279.getTree()); 10194 10195 } 10196 break; 10197 case 40 : 10198 // smaliParser.g:841:5: insn_format3rms_method 10199 { 10200 root_0 = (CommonTree)adaptor.nil(); 10201 10202 10203 pushFollow(FOLLOW_insn_format3rms_method_in_instruction3974); 10204 insn_format3rms_method280=insn_format3rms_method(); 10205 state._fsp--; 10206 10207 adaptor.addChild(root_0, insn_format3rms_method280.getTree()); 10208 10209 } 10210 break; 10211 case 41 : 10212 // smaliParser.g:842:5: insn_format45cc_method 10213 { 10214 root_0 = (CommonTree)adaptor.nil(); 10215 10216 10217 pushFollow(FOLLOW_insn_format45cc_method_in_instruction3980); 10218 insn_format45cc_method281=insn_format45cc_method(); 10219 state._fsp--; 10220 10221 adaptor.addChild(root_0, insn_format45cc_method281.getTree()); 10222 10223 } 10224 break; 10225 case 42 : 10226 // smaliParser.g:843:5: insn_format4rcc_method 10227 { 10228 root_0 = (CommonTree)adaptor.nil(); 10229 10230 10231 pushFollow(FOLLOW_insn_format4rcc_method_in_instruction3986); 10232 insn_format4rcc_method282=insn_format4rcc_method(); 10233 state._fsp--; 10234 10235 adaptor.addChild(root_0, insn_format4rcc_method282.getTree()); 10236 10237 } 10238 break; 10239 case 43 : 10240 // smaliParser.g:844:5: insn_format51l 10241 { 10242 root_0 = (CommonTree)adaptor.nil(); 10243 10244 10245 pushFollow(FOLLOW_insn_format51l_in_instruction3992); 10246 insn_format51l283=insn_format51l(); 10247 state._fsp--; 10248 10249 adaptor.addChild(root_0, insn_format51l283.getTree()); 10250 10251 } 10252 break; 10253 case 44 : 10254 // smaliParser.g:845:5: insn_array_data_directive 10255 { 10256 root_0 = (CommonTree)adaptor.nil(); 10257 10258 10259 pushFollow(FOLLOW_insn_array_data_directive_in_instruction3998); 10260 insn_array_data_directive284=insn_array_data_directive(); 10261 state._fsp--; 10262 10263 adaptor.addChild(root_0, insn_array_data_directive284.getTree()); 10264 10265 } 10266 break; 10267 case 45 : 10268 // smaliParser.g:846:5: insn_packed_switch_directive 10269 { 10270 root_0 = (CommonTree)adaptor.nil(); 10271 10272 10273 pushFollow(FOLLOW_insn_packed_switch_directive_in_instruction4004); 10274 insn_packed_switch_directive285=insn_packed_switch_directive(); 10275 state._fsp--; 10276 10277 adaptor.addChild(root_0, insn_packed_switch_directive285.getTree()); 10278 10279 } 10280 break; 10281 case 46 : 10282 // smaliParser.g:847:5: insn_sparse_switch_directive 10283 { 10284 root_0 = (CommonTree)adaptor.nil(); 10285 10286 10287 pushFollow(FOLLOW_insn_sparse_switch_directive_in_instruction4010); 10288 insn_sparse_switch_directive286=insn_sparse_switch_directive(); 10289 state._fsp--; 10290 10291 adaptor.addChild(root_0, insn_sparse_switch_directive286.getTree()); 10292 10293 } 10294 break; 10295 10296 } 10297 retval.stop = input.LT(-1); 10298 10299 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10300 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10301 10302 } 10303 catch (RecognitionException re) { 10304 reportError(re); 10305 recover(input,re); 10306 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10307 } 10308 finally { 10309 // do for sure before leaving 10310 } 10311 return retval; 10312 } 10313 // $ANTLR end "instruction" 10314 10315 10316 public static class insn_format10t_return extends ParserRuleReturnScope { 10317 CommonTree tree; 10318 @Override 10319 public CommonTree getTree() { return tree; } 10320 }; 10321 10322 10323 // $ANTLR start "insn_format10t" 10324 // smaliParser.g:849:1: insn_format10t : INSTRUCTION_FORMAT10t label_ref -> ^( I_STATEMENT_FORMAT10t[$start, \"I_STATEMENT_FORMAT10t\"] INSTRUCTION_FORMAT10t label_ref ) ; 10325 public final smaliParser.insn_format10t_return insn_format10t() throws RecognitionException { 10326 smaliParser.insn_format10t_return retval = new smaliParser.insn_format10t_return(); 10327 retval.start = input.LT(1); 10328 10329 CommonTree root_0 = null; 10330 10331 Token INSTRUCTION_FORMAT10t287=null; 10332 ParserRuleReturnScope label_ref288 =null; 10333 10334 CommonTree INSTRUCTION_FORMAT10t287_tree=null; 10335 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT10t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT10t"); 10336 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 10337 10338 try { 10339 // smaliParser.g:850:3: ( INSTRUCTION_FORMAT10t label_ref -> ^( I_STATEMENT_FORMAT10t[$start, \"I_STATEMENT_FORMAT10t\"] INSTRUCTION_FORMAT10t label_ref ) ) 10340 // smaliParser.g:852:5: INSTRUCTION_FORMAT10t label_ref 10341 { 10342 INSTRUCTION_FORMAT10t287=(Token)match(input,INSTRUCTION_FORMAT10t,FOLLOW_INSTRUCTION_FORMAT10t_in_insn_format10t4030); 10343 stream_INSTRUCTION_FORMAT10t.add(INSTRUCTION_FORMAT10t287); 10344 10345 pushFollow(FOLLOW_label_ref_in_insn_format10t4032); 10346 label_ref288=label_ref(); 10347 state._fsp--; 10348 10349 stream_label_ref.add(label_ref288.getTree()); 10350 // AST REWRITE 10351 // elements: INSTRUCTION_FORMAT10t, label_ref 10352 // token labels: 10353 // rule labels: retval 10354 // token list labels: 10355 // rule list labels: 10356 // wildcard labels: 10357 retval.tree = root_0; 10358 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10359 10360 root_0 = (CommonTree)adaptor.nil(); 10361 // 853:5: -> ^( I_STATEMENT_FORMAT10t[$start, \"I_STATEMENT_FORMAT10t\"] INSTRUCTION_FORMAT10t label_ref ) 10362 { 10363 // smaliParser.g:853:8: ^( I_STATEMENT_FORMAT10t[$start, \"I_STATEMENT_FORMAT10t\"] INSTRUCTION_FORMAT10t label_ref ) 10364 { 10365 CommonTree root_1 = (CommonTree)adaptor.nil(); 10366 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT10t, (retval.start), "I_STATEMENT_FORMAT10t"), root_1); 10367 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT10t.nextNode()); 10368 adaptor.addChild(root_1, stream_label_ref.nextTree()); 10369 adaptor.addChild(root_0, root_1); 10370 } 10371 10372 } 10373 10374 10375 retval.tree = root_0; 10376 10377 } 10378 10379 retval.stop = input.LT(-1); 10380 10381 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10382 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10383 10384 } 10385 catch (RecognitionException re) { 10386 reportError(re); 10387 recover(input,re); 10388 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10389 } 10390 finally { 10391 // do for sure before leaving 10392 } 10393 return retval; 10394 } 10395 // $ANTLR end "insn_format10t" 10396 10397 10398 public static class insn_format10x_return extends ParserRuleReturnScope { 10399 CommonTree tree; 10400 @Override 10401 public CommonTree getTree() { return tree; } 10402 }; 10403 10404 10405 // $ANTLR start "insn_format10x" 10406 // smaliParser.g:855:1: insn_format10x : INSTRUCTION_FORMAT10x -> ^( I_STATEMENT_FORMAT10x[$start, \"I_STATEMENT_FORMAT10x\"] INSTRUCTION_FORMAT10x ) ; 10407 public final smaliParser.insn_format10x_return insn_format10x() throws RecognitionException { 10408 smaliParser.insn_format10x_return retval = new smaliParser.insn_format10x_return(); 10409 retval.start = input.LT(1); 10410 10411 CommonTree root_0 = null; 10412 10413 Token INSTRUCTION_FORMAT10x289=null; 10414 10415 CommonTree INSTRUCTION_FORMAT10x289_tree=null; 10416 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT10x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT10x"); 10417 10418 try { 10419 // smaliParser.g:856:3: ( INSTRUCTION_FORMAT10x -> ^( I_STATEMENT_FORMAT10x[$start, \"I_STATEMENT_FORMAT10x\"] INSTRUCTION_FORMAT10x ) ) 10420 // smaliParser.g:857:5: INSTRUCTION_FORMAT10x 10421 { 10422 INSTRUCTION_FORMAT10x289=(Token)match(input,INSTRUCTION_FORMAT10x,FOLLOW_INSTRUCTION_FORMAT10x_in_insn_format10x4062); 10423 stream_INSTRUCTION_FORMAT10x.add(INSTRUCTION_FORMAT10x289); 10424 10425 // AST REWRITE 10426 // elements: INSTRUCTION_FORMAT10x 10427 // token labels: 10428 // rule labels: retval 10429 // token list labels: 10430 // rule list labels: 10431 // wildcard labels: 10432 retval.tree = root_0; 10433 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10434 10435 root_0 = (CommonTree)adaptor.nil(); 10436 // 858:5: -> ^( I_STATEMENT_FORMAT10x[$start, \"I_STATEMENT_FORMAT10x\"] INSTRUCTION_FORMAT10x ) 10437 { 10438 // smaliParser.g:858:8: ^( I_STATEMENT_FORMAT10x[$start, \"I_STATEMENT_FORMAT10x\"] INSTRUCTION_FORMAT10x ) 10439 { 10440 CommonTree root_1 = (CommonTree)adaptor.nil(); 10441 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT10x, (retval.start), "I_STATEMENT_FORMAT10x"), root_1); 10442 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT10x.nextNode()); 10443 adaptor.addChild(root_0, root_1); 10444 } 10445 10446 } 10447 10448 10449 retval.tree = root_0; 10450 10451 } 10452 10453 retval.stop = input.LT(-1); 10454 10455 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10456 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10457 10458 } 10459 catch (RecognitionException re) { 10460 reportError(re); 10461 recover(input,re); 10462 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10463 } 10464 finally { 10465 // do for sure before leaving 10466 } 10467 return retval; 10468 } 10469 // $ANTLR end "insn_format10x" 10470 10471 10472 public static class insn_format10x_odex_return extends ParserRuleReturnScope { 10473 CommonTree tree; 10474 @Override 10475 public CommonTree getTree() { return tree; } 10476 }; 10477 10478 10479 // $ANTLR start "insn_format10x_odex" 10480 // smaliParser.g:860:1: insn_format10x_odex : INSTRUCTION_FORMAT10x_ODEX ; 10481 public final smaliParser.insn_format10x_odex_return insn_format10x_odex() throws RecognitionException { 10482 smaliParser.insn_format10x_odex_return retval = new smaliParser.insn_format10x_odex_return(); 10483 retval.start = input.LT(1); 10484 10485 CommonTree root_0 = null; 10486 10487 Token INSTRUCTION_FORMAT10x_ODEX290=null; 10488 10489 CommonTree INSTRUCTION_FORMAT10x_ODEX290_tree=null; 10490 10491 try { 10492 // smaliParser.g:861:3: ( INSTRUCTION_FORMAT10x_ODEX ) 10493 // smaliParser.g:862:5: INSTRUCTION_FORMAT10x_ODEX 10494 { 10495 root_0 = (CommonTree)adaptor.nil(); 10496 10497 10498 INSTRUCTION_FORMAT10x_ODEX290=(Token)match(input,INSTRUCTION_FORMAT10x_ODEX,FOLLOW_INSTRUCTION_FORMAT10x_ODEX_in_insn_format10x_odex4090); 10499 INSTRUCTION_FORMAT10x_ODEX290_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT10x_ODEX290); 10500 adaptor.addChild(root_0, INSTRUCTION_FORMAT10x_ODEX290_tree); 10501 10502 10503 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT10x_ODEX290!=null?INSTRUCTION_FORMAT10x_ODEX290.getText():null)); 10504 10505 } 10506 10507 retval.stop = input.LT(-1); 10508 10509 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10510 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10511 10512 } 10513 catch (RecognitionException re) { 10514 reportError(re); 10515 recover(input,re); 10516 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10517 } 10518 finally { 10519 // do for sure before leaving 10520 } 10521 return retval; 10522 } 10523 // $ANTLR end "insn_format10x_odex" 10524 10525 10526 public static class insn_format11n_return extends ParserRuleReturnScope { 10527 CommonTree tree; 10528 @Override 10529 public CommonTree getTree() { return tree; } 10530 }; 10531 10532 10533 // $ANTLR start "insn_format11n" 10534 // smaliParser.g:867:1: insn_format11n : INSTRUCTION_FORMAT11n REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT11n[$start, \"I_STATEMENT_FORMAT11n\"] INSTRUCTION_FORMAT11n REGISTER integral_literal ) ; 10535 public final smaliParser.insn_format11n_return insn_format11n() throws RecognitionException { 10536 smaliParser.insn_format11n_return retval = new smaliParser.insn_format11n_return(); 10537 retval.start = input.LT(1); 10538 10539 CommonTree root_0 = null; 10540 10541 Token INSTRUCTION_FORMAT11n291=null; 10542 Token REGISTER292=null; 10543 Token COMMA293=null; 10544 ParserRuleReturnScope integral_literal294 =null; 10545 10546 CommonTree INSTRUCTION_FORMAT11n291_tree=null; 10547 CommonTree REGISTER292_tree=null; 10548 CommonTree COMMA293_tree=null; 10549 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 10550 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 10551 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT11n=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT11n"); 10552 RewriteRuleSubtreeStream stream_integral_literal=new RewriteRuleSubtreeStream(adaptor,"rule integral_literal"); 10553 10554 try { 10555 // smaliParser.g:868:3: ( INSTRUCTION_FORMAT11n REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT11n[$start, \"I_STATEMENT_FORMAT11n\"] INSTRUCTION_FORMAT11n REGISTER integral_literal ) ) 10556 // smaliParser.g:869:5: INSTRUCTION_FORMAT11n REGISTER COMMA integral_literal 10557 { 10558 INSTRUCTION_FORMAT11n291=(Token)match(input,INSTRUCTION_FORMAT11n,FOLLOW_INSTRUCTION_FORMAT11n_in_insn_format11n4111); 10559 stream_INSTRUCTION_FORMAT11n.add(INSTRUCTION_FORMAT11n291); 10560 10561 REGISTER292=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format11n4113); 10562 stream_REGISTER.add(REGISTER292); 10563 10564 COMMA293=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format11n4115); 10565 stream_COMMA.add(COMMA293); 10566 10567 pushFollow(FOLLOW_integral_literal_in_insn_format11n4117); 10568 integral_literal294=integral_literal(); 10569 state._fsp--; 10570 10571 stream_integral_literal.add(integral_literal294.getTree()); 10572 // AST REWRITE 10573 // elements: integral_literal, INSTRUCTION_FORMAT11n, REGISTER 10574 // token labels: 10575 // rule labels: retval 10576 // token list labels: 10577 // rule list labels: 10578 // wildcard labels: 10579 retval.tree = root_0; 10580 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10581 10582 root_0 = (CommonTree)adaptor.nil(); 10583 // 870:5: -> ^( I_STATEMENT_FORMAT11n[$start, \"I_STATEMENT_FORMAT11n\"] INSTRUCTION_FORMAT11n REGISTER integral_literal ) 10584 { 10585 // smaliParser.g:870:8: ^( I_STATEMENT_FORMAT11n[$start, \"I_STATEMENT_FORMAT11n\"] INSTRUCTION_FORMAT11n REGISTER integral_literal ) 10586 { 10587 CommonTree root_1 = (CommonTree)adaptor.nil(); 10588 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT11n, (retval.start), "I_STATEMENT_FORMAT11n"), root_1); 10589 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT11n.nextNode()); 10590 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 10591 adaptor.addChild(root_1, stream_integral_literal.nextTree()); 10592 adaptor.addChild(root_0, root_1); 10593 } 10594 10595 } 10596 10597 10598 retval.tree = root_0; 10599 10600 } 10601 10602 retval.stop = input.LT(-1); 10603 10604 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10605 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10606 10607 } 10608 catch (RecognitionException re) { 10609 reportError(re); 10610 recover(input,re); 10611 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10612 } 10613 finally { 10614 // do for sure before leaving 10615 } 10616 return retval; 10617 } 10618 // $ANTLR end "insn_format11n" 10619 10620 10621 public static class insn_format11x_return extends ParserRuleReturnScope { 10622 CommonTree tree; 10623 @Override 10624 public CommonTree getTree() { return tree; } 10625 }; 10626 10627 10628 // $ANTLR start "insn_format11x" 10629 // smaliParser.g:872:1: insn_format11x : INSTRUCTION_FORMAT11x REGISTER -> ^( I_STATEMENT_FORMAT11x[$start, \"I_STATEMENT_FORMAT11x\"] INSTRUCTION_FORMAT11x REGISTER ) ; 10630 public final smaliParser.insn_format11x_return insn_format11x() throws RecognitionException { 10631 smaliParser.insn_format11x_return retval = new smaliParser.insn_format11x_return(); 10632 retval.start = input.LT(1); 10633 10634 CommonTree root_0 = null; 10635 10636 Token INSTRUCTION_FORMAT11x295=null; 10637 Token REGISTER296=null; 10638 10639 CommonTree INSTRUCTION_FORMAT11x295_tree=null; 10640 CommonTree REGISTER296_tree=null; 10641 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 10642 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT11x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT11x"); 10643 10644 try { 10645 // smaliParser.g:873:3: ( INSTRUCTION_FORMAT11x REGISTER -> ^( I_STATEMENT_FORMAT11x[$start, \"I_STATEMENT_FORMAT11x\"] INSTRUCTION_FORMAT11x REGISTER ) ) 10646 // smaliParser.g:874:5: INSTRUCTION_FORMAT11x REGISTER 10647 { 10648 INSTRUCTION_FORMAT11x295=(Token)match(input,INSTRUCTION_FORMAT11x,FOLLOW_INSTRUCTION_FORMAT11x_in_insn_format11x4149); 10649 stream_INSTRUCTION_FORMAT11x.add(INSTRUCTION_FORMAT11x295); 10650 10651 REGISTER296=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format11x4151); 10652 stream_REGISTER.add(REGISTER296); 10653 10654 // AST REWRITE 10655 // elements: REGISTER, INSTRUCTION_FORMAT11x 10656 // token labels: 10657 // rule labels: retval 10658 // token list labels: 10659 // rule list labels: 10660 // wildcard labels: 10661 retval.tree = root_0; 10662 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10663 10664 root_0 = (CommonTree)adaptor.nil(); 10665 // 875:5: -> ^( I_STATEMENT_FORMAT11x[$start, \"I_STATEMENT_FORMAT11x\"] INSTRUCTION_FORMAT11x REGISTER ) 10666 { 10667 // smaliParser.g:875:8: ^( I_STATEMENT_FORMAT11x[$start, \"I_STATEMENT_FORMAT11x\"] INSTRUCTION_FORMAT11x REGISTER ) 10668 { 10669 CommonTree root_1 = (CommonTree)adaptor.nil(); 10670 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT11x, (retval.start), "I_STATEMENT_FORMAT11x"), root_1); 10671 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT11x.nextNode()); 10672 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 10673 adaptor.addChild(root_0, root_1); 10674 } 10675 10676 } 10677 10678 10679 retval.tree = root_0; 10680 10681 } 10682 10683 retval.stop = input.LT(-1); 10684 10685 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10686 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10687 10688 } 10689 catch (RecognitionException re) { 10690 reportError(re); 10691 recover(input,re); 10692 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10693 } 10694 finally { 10695 // do for sure before leaving 10696 } 10697 return retval; 10698 } 10699 // $ANTLR end "insn_format11x" 10700 10701 10702 public static class insn_format12x_return extends ParserRuleReturnScope { 10703 CommonTree tree; 10704 @Override 10705 public CommonTree getTree() { return tree; } 10706 }; 10707 10708 10709 // $ANTLR start "insn_format12x" 10710 // smaliParser.g:877:1: insn_format12x : instruction_format12x REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT12x[$start, \"I_STATEMENT_FORMAT12x\"] instruction_format12x REGISTER REGISTER ) ; 10711 public final smaliParser.insn_format12x_return insn_format12x() throws RecognitionException { 10712 smaliParser.insn_format12x_return retval = new smaliParser.insn_format12x_return(); 10713 retval.start = input.LT(1); 10714 10715 CommonTree root_0 = null; 10716 10717 Token REGISTER298=null; 10718 Token COMMA299=null; 10719 Token REGISTER300=null; 10720 ParserRuleReturnScope instruction_format12x297 =null; 10721 10722 CommonTree REGISTER298_tree=null; 10723 CommonTree COMMA299_tree=null; 10724 CommonTree REGISTER300_tree=null; 10725 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 10726 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 10727 RewriteRuleSubtreeStream stream_instruction_format12x=new RewriteRuleSubtreeStream(adaptor,"rule instruction_format12x"); 10728 10729 try { 10730 // smaliParser.g:878:3: ( instruction_format12x REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT12x[$start, \"I_STATEMENT_FORMAT12x\"] instruction_format12x REGISTER REGISTER ) ) 10731 // smaliParser.g:879:5: instruction_format12x REGISTER COMMA REGISTER 10732 { 10733 pushFollow(FOLLOW_instruction_format12x_in_insn_format12x4181); 10734 instruction_format12x297=instruction_format12x(); 10735 state._fsp--; 10736 10737 stream_instruction_format12x.add(instruction_format12x297.getTree()); 10738 REGISTER298=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format12x4183); 10739 stream_REGISTER.add(REGISTER298); 10740 10741 COMMA299=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format12x4185); 10742 stream_COMMA.add(COMMA299); 10743 10744 REGISTER300=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format12x4187); 10745 stream_REGISTER.add(REGISTER300); 10746 10747 // AST REWRITE 10748 // elements: REGISTER, instruction_format12x, REGISTER 10749 // token labels: 10750 // rule labels: retval 10751 // token list labels: 10752 // rule list labels: 10753 // wildcard labels: 10754 retval.tree = root_0; 10755 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10756 10757 root_0 = (CommonTree)adaptor.nil(); 10758 // 880:5: -> ^( I_STATEMENT_FORMAT12x[$start, \"I_STATEMENT_FORMAT12x\"] instruction_format12x REGISTER REGISTER ) 10759 { 10760 // smaliParser.g:880:8: ^( I_STATEMENT_FORMAT12x[$start, \"I_STATEMENT_FORMAT12x\"] instruction_format12x REGISTER REGISTER ) 10761 { 10762 CommonTree root_1 = (CommonTree)adaptor.nil(); 10763 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT12x, (retval.start), "I_STATEMENT_FORMAT12x"), root_1); 10764 adaptor.addChild(root_1, stream_instruction_format12x.nextTree()); 10765 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 10766 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 10767 adaptor.addChild(root_0, root_1); 10768 } 10769 10770 } 10771 10772 10773 retval.tree = root_0; 10774 10775 } 10776 10777 retval.stop = input.LT(-1); 10778 10779 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10780 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10781 10782 } 10783 catch (RecognitionException re) { 10784 reportError(re); 10785 recover(input,re); 10786 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10787 } 10788 finally { 10789 // do for sure before leaving 10790 } 10791 return retval; 10792 } 10793 // $ANTLR end "insn_format12x" 10794 10795 10796 public static class insn_format20bc_return extends ParserRuleReturnScope { 10797 CommonTree tree; 10798 @Override 10799 public CommonTree getTree() { return tree; } 10800 }; 10801 10802 10803 // $ANTLR start "insn_format20bc" 10804 // smaliParser.g:882:1: insn_format20bc : INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE COMMA verification_error_reference -> ^( I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE verification_error_reference ) ; 10805 public final smaliParser.insn_format20bc_return insn_format20bc() throws RecognitionException { 10806 smaliParser.insn_format20bc_return retval = new smaliParser.insn_format20bc_return(); 10807 retval.start = input.LT(1); 10808 10809 CommonTree root_0 = null; 10810 10811 Token INSTRUCTION_FORMAT20bc301=null; 10812 Token VERIFICATION_ERROR_TYPE302=null; 10813 Token COMMA303=null; 10814 ParserRuleReturnScope verification_error_reference304 =null; 10815 10816 CommonTree INSTRUCTION_FORMAT20bc301_tree=null; 10817 CommonTree VERIFICATION_ERROR_TYPE302_tree=null; 10818 CommonTree COMMA303_tree=null; 10819 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 10820 RewriteRuleTokenStream stream_VERIFICATION_ERROR_TYPE=new RewriteRuleTokenStream(adaptor,"token VERIFICATION_ERROR_TYPE"); 10821 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT20bc=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT20bc"); 10822 RewriteRuleSubtreeStream stream_verification_error_reference=new RewriteRuleSubtreeStream(adaptor,"rule verification_error_reference"); 10823 10824 try { 10825 // smaliParser.g:883:3: ( INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE COMMA verification_error_reference -> ^( I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE verification_error_reference ) ) 10826 // smaliParser.g:884:5: INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE COMMA verification_error_reference 10827 { 10828 INSTRUCTION_FORMAT20bc301=(Token)match(input,INSTRUCTION_FORMAT20bc,FOLLOW_INSTRUCTION_FORMAT20bc_in_insn_format20bc4219); 10829 stream_INSTRUCTION_FORMAT20bc.add(INSTRUCTION_FORMAT20bc301); 10830 10831 VERIFICATION_ERROR_TYPE302=(Token)match(input,VERIFICATION_ERROR_TYPE,FOLLOW_VERIFICATION_ERROR_TYPE_in_insn_format20bc4221); 10832 stream_VERIFICATION_ERROR_TYPE.add(VERIFICATION_ERROR_TYPE302); 10833 10834 COMMA303=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format20bc4223); 10835 stream_COMMA.add(COMMA303); 10836 10837 pushFollow(FOLLOW_verification_error_reference_in_insn_format20bc4225); 10838 verification_error_reference304=verification_error_reference(); 10839 state._fsp--; 10840 10841 stream_verification_error_reference.add(verification_error_reference304.getTree()); 10842 10843 if (!allowOdex || opcodes.getOpcodeByName((INSTRUCTION_FORMAT20bc301!=null?INSTRUCTION_FORMAT20bc301.getText():null)) == null || apiLevel >= 14) { 10844 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT20bc301!=null?INSTRUCTION_FORMAT20bc301.getText():null)); 10845 } 10846 10847 // AST REWRITE 10848 // elements: VERIFICATION_ERROR_TYPE, verification_error_reference, INSTRUCTION_FORMAT20bc 10849 // token labels: 10850 // rule labels: retval 10851 // token list labels: 10852 // rule list labels: 10853 // wildcard labels: 10854 retval.tree = root_0; 10855 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10856 10857 root_0 = (CommonTree)adaptor.nil(); 10858 // 890:5: -> ^( I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE verification_error_reference ) 10859 { 10860 // smaliParser.g:890:8: ^( I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE verification_error_reference ) 10861 { 10862 CommonTree root_1 = (CommonTree)adaptor.nil(); 10863 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT20bc, "I_STATEMENT_FORMAT20bc"), root_1); 10864 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT20bc.nextNode()); 10865 adaptor.addChild(root_1, stream_VERIFICATION_ERROR_TYPE.nextNode()); 10866 adaptor.addChild(root_1, stream_verification_error_reference.nextTree()); 10867 adaptor.addChild(root_0, root_1); 10868 } 10869 10870 } 10871 10872 10873 retval.tree = root_0; 10874 10875 } 10876 10877 retval.stop = input.LT(-1); 10878 10879 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10880 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10881 10882 } 10883 catch (RecognitionException re) { 10884 reportError(re); 10885 recover(input,re); 10886 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10887 } 10888 finally { 10889 // do for sure before leaving 10890 } 10891 return retval; 10892 } 10893 // $ANTLR end "insn_format20bc" 10894 10895 10896 public static class insn_format20t_return extends ParserRuleReturnScope { 10897 CommonTree tree; 10898 @Override 10899 public CommonTree getTree() { return tree; } 10900 }; 10901 10902 10903 // $ANTLR start "insn_format20t" 10904 // smaliParser.g:892:1: insn_format20t : INSTRUCTION_FORMAT20t label_ref -> ^( I_STATEMENT_FORMAT20t[$start, \"I_STATEMENT_FORMAT20t\"] INSTRUCTION_FORMAT20t label_ref ) ; 10905 public final smaliParser.insn_format20t_return insn_format20t() throws RecognitionException { 10906 smaliParser.insn_format20t_return retval = new smaliParser.insn_format20t_return(); 10907 retval.start = input.LT(1); 10908 10909 CommonTree root_0 = null; 10910 10911 Token INSTRUCTION_FORMAT20t305=null; 10912 ParserRuleReturnScope label_ref306 =null; 10913 10914 CommonTree INSTRUCTION_FORMAT20t305_tree=null; 10915 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT20t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT20t"); 10916 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 10917 10918 try { 10919 // smaliParser.g:893:3: ( INSTRUCTION_FORMAT20t label_ref -> ^( I_STATEMENT_FORMAT20t[$start, \"I_STATEMENT_FORMAT20t\"] INSTRUCTION_FORMAT20t label_ref ) ) 10920 // smaliParser.g:894:5: INSTRUCTION_FORMAT20t label_ref 10921 { 10922 INSTRUCTION_FORMAT20t305=(Token)match(input,INSTRUCTION_FORMAT20t,FOLLOW_INSTRUCTION_FORMAT20t_in_insn_format20t4262); 10923 stream_INSTRUCTION_FORMAT20t.add(INSTRUCTION_FORMAT20t305); 10924 10925 pushFollow(FOLLOW_label_ref_in_insn_format20t4264); 10926 label_ref306=label_ref(); 10927 state._fsp--; 10928 10929 stream_label_ref.add(label_ref306.getTree()); 10930 // AST REWRITE 10931 // elements: INSTRUCTION_FORMAT20t, label_ref 10932 // token labels: 10933 // rule labels: retval 10934 // token list labels: 10935 // rule list labels: 10936 // wildcard labels: 10937 retval.tree = root_0; 10938 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10939 10940 root_0 = (CommonTree)adaptor.nil(); 10941 // 895:5: -> ^( I_STATEMENT_FORMAT20t[$start, \"I_STATEMENT_FORMAT20t\"] INSTRUCTION_FORMAT20t label_ref ) 10942 { 10943 // smaliParser.g:895:8: ^( I_STATEMENT_FORMAT20t[$start, \"I_STATEMENT_FORMAT20t\"] INSTRUCTION_FORMAT20t label_ref ) 10944 { 10945 CommonTree root_1 = (CommonTree)adaptor.nil(); 10946 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT20t, (retval.start), "I_STATEMENT_FORMAT20t"), root_1); 10947 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT20t.nextNode()); 10948 adaptor.addChild(root_1, stream_label_ref.nextTree()); 10949 adaptor.addChild(root_0, root_1); 10950 } 10951 10952 } 10953 10954 10955 retval.tree = root_0; 10956 10957 } 10958 10959 retval.stop = input.LT(-1); 10960 10961 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10962 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10963 10964 } 10965 catch (RecognitionException re) { 10966 reportError(re); 10967 recover(input,re); 10968 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10969 } 10970 finally { 10971 // do for sure before leaving 10972 } 10973 return retval; 10974 } 10975 // $ANTLR end "insn_format20t" 10976 10977 10978 public static class insn_format21c_field_return extends ParserRuleReturnScope { 10979 CommonTree tree; 10980 @Override 10981 public CommonTree getTree() { return tree; } 10982 }; 10983 10984 10985 // $ANTLR start "insn_format21c_field" 10986 // smaliParser.g:897:1: insn_format21c_field : INSTRUCTION_FORMAT21c_FIELD REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD REGISTER field_reference ) ; 10987 public final smaliParser.insn_format21c_field_return insn_format21c_field() throws RecognitionException { 10988 smaliParser.insn_format21c_field_return retval = new smaliParser.insn_format21c_field_return(); 10989 retval.start = input.LT(1); 10990 10991 CommonTree root_0 = null; 10992 10993 Token INSTRUCTION_FORMAT21c_FIELD307=null; 10994 Token REGISTER308=null; 10995 Token COMMA309=null; 10996 ParserRuleReturnScope field_reference310 =null; 10997 10998 CommonTree INSTRUCTION_FORMAT21c_FIELD307_tree=null; 10999 CommonTree REGISTER308_tree=null; 11000 CommonTree COMMA309_tree=null; 11001 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11002 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_FIELD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_FIELD"); 11003 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11004 RewriteRuleSubtreeStream stream_field_reference=new RewriteRuleSubtreeStream(adaptor,"rule field_reference"); 11005 11006 try { 11007 // smaliParser.g:898:3: ( INSTRUCTION_FORMAT21c_FIELD REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD REGISTER field_reference ) ) 11008 // smaliParser.g:899:5: INSTRUCTION_FORMAT21c_FIELD REGISTER COMMA field_reference 11009 { 11010 INSTRUCTION_FORMAT21c_FIELD307=(Token)match(input,INSTRUCTION_FORMAT21c_FIELD,FOLLOW_INSTRUCTION_FORMAT21c_FIELD_in_insn_format21c_field4294); 11011 stream_INSTRUCTION_FORMAT21c_FIELD.add(INSTRUCTION_FORMAT21c_FIELD307); 11012 11013 REGISTER308=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_field4296); 11014 stream_REGISTER.add(REGISTER308); 11015 11016 COMMA309=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21c_field4298); 11017 stream_COMMA.add(COMMA309); 11018 11019 pushFollow(FOLLOW_field_reference_in_insn_format21c_field4300); 11020 field_reference310=field_reference(); 11021 state._fsp--; 11022 11023 stream_field_reference.add(field_reference310.getTree()); 11024 // AST REWRITE 11025 // elements: REGISTER, INSTRUCTION_FORMAT21c_FIELD, field_reference 11026 // token labels: 11027 // rule labels: retval 11028 // token list labels: 11029 // rule list labels: 11030 // wildcard labels: 11031 retval.tree = root_0; 11032 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11033 11034 root_0 = (CommonTree)adaptor.nil(); 11035 // 900:5: -> ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD REGISTER field_reference ) 11036 { 11037 // smaliParser.g:900:8: ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD REGISTER field_reference ) 11038 { 11039 CommonTree root_1 = (CommonTree)adaptor.nil(); 11040 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21c_FIELD, (retval.start), "I_STATEMENT_FORMAT21c_FIELD"), root_1); 11041 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21c_FIELD.nextNode()); 11042 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11043 adaptor.addChild(root_1, stream_field_reference.nextTree()); 11044 adaptor.addChild(root_0, root_1); 11045 } 11046 11047 } 11048 11049 11050 retval.tree = root_0; 11051 11052 } 11053 11054 retval.stop = input.LT(-1); 11055 11056 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11057 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11058 11059 } 11060 catch (RecognitionException re) { 11061 reportError(re); 11062 recover(input,re); 11063 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11064 } 11065 finally { 11066 // do for sure before leaving 11067 } 11068 return retval; 11069 } 11070 // $ANTLR end "insn_format21c_field" 11071 11072 11073 public static class insn_format21c_field_odex_return extends ParserRuleReturnScope { 11074 CommonTree tree; 11075 @Override 11076 public CommonTree getTree() { return tree; } 11077 }; 11078 11079 11080 // $ANTLR start "insn_format21c_field_odex" 11081 // smaliParser.g:902:1: insn_format21c_field_odex : INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER field_reference ) ; 11082 public final smaliParser.insn_format21c_field_odex_return insn_format21c_field_odex() throws RecognitionException { 11083 smaliParser.insn_format21c_field_odex_return retval = new smaliParser.insn_format21c_field_odex_return(); 11084 retval.start = input.LT(1); 11085 11086 CommonTree root_0 = null; 11087 11088 Token INSTRUCTION_FORMAT21c_FIELD_ODEX311=null; 11089 Token REGISTER312=null; 11090 Token COMMA313=null; 11091 ParserRuleReturnScope field_reference314 =null; 11092 11093 CommonTree INSTRUCTION_FORMAT21c_FIELD_ODEX311_tree=null; 11094 CommonTree REGISTER312_tree=null; 11095 CommonTree COMMA313_tree=null; 11096 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11097 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11098 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_FIELD_ODEX=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_FIELD_ODEX"); 11099 RewriteRuleSubtreeStream stream_field_reference=new RewriteRuleSubtreeStream(adaptor,"rule field_reference"); 11100 11101 try { 11102 // smaliParser.g:903:3: ( INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER field_reference ) ) 11103 // smaliParser.g:904:5: INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER COMMA field_reference 11104 { 11105 INSTRUCTION_FORMAT21c_FIELD_ODEX311=(Token)match(input,INSTRUCTION_FORMAT21c_FIELD_ODEX,FOLLOW_INSTRUCTION_FORMAT21c_FIELD_ODEX_in_insn_format21c_field_odex4332); 11106 stream_INSTRUCTION_FORMAT21c_FIELD_ODEX.add(INSTRUCTION_FORMAT21c_FIELD_ODEX311); 11107 11108 REGISTER312=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_field_odex4334); 11109 stream_REGISTER.add(REGISTER312); 11110 11111 COMMA313=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21c_field_odex4336); 11112 stream_COMMA.add(COMMA313); 11113 11114 pushFollow(FOLLOW_field_reference_in_insn_format21c_field_odex4338); 11115 field_reference314=field_reference(); 11116 state._fsp--; 11117 11118 stream_field_reference.add(field_reference314.getTree()); 11119 11120 if (!allowOdex || opcodes.getOpcodeByName((INSTRUCTION_FORMAT21c_FIELD_ODEX311!=null?INSTRUCTION_FORMAT21c_FIELD_ODEX311.getText():null)) == null || apiLevel >= 14) { 11121 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT21c_FIELD_ODEX311!=null?INSTRUCTION_FORMAT21c_FIELD_ODEX311.getText():null)); 11122 } 11123 11124 // AST REWRITE 11125 // elements: INSTRUCTION_FORMAT21c_FIELD_ODEX, REGISTER, field_reference 11126 // token labels: 11127 // rule labels: retval 11128 // token list labels: 11129 // rule list labels: 11130 // wildcard labels: 11131 retval.tree = root_0; 11132 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11133 11134 root_0 = (CommonTree)adaptor.nil(); 11135 // 910:5: -> ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER field_reference ) 11136 { 11137 // smaliParser.g:910:8: ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER field_reference ) 11138 { 11139 CommonTree root_1 = (CommonTree)adaptor.nil(); 11140 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21c_FIELD, (retval.start), "I_STATEMENT_FORMAT21c_FIELD"), root_1); 11141 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21c_FIELD_ODEX.nextNode()); 11142 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11143 adaptor.addChild(root_1, stream_field_reference.nextTree()); 11144 adaptor.addChild(root_0, root_1); 11145 } 11146 11147 } 11148 11149 11150 retval.tree = root_0; 11151 11152 } 11153 11154 retval.stop = input.LT(-1); 11155 11156 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11157 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11158 11159 } 11160 catch (RecognitionException re) { 11161 reportError(re); 11162 recover(input,re); 11163 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11164 } 11165 finally { 11166 // do for sure before leaving 11167 } 11168 return retval; 11169 } 11170 // $ANTLR end "insn_format21c_field_odex" 11171 11172 11173 public static class insn_format21c_string_return extends ParserRuleReturnScope { 11174 CommonTree tree; 11175 @Override 11176 public CommonTree getTree() { return tree; } 11177 }; 11178 11179 11180 // $ANTLR start "insn_format21c_string" 11181 // smaliParser.g:912:1: insn_format21c_string : INSTRUCTION_FORMAT21c_STRING REGISTER COMMA STRING_LITERAL -> ^( I_STATEMENT_FORMAT21c_STRING[$start, \"I_STATEMENT_FORMAT21c_STRING\"] INSTRUCTION_FORMAT21c_STRING REGISTER STRING_LITERAL ) ; 11182 public final smaliParser.insn_format21c_string_return insn_format21c_string() throws RecognitionException { 11183 smaliParser.insn_format21c_string_return retval = new smaliParser.insn_format21c_string_return(); 11184 retval.start = input.LT(1); 11185 11186 CommonTree root_0 = null; 11187 11188 Token INSTRUCTION_FORMAT21c_STRING315=null; 11189 Token REGISTER316=null; 11190 Token COMMA317=null; 11191 Token STRING_LITERAL318=null; 11192 11193 CommonTree INSTRUCTION_FORMAT21c_STRING315_tree=null; 11194 CommonTree REGISTER316_tree=null; 11195 CommonTree COMMA317_tree=null; 11196 CommonTree STRING_LITERAL318_tree=null; 11197 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11198 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11199 RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL"); 11200 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_STRING=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_STRING"); 11201 11202 try { 11203 // smaliParser.g:913:3: ( INSTRUCTION_FORMAT21c_STRING REGISTER COMMA STRING_LITERAL -> ^( I_STATEMENT_FORMAT21c_STRING[$start, \"I_STATEMENT_FORMAT21c_STRING\"] INSTRUCTION_FORMAT21c_STRING REGISTER STRING_LITERAL ) ) 11204 // smaliParser.g:914:5: INSTRUCTION_FORMAT21c_STRING REGISTER COMMA STRING_LITERAL 11205 { 11206 INSTRUCTION_FORMAT21c_STRING315=(Token)match(input,INSTRUCTION_FORMAT21c_STRING,FOLLOW_INSTRUCTION_FORMAT21c_STRING_in_insn_format21c_string4376); 11207 stream_INSTRUCTION_FORMAT21c_STRING.add(INSTRUCTION_FORMAT21c_STRING315); 11208 11209 REGISTER316=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_string4378); 11210 stream_REGISTER.add(REGISTER316); 11211 11212 COMMA317=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21c_string4380); 11213 stream_COMMA.add(COMMA317); 11214 11215 STRING_LITERAL318=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_insn_format21c_string4382); 11216 stream_STRING_LITERAL.add(STRING_LITERAL318); 11217 11218 // AST REWRITE 11219 // elements: STRING_LITERAL, REGISTER, INSTRUCTION_FORMAT21c_STRING 11220 // token labels: 11221 // rule labels: retval 11222 // token list labels: 11223 // rule list labels: 11224 // wildcard labels: 11225 retval.tree = root_0; 11226 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11227 11228 root_0 = (CommonTree)adaptor.nil(); 11229 // 915:5: -> ^( I_STATEMENT_FORMAT21c_STRING[$start, \"I_STATEMENT_FORMAT21c_STRING\"] INSTRUCTION_FORMAT21c_STRING REGISTER STRING_LITERAL ) 11230 { 11231 // smaliParser.g:915:8: ^( I_STATEMENT_FORMAT21c_STRING[$start, \"I_STATEMENT_FORMAT21c_STRING\"] INSTRUCTION_FORMAT21c_STRING REGISTER STRING_LITERAL ) 11232 { 11233 CommonTree root_1 = (CommonTree)adaptor.nil(); 11234 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21c_STRING, (retval.start), "I_STATEMENT_FORMAT21c_STRING"), root_1); 11235 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21c_STRING.nextNode()); 11236 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11237 adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode()); 11238 adaptor.addChild(root_0, root_1); 11239 } 11240 11241 } 11242 11243 11244 retval.tree = root_0; 11245 11246 } 11247 11248 retval.stop = input.LT(-1); 11249 11250 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11251 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11252 11253 } 11254 catch (RecognitionException re) { 11255 reportError(re); 11256 recover(input,re); 11257 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11258 } 11259 finally { 11260 // do for sure before leaving 11261 } 11262 return retval; 11263 } 11264 // $ANTLR end "insn_format21c_string" 11265 11266 11267 public static class insn_format21c_type_return extends ParserRuleReturnScope { 11268 CommonTree tree; 11269 @Override 11270 public CommonTree getTree() { return tree; } 11271 }; 11272 11273 11274 // $ANTLR start "insn_format21c_type" 11275 // smaliParser.g:917:1: insn_format21c_type : INSTRUCTION_FORMAT21c_TYPE REGISTER COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT21c_TYPE[$start, \"I_STATEMENT_FORMAT21c\"] INSTRUCTION_FORMAT21c_TYPE REGISTER nonvoid_type_descriptor ) ; 11276 public final smaliParser.insn_format21c_type_return insn_format21c_type() throws RecognitionException { 11277 smaliParser.insn_format21c_type_return retval = new smaliParser.insn_format21c_type_return(); 11278 retval.start = input.LT(1); 11279 11280 CommonTree root_0 = null; 11281 11282 Token INSTRUCTION_FORMAT21c_TYPE319=null; 11283 Token REGISTER320=null; 11284 Token COMMA321=null; 11285 ParserRuleReturnScope nonvoid_type_descriptor322 =null; 11286 11287 CommonTree INSTRUCTION_FORMAT21c_TYPE319_tree=null; 11288 CommonTree REGISTER320_tree=null; 11289 CommonTree COMMA321_tree=null; 11290 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11291 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11292 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_TYPE"); 11293 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 11294 11295 try { 11296 // smaliParser.g:918:3: ( INSTRUCTION_FORMAT21c_TYPE REGISTER COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT21c_TYPE[$start, \"I_STATEMENT_FORMAT21c\"] INSTRUCTION_FORMAT21c_TYPE REGISTER nonvoid_type_descriptor ) ) 11297 // smaliParser.g:919:5: INSTRUCTION_FORMAT21c_TYPE REGISTER COMMA nonvoid_type_descriptor 11298 { 11299 INSTRUCTION_FORMAT21c_TYPE319=(Token)match(input,INSTRUCTION_FORMAT21c_TYPE,FOLLOW_INSTRUCTION_FORMAT21c_TYPE_in_insn_format21c_type4414); 11300 stream_INSTRUCTION_FORMAT21c_TYPE.add(INSTRUCTION_FORMAT21c_TYPE319); 11301 11302 REGISTER320=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_type4416); 11303 stream_REGISTER.add(REGISTER320); 11304 11305 COMMA321=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21c_type4418); 11306 stream_COMMA.add(COMMA321); 11307 11308 pushFollow(FOLLOW_nonvoid_type_descriptor_in_insn_format21c_type4420); 11309 nonvoid_type_descriptor322=nonvoid_type_descriptor(); 11310 state._fsp--; 11311 11312 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor322.getTree()); 11313 // AST REWRITE 11314 // elements: REGISTER, INSTRUCTION_FORMAT21c_TYPE, nonvoid_type_descriptor 11315 // token labels: 11316 // rule labels: retval 11317 // token list labels: 11318 // rule list labels: 11319 // wildcard labels: 11320 retval.tree = root_0; 11321 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11322 11323 root_0 = (CommonTree)adaptor.nil(); 11324 // 920:5: -> ^( I_STATEMENT_FORMAT21c_TYPE[$start, \"I_STATEMENT_FORMAT21c\"] INSTRUCTION_FORMAT21c_TYPE REGISTER nonvoid_type_descriptor ) 11325 { 11326 // smaliParser.g:920:8: ^( I_STATEMENT_FORMAT21c_TYPE[$start, \"I_STATEMENT_FORMAT21c\"] INSTRUCTION_FORMAT21c_TYPE REGISTER nonvoid_type_descriptor ) 11327 { 11328 CommonTree root_1 = (CommonTree)adaptor.nil(); 11329 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21c_TYPE, (retval.start), "I_STATEMENT_FORMAT21c"), root_1); 11330 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21c_TYPE.nextNode()); 11331 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11332 adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree()); 11333 adaptor.addChild(root_0, root_1); 11334 } 11335 11336 } 11337 11338 11339 retval.tree = root_0; 11340 11341 } 11342 11343 retval.stop = input.LT(-1); 11344 11345 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11346 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11347 11348 } 11349 catch (RecognitionException re) { 11350 reportError(re); 11351 recover(input,re); 11352 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11353 } 11354 finally { 11355 // do for sure before leaving 11356 } 11357 return retval; 11358 } 11359 // $ANTLR end "insn_format21c_type" 11360 11361 11362 public static class insn_format21ih_return extends ParserRuleReturnScope { 11363 CommonTree tree; 11364 @Override 11365 public CommonTree getTree() { return tree; } 11366 }; 11367 11368 11369 // $ANTLR start "insn_format21ih" 11370 // smaliParser.g:922:1: insn_format21ih : INSTRUCTION_FORMAT21ih REGISTER COMMA fixed_32bit_literal -> ^( I_STATEMENT_FORMAT21ih[$start, \"I_STATEMENT_FORMAT21ih\"] INSTRUCTION_FORMAT21ih REGISTER fixed_32bit_literal ) ; 11371 public final smaliParser.insn_format21ih_return insn_format21ih() throws RecognitionException { 11372 smaliParser.insn_format21ih_return retval = new smaliParser.insn_format21ih_return(); 11373 retval.start = input.LT(1); 11374 11375 CommonTree root_0 = null; 11376 11377 Token INSTRUCTION_FORMAT21ih323=null; 11378 Token REGISTER324=null; 11379 Token COMMA325=null; 11380 ParserRuleReturnScope fixed_32bit_literal326 =null; 11381 11382 CommonTree INSTRUCTION_FORMAT21ih323_tree=null; 11383 CommonTree REGISTER324_tree=null; 11384 CommonTree COMMA325_tree=null; 11385 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11386 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11387 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21ih=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21ih"); 11388 RewriteRuleSubtreeStream stream_fixed_32bit_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_32bit_literal"); 11389 11390 try { 11391 // smaliParser.g:923:3: ( INSTRUCTION_FORMAT21ih REGISTER COMMA fixed_32bit_literal -> ^( I_STATEMENT_FORMAT21ih[$start, \"I_STATEMENT_FORMAT21ih\"] INSTRUCTION_FORMAT21ih REGISTER fixed_32bit_literal ) ) 11392 // smaliParser.g:924:5: INSTRUCTION_FORMAT21ih REGISTER COMMA fixed_32bit_literal 11393 { 11394 INSTRUCTION_FORMAT21ih323=(Token)match(input,INSTRUCTION_FORMAT21ih,FOLLOW_INSTRUCTION_FORMAT21ih_in_insn_format21ih4452); 11395 stream_INSTRUCTION_FORMAT21ih.add(INSTRUCTION_FORMAT21ih323); 11396 11397 REGISTER324=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21ih4454); 11398 stream_REGISTER.add(REGISTER324); 11399 11400 COMMA325=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21ih4456); 11401 stream_COMMA.add(COMMA325); 11402 11403 pushFollow(FOLLOW_fixed_32bit_literal_in_insn_format21ih4458); 11404 fixed_32bit_literal326=fixed_32bit_literal(); 11405 state._fsp--; 11406 11407 stream_fixed_32bit_literal.add(fixed_32bit_literal326.getTree()); 11408 // AST REWRITE 11409 // elements: REGISTER, INSTRUCTION_FORMAT21ih, fixed_32bit_literal 11410 // token labels: 11411 // rule labels: retval 11412 // token list labels: 11413 // rule list labels: 11414 // wildcard labels: 11415 retval.tree = root_0; 11416 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11417 11418 root_0 = (CommonTree)adaptor.nil(); 11419 // 925:5: -> ^( I_STATEMENT_FORMAT21ih[$start, \"I_STATEMENT_FORMAT21ih\"] INSTRUCTION_FORMAT21ih REGISTER fixed_32bit_literal ) 11420 { 11421 // smaliParser.g:925:8: ^( I_STATEMENT_FORMAT21ih[$start, \"I_STATEMENT_FORMAT21ih\"] INSTRUCTION_FORMAT21ih REGISTER fixed_32bit_literal ) 11422 { 11423 CommonTree root_1 = (CommonTree)adaptor.nil(); 11424 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21ih, (retval.start), "I_STATEMENT_FORMAT21ih"), root_1); 11425 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21ih.nextNode()); 11426 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11427 adaptor.addChild(root_1, stream_fixed_32bit_literal.nextTree()); 11428 adaptor.addChild(root_0, root_1); 11429 } 11430 11431 } 11432 11433 11434 retval.tree = root_0; 11435 11436 } 11437 11438 retval.stop = input.LT(-1); 11439 11440 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11441 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11442 11443 } 11444 catch (RecognitionException re) { 11445 reportError(re); 11446 recover(input,re); 11447 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11448 } 11449 finally { 11450 // do for sure before leaving 11451 } 11452 return retval; 11453 } 11454 // $ANTLR end "insn_format21ih" 11455 11456 11457 public static class insn_format21lh_return extends ParserRuleReturnScope { 11458 CommonTree tree; 11459 @Override 11460 public CommonTree getTree() { return tree; } 11461 }; 11462 11463 11464 // $ANTLR start "insn_format21lh" 11465 // smaliParser.g:927:1: insn_format21lh : INSTRUCTION_FORMAT21lh REGISTER COMMA fixed_32bit_literal -> ^( I_STATEMENT_FORMAT21lh[$start, \"I_STATEMENT_FORMAT21lh\"] INSTRUCTION_FORMAT21lh REGISTER fixed_32bit_literal ) ; 11466 public final smaliParser.insn_format21lh_return insn_format21lh() throws RecognitionException { 11467 smaliParser.insn_format21lh_return retval = new smaliParser.insn_format21lh_return(); 11468 retval.start = input.LT(1); 11469 11470 CommonTree root_0 = null; 11471 11472 Token INSTRUCTION_FORMAT21lh327=null; 11473 Token REGISTER328=null; 11474 Token COMMA329=null; 11475 ParserRuleReturnScope fixed_32bit_literal330 =null; 11476 11477 CommonTree INSTRUCTION_FORMAT21lh327_tree=null; 11478 CommonTree REGISTER328_tree=null; 11479 CommonTree COMMA329_tree=null; 11480 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11481 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11482 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21lh=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21lh"); 11483 RewriteRuleSubtreeStream stream_fixed_32bit_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_32bit_literal"); 11484 11485 try { 11486 // smaliParser.g:928:3: ( INSTRUCTION_FORMAT21lh REGISTER COMMA fixed_32bit_literal -> ^( I_STATEMENT_FORMAT21lh[$start, \"I_STATEMENT_FORMAT21lh\"] INSTRUCTION_FORMAT21lh REGISTER fixed_32bit_literal ) ) 11487 // smaliParser.g:929:5: INSTRUCTION_FORMAT21lh REGISTER COMMA fixed_32bit_literal 11488 { 11489 INSTRUCTION_FORMAT21lh327=(Token)match(input,INSTRUCTION_FORMAT21lh,FOLLOW_INSTRUCTION_FORMAT21lh_in_insn_format21lh4490); 11490 stream_INSTRUCTION_FORMAT21lh.add(INSTRUCTION_FORMAT21lh327); 11491 11492 REGISTER328=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21lh4492); 11493 stream_REGISTER.add(REGISTER328); 11494 11495 COMMA329=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21lh4494); 11496 stream_COMMA.add(COMMA329); 11497 11498 pushFollow(FOLLOW_fixed_32bit_literal_in_insn_format21lh4496); 11499 fixed_32bit_literal330=fixed_32bit_literal(); 11500 state._fsp--; 11501 11502 stream_fixed_32bit_literal.add(fixed_32bit_literal330.getTree()); 11503 // AST REWRITE 11504 // elements: INSTRUCTION_FORMAT21lh, fixed_32bit_literal, REGISTER 11505 // token labels: 11506 // rule labels: retval 11507 // token list labels: 11508 // rule list labels: 11509 // wildcard labels: 11510 retval.tree = root_0; 11511 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11512 11513 root_0 = (CommonTree)adaptor.nil(); 11514 // 930:5: -> ^( I_STATEMENT_FORMAT21lh[$start, \"I_STATEMENT_FORMAT21lh\"] INSTRUCTION_FORMAT21lh REGISTER fixed_32bit_literal ) 11515 { 11516 // smaliParser.g:930:8: ^( I_STATEMENT_FORMAT21lh[$start, \"I_STATEMENT_FORMAT21lh\"] INSTRUCTION_FORMAT21lh REGISTER fixed_32bit_literal ) 11517 { 11518 CommonTree root_1 = (CommonTree)adaptor.nil(); 11519 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21lh, (retval.start), "I_STATEMENT_FORMAT21lh"), root_1); 11520 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21lh.nextNode()); 11521 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11522 adaptor.addChild(root_1, stream_fixed_32bit_literal.nextTree()); 11523 adaptor.addChild(root_0, root_1); 11524 } 11525 11526 } 11527 11528 11529 retval.tree = root_0; 11530 11531 } 11532 11533 retval.stop = input.LT(-1); 11534 11535 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11536 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11537 11538 } 11539 catch (RecognitionException re) { 11540 reportError(re); 11541 recover(input,re); 11542 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11543 } 11544 finally { 11545 // do for sure before leaving 11546 } 11547 return retval; 11548 } 11549 // $ANTLR end "insn_format21lh" 11550 11551 11552 public static class insn_format21s_return extends ParserRuleReturnScope { 11553 CommonTree tree; 11554 @Override 11555 public CommonTree getTree() { return tree; } 11556 }; 11557 11558 11559 // $ANTLR start "insn_format21s" 11560 // smaliParser.g:932:1: insn_format21s : INSTRUCTION_FORMAT21s REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT21s[$start, \"I_STATEMENT_FORMAT21s\"] INSTRUCTION_FORMAT21s REGISTER integral_literal ) ; 11561 public final smaliParser.insn_format21s_return insn_format21s() throws RecognitionException { 11562 smaliParser.insn_format21s_return retval = new smaliParser.insn_format21s_return(); 11563 retval.start = input.LT(1); 11564 11565 CommonTree root_0 = null; 11566 11567 Token INSTRUCTION_FORMAT21s331=null; 11568 Token REGISTER332=null; 11569 Token COMMA333=null; 11570 ParserRuleReturnScope integral_literal334 =null; 11571 11572 CommonTree INSTRUCTION_FORMAT21s331_tree=null; 11573 CommonTree REGISTER332_tree=null; 11574 CommonTree COMMA333_tree=null; 11575 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11576 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11577 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21s=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21s"); 11578 RewriteRuleSubtreeStream stream_integral_literal=new RewriteRuleSubtreeStream(adaptor,"rule integral_literal"); 11579 11580 try { 11581 // smaliParser.g:933:3: ( INSTRUCTION_FORMAT21s REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT21s[$start, \"I_STATEMENT_FORMAT21s\"] INSTRUCTION_FORMAT21s REGISTER integral_literal ) ) 11582 // smaliParser.g:934:5: INSTRUCTION_FORMAT21s REGISTER COMMA integral_literal 11583 { 11584 INSTRUCTION_FORMAT21s331=(Token)match(input,INSTRUCTION_FORMAT21s,FOLLOW_INSTRUCTION_FORMAT21s_in_insn_format21s4528); 11585 stream_INSTRUCTION_FORMAT21s.add(INSTRUCTION_FORMAT21s331); 11586 11587 REGISTER332=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21s4530); 11588 stream_REGISTER.add(REGISTER332); 11589 11590 COMMA333=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21s4532); 11591 stream_COMMA.add(COMMA333); 11592 11593 pushFollow(FOLLOW_integral_literal_in_insn_format21s4534); 11594 integral_literal334=integral_literal(); 11595 state._fsp--; 11596 11597 stream_integral_literal.add(integral_literal334.getTree()); 11598 // AST REWRITE 11599 // elements: integral_literal, REGISTER, INSTRUCTION_FORMAT21s 11600 // token labels: 11601 // rule labels: retval 11602 // token list labels: 11603 // rule list labels: 11604 // wildcard labels: 11605 retval.tree = root_0; 11606 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11607 11608 root_0 = (CommonTree)adaptor.nil(); 11609 // 935:5: -> ^( I_STATEMENT_FORMAT21s[$start, \"I_STATEMENT_FORMAT21s\"] INSTRUCTION_FORMAT21s REGISTER integral_literal ) 11610 { 11611 // smaliParser.g:935:8: ^( I_STATEMENT_FORMAT21s[$start, \"I_STATEMENT_FORMAT21s\"] INSTRUCTION_FORMAT21s REGISTER integral_literal ) 11612 { 11613 CommonTree root_1 = (CommonTree)adaptor.nil(); 11614 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21s, (retval.start), "I_STATEMENT_FORMAT21s"), root_1); 11615 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21s.nextNode()); 11616 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11617 adaptor.addChild(root_1, stream_integral_literal.nextTree()); 11618 adaptor.addChild(root_0, root_1); 11619 } 11620 11621 } 11622 11623 11624 retval.tree = root_0; 11625 11626 } 11627 11628 retval.stop = input.LT(-1); 11629 11630 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11631 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11632 11633 } 11634 catch (RecognitionException re) { 11635 reportError(re); 11636 recover(input,re); 11637 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11638 } 11639 finally { 11640 // do for sure before leaving 11641 } 11642 return retval; 11643 } 11644 // $ANTLR end "insn_format21s" 11645 11646 11647 public static class insn_format21t_return extends ParserRuleReturnScope { 11648 CommonTree tree; 11649 @Override 11650 public CommonTree getTree() { return tree; } 11651 }; 11652 11653 11654 // $ANTLR start "insn_format21t" 11655 // smaliParser.g:937:1: insn_format21t : INSTRUCTION_FORMAT21t REGISTER COMMA label_ref -> ^( I_STATEMENT_FORMAT21t[$start, \"I_STATEMENT_FORMAT21t\"] INSTRUCTION_FORMAT21t REGISTER label_ref ) ; 11656 public final smaliParser.insn_format21t_return insn_format21t() throws RecognitionException { 11657 smaliParser.insn_format21t_return retval = new smaliParser.insn_format21t_return(); 11658 retval.start = input.LT(1); 11659 11660 CommonTree root_0 = null; 11661 11662 Token INSTRUCTION_FORMAT21t335=null; 11663 Token REGISTER336=null; 11664 Token COMMA337=null; 11665 ParserRuleReturnScope label_ref338 =null; 11666 11667 CommonTree INSTRUCTION_FORMAT21t335_tree=null; 11668 CommonTree REGISTER336_tree=null; 11669 CommonTree COMMA337_tree=null; 11670 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11671 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11672 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21t"); 11673 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 11674 11675 try { 11676 // smaliParser.g:938:3: ( INSTRUCTION_FORMAT21t REGISTER COMMA label_ref -> ^( I_STATEMENT_FORMAT21t[$start, \"I_STATEMENT_FORMAT21t\"] INSTRUCTION_FORMAT21t REGISTER label_ref ) ) 11677 // smaliParser.g:939:5: INSTRUCTION_FORMAT21t REGISTER COMMA label_ref 11678 { 11679 INSTRUCTION_FORMAT21t335=(Token)match(input,INSTRUCTION_FORMAT21t,FOLLOW_INSTRUCTION_FORMAT21t_in_insn_format21t4566); 11680 stream_INSTRUCTION_FORMAT21t.add(INSTRUCTION_FORMAT21t335); 11681 11682 REGISTER336=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21t4568); 11683 stream_REGISTER.add(REGISTER336); 11684 11685 COMMA337=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21t4570); 11686 stream_COMMA.add(COMMA337); 11687 11688 pushFollow(FOLLOW_label_ref_in_insn_format21t4572); 11689 label_ref338=label_ref(); 11690 state._fsp--; 11691 11692 stream_label_ref.add(label_ref338.getTree()); 11693 // AST REWRITE 11694 // elements: INSTRUCTION_FORMAT21t, label_ref, REGISTER 11695 // token labels: 11696 // rule labels: retval 11697 // token list labels: 11698 // rule list labels: 11699 // wildcard labels: 11700 retval.tree = root_0; 11701 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11702 11703 root_0 = (CommonTree)adaptor.nil(); 11704 // 940:5: -> ^( I_STATEMENT_FORMAT21t[$start, \"I_STATEMENT_FORMAT21t\"] INSTRUCTION_FORMAT21t REGISTER label_ref ) 11705 { 11706 // smaliParser.g:940:8: ^( I_STATEMENT_FORMAT21t[$start, \"I_STATEMENT_FORMAT21t\"] INSTRUCTION_FORMAT21t REGISTER label_ref ) 11707 { 11708 CommonTree root_1 = (CommonTree)adaptor.nil(); 11709 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21t, (retval.start), "I_STATEMENT_FORMAT21t"), root_1); 11710 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21t.nextNode()); 11711 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11712 adaptor.addChild(root_1, stream_label_ref.nextTree()); 11713 adaptor.addChild(root_0, root_1); 11714 } 11715 11716 } 11717 11718 11719 retval.tree = root_0; 11720 11721 } 11722 11723 retval.stop = input.LT(-1); 11724 11725 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11726 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11727 11728 } 11729 catch (RecognitionException re) { 11730 reportError(re); 11731 recover(input,re); 11732 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11733 } 11734 finally { 11735 // do for sure before leaving 11736 } 11737 return retval; 11738 } 11739 // $ANTLR end "insn_format21t" 11740 11741 11742 public static class insn_format22b_return extends ParserRuleReturnScope { 11743 CommonTree tree; 11744 @Override 11745 public CommonTree getTree() { return tree; } 11746 }; 11747 11748 11749 // $ANTLR start "insn_format22b" 11750 // smaliParser.g:942:1: insn_format22b : INSTRUCTION_FORMAT22b REGISTER COMMA REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT22b[$start, \"I_STATEMENT_FORMAT22b\"] INSTRUCTION_FORMAT22b REGISTER REGISTER integral_literal ) ; 11751 public final smaliParser.insn_format22b_return insn_format22b() throws RecognitionException { 11752 smaliParser.insn_format22b_return retval = new smaliParser.insn_format22b_return(); 11753 retval.start = input.LT(1); 11754 11755 CommonTree root_0 = null; 11756 11757 Token INSTRUCTION_FORMAT22b339=null; 11758 Token REGISTER340=null; 11759 Token COMMA341=null; 11760 Token REGISTER342=null; 11761 Token COMMA343=null; 11762 ParserRuleReturnScope integral_literal344 =null; 11763 11764 CommonTree INSTRUCTION_FORMAT22b339_tree=null; 11765 CommonTree REGISTER340_tree=null; 11766 CommonTree COMMA341_tree=null; 11767 CommonTree REGISTER342_tree=null; 11768 CommonTree COMMA343_tree=null; 11769 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11770 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11771 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22b=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22b"); 11772 RewriteRuleSubtreeStream stream_integral_literal=new RewriteRuleSubtreeStream(adaptor,"rule integral_literal"); 11773 11774 try { 11775 // smaliParser.g:943:3: ( INSTRUCTION_FORMAT22b REGISTER COMMA REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT22b[$start, \"I_STATEMENT_FORMAT22b\"] INSTRUCTION_FORMAT22b REGISTER REGISTER integral_literal ) ) 11776 // smaliParser.g:944:5: INSTRUCTION_FORMAT22b REGISTER COMMA REGISTER COMMA integral_literal 11777 { 11778 INSTRUCTION_FORMAT22b339=(Token)match(input,INSTRUCTION_FORMAT22b,FOLLOW_INSTRUCTION_FORMAT22b_in_insn_format22b4604); 11779 stream_INSTRUCTION_FORMAT22b.add(INSTRUCTION_FORMAT22b339); 11780 11781 REGISTER340=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22b4606); 11782 stream_REGISTER.add(REGISTER340); 11783 11784 COMMA341=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22b4608); 11785 stream_COMMA.add(COMMA341); 11786 11787 REGISTER342=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22b4610); 11788 stream_REGISTER.add(REGISTER342); 11789 11790 COMMA343=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22b4612); 11791 stream_COMMA.add(COMMA343); 11792 11793 pushFollow(FOLLOW_integral_literal_in_insn_format22b4614); 11794 integral_literal344=integral_literal(); 11795 state._fsp--; 11796 11797 stream_integral_literal.add(integral_literal344.getTree()); 11798 // AST REWRITE 11799 // elements: REGISTER, REGISTER, integral_literal, INSTRUCTION_FORMAT22b 11800 // token labels: 11801 // rule labels: retval 11802 // token list labels: 11803 // rule list labels: 11804 // wildcard labels: 11805 retval.tree = root_0; 11806 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11807 11808 root_0 = (CommonTree)adaptor.nil(); 11809 // 945:5: -> ^( I_STATEMENT_FORMAT22b[$start, \"I_STATEMENT_FORMAT22b\"] INSTRUCTION_FORMAT22b REGISTER REGISTER integral_literal ) 11810 { 11811 // smaliParser.g:945:8: ^( I_STATEMENT_FORMAT22b[$start, \"I_STATEMENT_FORMAT22b\"] INSTRUCTION_FORMAT22b REGISTER REGISTER integral_literal ) 11812 { 11813 CommonTree root_1 = (CommonTree)adaptor.nil(); 11814 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22b, (retval.start), "I_STATEMENT_FORMAT22b"), root_1); 11815 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22b.nextNode()); 11816 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11817 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11818 adaptor.addChild(root_1, stream_integral_literal.nextTree()); 11819 adaptor.addChild(root_0, root_1); 11820 } 11821 11822 } 11823 11824 11825 retval.tree = root_0; 11826 11827 } 11828 11829 retval.stop = input.LT(-1); 11830 11831 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11832 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11833 11834 } 11835 catch (RecognitionException re) { 11836 reportError(re); 11837 recover(input,re); 11838 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11839 } 11840 finally { 11841 // do for sure before leaving 11842 } 11843 return retval; 11844 } 11845 // $ANTLR end "insn_format22b" 11846 11847 11848 public static class insn_format22c_field_return extends ParserRuleReturnScope { 11849 CommonTree tree; 11850 @Override 11851 public CommonTree getTree() { return tree; } 11852 }; 11853 11854 11855 // $ANTLR start "insn_format22c_field" 11856 // smaliParser.g:947:1: insn_format22c_field : INSTRUCTION_FORMAT22c_FIELD REGISTER COMMA REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD REGISTER REGISTER field_reference ) ; 11857 public final smaliParser.insn_format22c_field_return insn_format22c_field() throws RecognitionException { 11858 smaliParser.insn_format22c_field_return retval = new smaliParser.insn_format22c_field_return(); 11859 retval.start = input.LT(1); 11860 11861 CommonTree root_0 = null; 11862 11863 Token INSTRUCTION_FORMAT22c_FIELD345=null; 11864 Token REGISTER346=null; 11865 Token COMMA347=null; 11866 Token REGISTER348=null; 11867 Token COMMA349=null; 11868 ParserRuleReturnScope field_reference350 =null; 11869 11870 CommonTree INSTRUCTION_FORMAT22c_FIELD345_tree=null; 11871 CommonTree REGISTER346_tree=null; 11872 CommonTree COMMA347_tree=null; 11873 CommonTree REGISTER348_tree=null; 11874 CommonTree COMMA349_tree=null; 11875 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11876 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_FIELD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_FIELD"); 11877 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11878 RewriteRuleSubtreeStream stream_field_reference=new RewriteRuleSubtreeStream(adaptor,"rule field_reference"); 11879 11880 try { 11881 // smaliParser.g:948:3: ( INSTRUCTION_FORMAT22c_FIELD REGISTER COMMA REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD REGISTER REGISTER field_reference ) ) 11882 // smaliParser.g:949:5: INSTRUCTION_FORMAT22c_FIELD REGISTER COMMA REGISTER COMMA field_reference 11883 { 11884 INSTRUCTION_FORMAT22c_FIELD345=(Token)match(input,INSTRUCTION_FORMAT22c_FIELD,FOLLOW_INSTRUCTION_FORMAT22c_FIELD_in_insn_format22c_field4648); 11885 stream_INSTRUCTION_FORMAT22c_FIELD.add(INSTRUCTION_FORMAT22c_FIELD345); 11886 11887 REGISTER346=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_field4650); 11888 stream_REGISTER.add(REGISTER346); 11889 11890 COMMA347=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_field4652); 11891 stream_COMMA.add(COMMA347); 11892 11893 REGISTER348=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_field4654); 11894 stream_REGISTER.add(REGISTER348); 11895 11896 COMMA349=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_field4656); 11897 stream_COMMA.add(COMMA349); 11898 11899 pushFollow(FOLLOW_field_reference_in_insn_format22c_field4658); 11900 field_reference350=field_reference(); 11901 state._fsp--; 11902 11903 stream_field_reference.add(field_reference350.getTree()); 11904 // AST REWRITE 11905 // elements: INSTRUCTION_FORMAT22c_FIELD, REGISTER, field_reference, REGISTER 11906 // token labels: 11907 // rule labels: retval 11908 // token list labels: 11909 // rule list labels: 11910 // wildcard labels: 11911 retval.tree = root_0; 11912 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11913 11914 root_0 = (CommonTree)adaptor.nil(); 11915 // 950:5: -> ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD REGISTER REGISTER field_reference ) 11916 { 11917 // smaliParser.g:950:8: ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD REGISTER REGISTER field_reference ) 11918 { 11919 CommonTree root_1 = (CommonTree)adaptor.nil(); 11920 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22c_FIELD, (retval.start), "I_STATEMENT_FORMAT22c_FIELD"), root_1); 11921 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22c_FIELD.nextNode()); 11922 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11923 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11924 adaptor.addChild(root_1, stream_field_reference.nextTree()); 11925 adaptor.addChild(root_0, root_1); 11926 } 11927 11928 } 11929 11930 11931 retval.tree = root_0; 11932 11933 } 11934 11935 retval.stop = input.LT(-1); 11936 11937 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11938 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11939 11940 } 11941 catch (RecognitionException re) { 11942 reportError(re); 11943 recover(input,re); 11944 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11945 } 11946 finally { 11947 // do for sure before leaving 11948 } 11949 return retval; 11950 } 11951 // $ANTLR end "insn_format22c_field" 11952 11953 11954 public static class insn_format22c_field_odex_return extends ParserRuleReturnScope { 11955 CommonTree tree; 11956 @Override 11957 public CommonTree getTree() { return tree; } 11958 }; 11959 11960 11961 // $ANTLR start "insn_format22c_field_odex" 11962 // smaliParser.g:952:1: insn_format22c_field_odex : INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER COMMA REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER REGISTER field_reference ) ; 11963 public final smaliParser.insn_format22c_field_odex_return insn_format22c_field_odex() throws RecognitionException { 11964 smaliParser.insn_format22c_field_odex_return retval = new smaliParser.insn_format22c_field_odex_return(); 11965 retval.start = input.LT(1); 11966 11967 CommonTree root_0 = null; 11968 11969 Token INSTRUCTION_FORMAT22c_FIELD_ODEX351=null; 11970 Token REGISTER352=null; 11971 Token COMMA353=null; 11972 Token REGISTER354=null; 11973 Token COMMA355=null; 11974 ParserRuleReturnScope field_reference356 =null; 11975 11976 CommonTree INSTRUCTION_FORMAT22c_FIELD_ODEX351_tree=null; 11977 CommonTree REGISTER352_tree=null; 11978 CommonTree COMMA353_tree=null; 11979 CommonTree REGISTER354_tree=null; 11980 CommonTree COMMA355_tree=null; 11981 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11982 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11983 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_FIELD_ODEX=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_FIELD_ODEX"); 11984 RewriteRuleSubtreeStream stream_field_reference=new RewriteRuleSubtreeStream(adaptor,"rule field_reference"); 11985 11986 try { 11987 // smaliParser.g:953:3: ( INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER COMMA REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER REGISTER field_reference ) ) 11988 // smaliParser.g:954:5: INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER COMMA REGISTER COMMA field_reference 11989 { 11990 INSTRUCTION_FORMAT22c_FIELD_ODEX351=(Token)match(input,INSTRUCTION_FORMAT22c_FIELD_ODEX,FOLLOW_INSTRUCTION_FORMAT22c_FIELD_ODEX_in_insn_format22c_field_odex4692); 11991 stream_INSTRUCTION_FORMAT22c_FIELD_ODEX.add(INSTRUCTION_FORMAT22c_FIELD_ODEX351); 11992 11993 REGISTER352=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_field_odex4694); 11994 stream_REGISTER.add(REGISTER352); 11995 11996 COMMA353=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_field_odex4696); 11997 stream_COMMA.add(COMMA353); 11998 11999 REGISTER354=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_field_odex4698); 12000 stream_REGISTER.add(REGISTER354); 12001 12002 COMMA355=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_field_odex4700); 12003 stream_COMMA.add(COMMA355); 12004 12005 pushFollow(FOLLOW_field_reference_in_insn_format22c_field_odex4702); 12006 field_reference356=field_reference(); 12007 state._fsp--; 12008 12009 stream_field_reference.add(field_reference356.getTree()); 12010 12011 if (!allowOdex || opcodes.getOpcodeByName((INSTRUCTION_FORMAT22c_FIELD_ODEX351!=null?INSTRUCTION_FORMAT22c_FIELD_ODEX351.getText():null)) == null || apiLevel >= 14) { 12012 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT22c_FIELD_ODEX351!=null?INSTRUCTION_FORMAT22c_FIELD_ODEX351.getText():null)); 12013 } 12014 12015 // AST REWRITE 12016 // elements: INSTRUCTION_FORMAT22c_FIELD_ODEX, field_reference, REGISTER, REGISTER 12017 // token labels: 12018 // rule labels: retval 12019 // token list labels: 12020 // rule list labels: 12021 // wildcard labels: 12022 retval.tree = root_0; 12023 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12024 12025 root_0 = (CommonTree)adaptor.nil(); 12026 // 960:5: -> ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER REGISTER field_reference ) 12027 { 12028 // smaliParser.g:960:8: ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER REGISTER field_reference ) 12029 { 12030 CommonTree root_1 = (CommonTree)adaptor.nil(); 12031 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22c_FIELD, (retval.start), "I_STATEMENT_FORMAT22c_FIELD"), root_1); 12032 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22c_FIELD_ODEX.nextNode()); 12033 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12034 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12035 adaptor.addChild(root_1, stream_field_reference.nextTree()); 12036 adaptor.addChild(root_0, root_1); 12037 } 12038 12039 } 12040 12041 12042 retval.tree = root_0; 12043 12044 } 12045 12046 retval.stop = input.LT(-1); 12047 12048 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12049 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12050 12051 } 12052 catch (RecognitionException re) { 12053 reportError(re); 12054 recover(input,re); 12055 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12056 } 12057 finally { 12058 // do for sure before leaving 12059 } 12060 return retval; 12061 } 12062 // $ANTLR end "insn_format22c_field_odex" 12063 12064 12065 public static class insn_format22c_type_return extends ParserRuleReturnScope { 12066 CommonTree tree; 12067 @Override 12068 public CommonTree getTree() { return tree; } 12069 }; 12070 12071 12072 // $ANTLR start "insn_format22c_type" 12073 // smaliParser.g:962:1: insn_format22c_type : INSTRUCTION_FORMAT22c_TYPE REGISTER COMMA REGISTER COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT22c_TYPE[$start, \"I_STATEMENT_FORMAT22c_TYPE\"] INSTRUCTION_FORMAT22c_TYPE REGISTER REGISTER nonvoid_type_descriptor ) ; 12074 public final smaliParser.insn_format22c_type_return insn_format22c_type() throws RecognitionException { 12075 smaliParser.insn_format22c_type_return retval = new smaliParser.insn_format22c_type_return(); 12076 retval.start = input.LT(1); 12077 12078 CommonTree root_0 = null; 12079 12080 Token INSTRUCTION_FORMAT22c_TYPE357=null; 12081 Token REGISTER358=null; 12082 Token COMMA359=null; 12083 Token REGISTER360=null; 12084 Token COMMA361=null; 12085 ParserRuleReturnScope nonvoid_type_descriptor362 =null; 12086 12087 CommonTree INSTRUCTION_FORMAT22c_TYPE357_tree=null; 12088 CommonTree REGISTER358_tree=null; 12089 CommonTree COMMA359_tree=null; 12090 CommonTree REGISTER360_tree=null; 12091 CommonTree COMMA361_tree=null; 12092 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12093 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 12094 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_TYPE"); 12095 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 12096 12097 try { 12098 // smaliParser.g:963:3: ( INSTRUCTION_FORMAT22c_TYPE REGISTER COMMA REGISTER COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT22c_TYPE[$start, \"I_STATEMENT_FORMAT22c_TYPE\"] INSTRUCTION_FORMAT22c_TYPE REGISTER REGISTER nonvoid_type_descriptor ) ) 12099 // smaliParser.g:964:5: INSTRUCTION_FORMAT22c_TYPE REGISTER COMMA REGISTER COMMA nonvoid_type_descriptor 12100 { 12101 INSTRUCTION_FORMAT22c_TYPE357=(Token)match(input,INSTRUCTION_FORMAT22c_TYPE,FOLLOW_INSTRUCTION_FORMAT22c_TYPE_in_insn_format22c_type4742); 12102 stream_INSTRUCTION_FORMAT22c_TYPE.add(INSTRUCTION_FORMAT22c_TYPE357); 12103 12104 REGISTER358=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_type4744); 12105 stream_REGISTER.add(REGISTER358); 12106 12107 COMMA359=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_type4746); 12108 stream_COMMA.add(COMMA359); 12109 12110 REGISTER360=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_type4748); 12111 stream_REGISTER.add(REGISTER360); 12112 12113 COMMA361=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_type4750); 12114 stream_COMMA.add(COMMA361); 12115 12116 pushFollow(FOLLOW_nonvoid_type_descriptor_in_insn_format22c_type4752); 12117 nonvoid_type_descriptor362=nonvoid_type_descriptor(); 12118 state._fsp--; 12119 12120 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor362.getTree()); 12121 // AST REWRITE 12122 // elements: REGISTER, REGISTER, nonvoid_type_descriptor, INSTRUCTION_FORMAT22c_TYPE 12123 // token labels: 12124 // rule labels: retval 12125 // token list labels: 12126 // rule list labels: 12127 // wildcard labels: 12128 retval.tree = root_0; 12129 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12130 12131 root_0 = (CommonTree)adaptor.nil(); 12132 // 965:5: -> ^( I_STATEMENT_FORMAT22c_TYPE[$start, \"I_STATEMENT_FORMAT22c_TYPE\"] INSTRUCTION_FORMAT22c_TYPE REGISTER REGISTER nonvoid_type_descriptor ) 12133 { 12134 // smaliParser.g:965:8: ^( I_STATEMENT_FORMAT22c_TYPE[$start, \"I_STATEMENT_FORMAT22c_TYPE\"] INSTRUCTION_FORMAT22c_TYPE REGISTER REGISTER nonvoid_type_descriptor ) 12135 { 12136 CommonTree root_1 = (CommonTree)adaptor.nil(); 12137 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22c_TYPE, (retval.start), "I_STATEMENT_FORMAT22c_TYPE"), root_1); 12138 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22c_TYPE.nextNode()); 12139 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12140 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12141 adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree()); 12142 adaptor.addChild(root_0, root_1); 12143 } 12144 12145 } 12146 12147 12148 retval.tree = root_0; 12149 12150 } 12151 12152 retval.stop = input.LT(-1); 12153 12154 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12155 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12156 12157 } 12158 catch (RecognitionException re) { 12159 reportError(re); 12160 recover(input,re); 12161 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12162 } 12163 finally { 12164 // do for sure before leaving 12165 } 12166 return retval; 12167 } 12168 // $ANTLR end "insn_format22c_type" 12169 12170 12171 public static class insn_format22cs_field_return extends ParserRuleReturnScope { 12172 CommonTree tree; 12173 @Override 12174 public CommonTree getTree() { return tree; } 12175 }; 12176 12177 12178 // $ANTLR start "insn_format22cs_field" 12179 // smaliParser.g:967:1: insn_format22cs_field : INSTRUCTION_FORMAT22cs_FIELD REGISTER COMMA REGISTER COMMA FIELD_OFFSET ; 12180 public final smaliParser.insn_format22cs_field_return insn_format22cs_field() throws RecognitionException { 12181 smaliParser.insn_format22cs_field_return retval = new smaliParser.insn_format22cs_field_return(); 12182 retval.start = input.LT(1); 12183 12184 CommonTree root_0 = null; 12185 12186 Token INSTRUCTION_FORMAT22cs_FIELD363=null; 12187 Token REGISTER364=null; 12188 Token COMMA365=null; 12189 Token REGISTER366=null; 12190 Token COMMA367=null; 12191 Token FIELD_OFFSET368=null; 12192 12193 CommonTree INSTRUCTION_FORMAT22cs_FIELD363_tree=null; 12194 CommonTree REGISTER364_tree=null; 12195 CommonTree COMMA365_tree=null; 12196 CommonTree REGISTER366_tree=null; 12197 CommonTree COMMA367_tree=null; 12198 CommonTree FIELD_OFFSET368_tree=null; 12199 12200 try { 12201 // smaliParser.g:968:3: ( INSTRUCTION_FORMAT22cs_FIELD REGISTER COMMA REGISTER COMMA FIELD_OFFSET ) 12202 // smaliParser.g:969:5: INSTRUCTION_FORMAT22cs_FIELD REGISTER COMMA REGISTER COMMA FIELD_OFFSET 12203 { 12204 root_0 = (CommonTree)adaptor.nil(); 12205 12206 12207 INSTRUCTION_FORMAT22cs_FIELD363=(Token)match(input,INSTRUCTION_FORMAT22cs_FIELD,FOLLOW_INSTRUCTION_FORMAT22cs_FIELD_in_insn_format22cs_field4786); 12208 INSTRUCTION_FORMAT22cs_FIELD363_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT22cs_FIELD363); 12209 adaptor.addChild(root_0, INSTRUCTION_FORMAT22cs_FIELD363_tree); 12210 12211 REGISTER364=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22cs_field4788); 12212 REGISTER364_tree = (CommonTree)adaptor.create(REGISTER364); 12213 adaptor.addChild(root_0, REGISTER364_tree); 12214 12215 COMMA365=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22cs_field4790); 12216 COMMA365_tree = (CommonTree)adaptor.create(COMMA365); 12217 adaptor.addChild(root_0, COMMA365_tree); 12218 12219 REGISTER366=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22cs_field4792); 12220 REGISTER366_tree = (CommonTree)adaptor.create(REGISTER366); 12221 adaptor.addChild(root_0, REGISTER366_tree); 12222 12223 COMMA367=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22cs_field4794); 12224 COMMA367_tree = (CommonTree)adaptor.create(COMMA367); 12225 adaptor.addChild(root_0, COMMA367_tree); 12226 12227 FIELD_OFFSET368=(Token)match(input,FIELD_OFFSET,FOLLOW_FIELD_OFFSET_in_insn_format22cs_field4796); 12228 FIELD_OFFSET368_tree = (CommonTree)adaptor.create(FIELD_OFFSET368); 12229 adaptor.addChild(root_0, FIELD_OFFSET368_tree); 12230 12231 12232 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT22cs_FIELD363!=null?INSTRUCTION_FORMAT22cs_FIELD363.getText():null)); 12233 12234 } 12235 12236 retval.stop = input.LT(-1); 12237 12238 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12239 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12240 12241 } 12242 catch (RecognitionException re) { 12243 reportError(re); 12244 recover(input,re); 12245 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12246 } 12247 finally { 12248 // do for sure before leaving 12249 } 12250 return retval; 12251 } 12252 // $ANTLR end "insn_format22cs_field" 12253 12254 12255 public static class insn_format22s_return extends ParserRuleReturnScope { 12256 CommonTree tree; 12257 @Override 12258 public CommonTree getTree() { return tree; } 12259 }; 12260 12261 12262 // $ANTLR start "insn_format22s" 12263 // smaliParser.g:974:1: insn_format22s : instruction_format22s REGISTER COMMA REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT22s[$start, \"I_STATEMENT_FORMAT22s\"] instruction_format22s REGISTER REGISTER integral_literal ) ; 12264 public final smaliParser.insn_format22s_return insn_format22s() throws RecognitionException { 12265 smaliParser.insn_format22s_return retval = new smaliParser.insn_format22s_return(); 12266 retval.start = input.LT(1); 12267 12268 CommonTree root_0 = null; 12269 12270 Token REGISTER370=null; 12271 Token COMMA371=null; 12272 Token REGISTER372=null; 12273 Token COMMA373=null; 12274 ParserRuleReturnScope instruction_format22s369 =null; 12275 ParserRuleReturnScope integral_literal374 =null; 12276 12277 CommonTree REGISTER370_tree=null; 12278 CommonTree COMMA371_tree=null; 12279 CommonTree REGISTER372_tree=null; 12280 CommonTree COMMA373_tree=null; 12281 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12282 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 12283 RewriteRuleSubtreeStream stream_instruction_format22s=new RewriteRuleSubtreeStream(adaptor,"rule instruction_format22s"); 12284 RewriteRuleSubtreeStream stream_integral_literal=new RewriteRuleSubtreeStream(adaptor,"rule integral_literal"); 12285 12286 try { 12287 // smaliParser.g:975:3: ( instruction_format22s REGISTER COMMA REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT22s[$start, \"I_STATEMENT_FORMAT22s\"] instruction_format22s REGISTER REGISTER integral_literal ) ) 12288 // smaliParser.g:976:5: instruction_format22s REGISTER COMMA REGISTER COMMA integral_literal 12289 { 12290 pushFollow(FOLLOW_instruction_format22s_in_insn_format22s4817); 12291 instruction_format22s369=instruction_format22s(); 12292 state._fsp--; 12293 12294 stream_instruction_format22s.add(instruction_format22s369.getTree()); 12295 REGISTER370=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22s4819); 12296 stream_REGISTER.add(REGISTER370); 12297 12298 COMMA371=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22s4821); 12299 stream_COMMA.add(COMMA371); 12300 12301 REGISTER372=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22s4823); 12302 stream_REGISTER.add(REGISTER372); 12303 12304 COMMA373=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22s4825); 12305 stream_COMMA.add(COMMA373); 12306 12307 pushFollow(FOLLOW_integral_literal_in_insn_format22s4827); 12308 integral_literal374=integral_literal(); 12309 state._fsp--; 12310 12311 stream_integral_literal.add(integral_literal374.getTree()); 12312 // AST REWRITE 12313 // elements: REGISTER, REGISTER, instruction_format22s, integral_literal 12314 // token labels: 12315 // rule labels: retval 12316 // token list labels: 12317 // rule list labels: 12318 // wildcard labels: 12319 retval.tree = root_0; 12320 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12321 12322 root_0 = (CommonTree)adaptor.nil(); 12323 // 977:5: -> ^( I_STATEMENT_FORMAT22s[$start, \"I_STATEMENT_FORMAT22s\"] instruction_format22s REGISTER REGISTER integral_literal ) 12324 { 12325 // smaliParser.g:977:8: ^( I_STATEMENT_FORMAT22s[$start, \"I_STATEMENT_FORMAT22s\"] instruction_format22s REGISTER REGISTER integral_literal ) 12326 { 12327 CommonTree root_1 = (CommonTree)adaptor.nil(); 12328 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22s, (retval.start), "I_STATEMENT_FORMAT22s"), root_1); 12329 adaptor.addChild(root_1, stream_instruction_format22s.nextTree()); 12330 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12331 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12332 adaptor.addChild(root_1, stream_integral_literal.nextTree()); 12333 adaptor.addChild(root_0, root_1); 12334 } 12335 12336 } 12337 12338 12339 retval.tree = root_0; 12340 12341 } 12342 12343 retval.stop = input.LT(-1); 12344 12345 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12346 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12347 12348 } 12349 catch (RecognitionException re) { 12350 reportError(re); 12351 recover(input,re); 12352 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12353 } 12354 finally { 12355 // do for sure before leaving 12356 } 12357 return retval; 12358 } 12359 // $ANTLR end "insn_format22s" 12360 12361 12362 public static class insn_format22t_return extends ParserRuleReturnScope { 12363 CommonTree tree; 12364 @Override 12365 public CommonTree getTree() { return tree; } 12366 }; 12367 12368 12369 // $ANTLR start "insn_format22t" 12370 // smaliParser.g:979:1: insn_format22t : INSTRUCTION_FORMAT22t REGISTER COMMA REGISTER COMMA label_ref -> ^( I_STATEMENT_FORMAT22t[$start, \"I_STATEMENT_FFORMAT22t\"] INSTRUCTION_FORMAT22t REGISTER REGISTER label_ref ) ; 12371 public final smaliParser.insn_format22t_return insn_format22t() throws RecognitionException { 12372 smaliParser.insn_format22t_return retval = new smaliParser.insn_format22t_return(); 12373 retval.start = input.LT(1); 12374 12375 CommonTree root_0 = null; 12376 12377 Token INSTRUCTION_FORMAT22t375=null; 12378 Token REGISTER376=null; 12379 Token COMMA377=null; 12380 Token REGISTER378=null; 12381 Token COMMA379=null; 12382 ParserRuleReturnScope label_ref380 =null; 12383 12384 CommonTree INSTRUCTION_FORMAT22t375_tree=null; 12385 CommonTree REGISTER376_tree=null; 12386 CommonTree COMMA377_tree=null; 12387 CommonTree REGISTER378_tree=null; 12388 CommonTree COMMA379_tree=null; 12389 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12390 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 12391 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22t"); 12392 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 12393 12394 try { 12395 // smaliParser.g:980:3: ( INSTRUCTION_FORMAT22t REGISTER COMMA REGISTER COMMA label_ref -> ^( I_STATEMENT_FORMAT22t[$start, \"I_STATEMENT_FFORMAT22t\"] INSTRUCTION_FORMAT22t REGISTER REGISTER label_ref ) ) 12396 // smaliParser.g:981:5: INSTRUCTION_FORMAT22t REGISTER COMMA REGISTER COMMA label_ref 12397 { 12398 INSTRUCTION_FORMAT22t375=(Token)match(input,INSTRUCTION_FORMAT22t,FOLLOW_INSTRUCTION_FORMAT22t_in_insn_format22t4861); 12399 stream_INSTRUCTION_FORMAT22t.add(INSTRUCTION_FORMAT22t375); 12400 12401 REGISTER376=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22t4863); 12402 stream_REGISTER.add(REGISTER376); 12403 12404 COMMA377=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22t4865); 12405 stream_COMMA.add(COMMA377); 12406 12407 REGISTER378=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22t4867); 12408 stream_REGISTER.add(REGISTER378); 12409 12410 COMMA379=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22t4869); 12411 stream_COMMA.add(COMMA379); 12412 12413 pushFollow(FOLLOW_label_ref_in_insn_format22t4871); 12414 label_ref380=label_ref(); 12415 state._fsp--; 12416 12417 stream_label_ref.add(label_ref380.getTree()); 12418 // AST REWRITE 12419 // elements: REGISTER, INSTRUCTION_FORMAT22t, REGISTER, label_ref 12420 // token labels: 12421 // rule labels: retval 12422 // token list labels: 12423 // rule list labels: 12424 // wildcard labels: 12425 retval.tree = root_0; 12426 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12427 12428 root_0 = (CommonTree)adaptor.nil(); 12429 // 982:5: -> ^( I_STATEMENT_FORMAT22t[$start, \"I_STATEMENT_FFORMAT22t\"] INSTRUCTION_FORMAT22t REGISTER REGISTER label_ref ) 12430 { 12431 // smaliParser.g:982:8: ^( I_STATEMENT_FORMAT22t[$start, \"I_STATEMENT_FFORMAT22t\"] INSTRUCTION_FORMAT22t REGISTER REGISTER label_ref ) 12432 { 12433 CommonTree root_1 = (CommonTree)adaptor.nil(); 12434 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22t, (retval.start), "I_STATEMENT_FFORMAT22t"), root_1); 12435 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22t.nextNode()); 12436 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12437 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12438 adaptor.addChild(root_1, stream_label_ref.nextTree()); 12439 adaptor.addChild(root_0, root_1); 12440 } 12441 12442 } 12443 12444 12445 retval.tree = root_0; 12446 12447 } 12448 12449 retval.stop = input.LT(-1); 12450 12451 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12452 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12453 12454 } 12455 catch (RecognitionException re) { 12456 reportError(re); 12457 recover(input,re); 12458 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12459 } 12460 finally { 12461 // do for sure before leaving 12462 } 12463 return retval; 12464 } 12465 // $ANTLR end "insn_format22t" 12466 12467 12468 public static class insn_format22x_return extends ParserRuleReturnScope { 12469 CommonTree tree; 12470 @Override 12471 public CommonTree getTree() { return tree; } 12472 }; 12473 12474 12475 // $ANTLR start "insn_format22x" 12476 // smaliParser.g:984:1: insn_format22x : INSTRUCTION_FORMAT22x REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT22x[$start, \"I_STATEMENT_FORMAT22x\"] INSTRUCTION_FORMAT22x REGISTER REGISTER ) ; 12477 public final smaliParser.insn_format22x_return insn_format22x() throws RecognitionException { 12478 smaliParser.insn_format22x_return retval = new smaliParser.insn_format22x_return(); 12479 retval.start = input.LT(1); 12480 12481 CommonTree root_0 = null; 12482 12483 Token INSTRUCTION_FORMAT22x381=null; 12484 Token REGISTER382=null; 12485 Token COMMA383=null; 12486 Token REGISTER384=null; 12487 12488 CommonTree INSTRUCTION_FORMAT22x381_tree=null; 12489 CommonTree REGISTER382_tree=null; 12490 CommonTree COMMA383_tree=null; 12491 CommonTree REGISTER384_tree=null; 12492 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12493 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 12494 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22x"); 12495 12496 try { 12497 // smaliParser.g:985:3: ( INSTRUCTION_FORMAT22x REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT22x[$start, \"I_STATEMENT_FORMAT22x\"] INSTRUCTION_FORMAT22x REGISTER REGISTER ) ) 12498 // smaliParser.g:986:5: INSTRUCTION_FORMAT22x REGISTER COMMA REGISTER 12499 { 12500 INSTRUCTION_FORMAT22x381=(Token)match(input,INSTRUCTION_FORMAT22x,FOLLOW_INSTRUCTION_FORMAT22x_in_insn_format22x4905); 12501 stream_INSTRUCTION_FORMAT22x.add(INSTRUCTION_FORMAT22x381); 12502 12503 REGISTER382=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22x4907); 12504 stream_REGISTER.add(REGISTER382); 12505 12506 COMMA383=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22x4909); 12507 stream_COMMA.add(COMMA383); 12508 12509 REGISTER384=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22x4911); 12510 stream_REGISTER.add(REGISTER384); 12511 12512 // AST REWRITE 12513 // elements: REGISTER, REGISTER, INSTRUCTION_FORMAT22x 12514 // token labels: 12515 // rule labels: retval 12516 // token list labels: 12517 // rule list labels: 12518 // wildcard labels: 12519 retval.tree = root_0; 12520 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12521 12522 root_0 = (CommonTree)adaptor.nil(); 12523 // 987:5: -> ^( I_STATEMENT_FORMAT22x[$start, \"I_STATEMENT_FORMAT22x\"] INSTRUCTION_FORMAT22x REGISTER REGISTER ) 12524 { 12525 // smaliParser.g:987:8: ^( I_STATEMENT_FORMAT22x[$start, \"I_STATEMENT_FORMAT22x\"] INSTRUCTION_FORMAT22x REGISTER REGISTER ) 12526 { 12527 CommonTree root_1 = (CommonTree)adaptor.nil(); 12528 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22x, (retval.start), "I_STATEMENT_FORMAT22x"), root_1); 12529 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22x.nextNode()); 12530 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12531 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12532 adaptor.addChild(root_0, root_1); 12533 } 12534 12535 } 12536 12537 12538 retval.tree = root_0; 12539 12540 } 12541 12542 retval.stop = input.LT(-1); 12543 12544 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12545 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12546 12547 } 12548 catch (RecognitionException re) { 12549 reportError(re); 12550 recover(input,re); 12551 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12552 } 12553 finally { 12554 // do for sure before leaving 12555 } 12556 return retval; 12557 } 12558 // $ANTLR end "insn_format22x" 12559 12560 12561 public static class insn_format23x_return extends ParserRuleReturnScope { 12562 CommonTree tree; 12563 @Override 12564 public CommonTree getTree() { return tree; } 12565 }; 12566 12567 12568 // $ANTLR start "insn_format23x" 12569 // smaliParser.g:989:1: insn_format23x : INSTRUCTION_FORMAT23x REGISTER COMMA REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT23x[$start, \"I_STATEMENT_FORMAT23x\"] INSTRUCTION_FORMAT23x REGISTER REGISTER REGISTER ) ; 12570 public final smaliParser.insn_format23x_return insn_format23x() throws RecognitionException { 12571 smaliParser.insn_format23x_return retval = new smaliParser.insn_format23x_return(); 12572 retval.start = input.LT(1); 12573 12574 CommonTree root_0 = null; 12575 12576 Token INSTRUCTION_FORMAT23x385=null; 12577 Token REGISTER386=null; 12578 Token COMMA387=null; 12579 Token REGISTER388=null; 12580 Token COMMA389=null; 12581 Token REGISTER390=null; 12582 12583 CommonTree INSTRUCTION_FORMAT23x385_tree=null; 12584 CommonTree REGISTER386_tree=null; 12585 CommonTree COMMA387_tree=null; 12586 CommonTree REGISTER388_tree=null; 12587 CommonTree COMMA389_tree=null; 12588 CommonTree REGISTER390_tree=null; 12589 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12590 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 12591 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT23x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT23x"); 12592 12593 try { 12594 // smaliParser.g:990:3: ( INSTRUCTION_FORMAT23x REGISTER COMMA REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT23x[$start, \"I_STATEMENT_FORMAT23x\"] INSTRUCTION_FORMAT23x REGISTER REGISTER REGISTER ) ) 12595 // smaliParser.g:991:5: INSTRUCTION_FORMAT23x REGISTER COMMA REGISTER COMMA REGISTER 12596 { 12597 INSTRUCTION_FORMAT23x385=(Token)match(input,INSTRUCTION_FORMAT23x,FOLLOW_INSTRUCTION_FORMAT23x_in_insn_format23x4943); 12598 stream_INSTRUCTION_FORMAT23x.add(INSTRUCTION_FORMAT23x385); 12599 12600 REGISTER386=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format23x4945); 12601 stream_REGISTER.add(REGISTER386); 12602 12603 COMMA387=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format23x4947); 12604 stream_COMMA.add(COMMA387); 12605 12606 REGISTER388=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format23x4949); 12607 stream_REGISTER.add(REGISTER388); 12608 12609 COMMA389=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format23x4951); 12610 stream_COMMA.add(COMMA389); 12611 12612 REGISTER390=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format23x4953); 12613 stream_REGISTER.add(REGISTER390); 12614 12615 // AST REWRITE 12616 // elements: REGISTER, REGISTER, INSTRUCTION_FORMAT23x, REGISTER 12617 // token labels: 12618 // rule labels: retval 12619 // token list labels: 12620 // rule list labels: 12621 // wildcard labels: 12622 retval.tree = root_0; 12623 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12624 12625 root_0 = (CommonTree)adaptor.nil(); 12626 // 992:5: -> ^( I_STATEMENT_FORMAT23x[$start, \"I_STATEMENT_FORMAT23x\"] INSTRUCTION_FORMAT23x REGISTER REGISTER REGISTER ) 12627 { 12628 // smaliParser.g:992:8: ^( I_STATEMENT_FORMAT23x[$start, \"I_STATEMENT_FORMAT23x\"] INSTRUCTION_FORMAT23x REGISTER REGISTER REGISTER ) 12629 { 12630 CommonTree root_1 = (CommonTree)adaptor.nil(); 12631 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT23x, (retval.start), "I_STATEMENT_FORMAT23x"), root_1); 12632 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT23x.nextNode()); 12633 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12634 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12635 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12636 adaptor.addChild(root_0, root_1); 12637 } 12638 12639 } 12640 12641 12642 retval.tree = root_0; 12643 12644 } 12645 12646 retval.stop = input.LT(-1); 12647 12648 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12649 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12650 12651 } 12652 catch (RecognitionException re) { 12653 reportError(re); 12654 recover(input,re); 12655 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12656 } 12657 finally { 12658 // do for sure before leaving 12659 } 12660 return retval; 12661 } 12662 // $ANTLR end "insn_format23x" 12663 12664 12665 public static class insn_format30t_return extends ParserRuleReturnScope { 12666 CommonTree tree; 12667 @Override 12668 public CommonTree getTree() { return tree; } 12669 }; 12670 12671 12672 // $ANTLR start "insn_format30t" 12673 // smaliParser.g:994:1: insn_format30t : INSTRUCTION_FORMAT30t label_ref -> ^( I_STATEMENT_FORMAT30t[$start, \"I_STATEMENT_FORMAT30t\"] INSTRUCTION_FORMAT30t label_ref ) ; 12674 public final smaliParser.insn_format30t_return insn_format30t() throws RecognitionException { 12675 smaliParser.insn_format30t_return retval = new smaliParser.insn_format30t_return(); 12676 retval.start = input.LT(1); 12677 12678 CommonTree root_0 = null; 12679 12680 Token INSTRUCTION_FORMAT30t391=null; 12681 ParserRuleReturnScope label_ref392 =null; 12682 12683 CommonTree INSTRUCTION_FORMAT30t391_tree=null; 12684 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT30t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT30t"); 12685 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 12686 12687 try { 12688 // smaliParser.g:995:3: ( INSTRUCTION_FORMAT30t label_ref -> ^( I_STATEMENT_FORMAT30t[$start, \"I_STATEMENT_FORMAT30t\"] INSTRUCTION_FORMAT30t label_ref ) ) 12689 // smaliParser.g:996:5: INSTRUCTION_FORMAT30t label_ref 12690 { 12691 INSTRUCTION_FORMAT30t391=(Token)match(input,INSTRUCTION_FORMAT30t,FOLLOW_INSTRUCTION_FORMAT30t_in_insn_format30t4987); 12692 stream_INSTRUCTION_FORMAT30t.add(INSTRUCTION_FORMAT30t391); 12693 12694 pushFollow(FOLLOW_label_ref_in_insn_format30t4989); 12695 label_ref392=label_ref(); 12696 state._fsp--; 12697 12698 stream_label_ref.add(label_ref392.getTree()); 12699 // AST REWRITE 12700 // elements: INSTRUCTION_FORMAT30t, label_ref 12701 // token labels: 12702 // rule labels: retval 12703 // token list labels: 12704 // rule list labels: 12705 // wildcard labels: 12706 retval.tree = root_0; 12707 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12708 12709 root_0 = (CommonTree)adaptor.nil(); 12710 // 997:5: -> ^( I_STATEMENT_FORMAT30t[$start, \"I_STATEMENT_FORMAT30t\"] INSTRUCTION_FORMAT30t label_ref ) 12711 { 12712 // smaliParser.g:997:8: ^( I_STATEMENT_FORMAT30t[$start, \"I_STATEMENT_FORMAT30t\"] INSTRUCTION_FORMAT30t label_ref ) 12713 { 12714 CommonTree root_1 = (CommonTree)adaptor.nil(); 12715 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT30t, (retval.start), "I_STATEMENT_FORMAT30t"), root_1); 12716 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT30t.nextNode()); 12717 adaptor.addChild(root_1, stream_label_ref.nextTree()); 12718 adaptor.addChild(root_0, root_1); 12719 } 12720 12721 } 12722 12723 12724 retval.tree = root_0; 12725 12726 } 12727 12728 retval.stop = input.LT(-1); 12729 12730 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12731 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12732 12733 } 12734 catch (RecognitionException re) { 12735 reportError(re); 12736 recover(input,re); 12737 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12738 } 12739 finally { 12740 // do for sure before leaving 12741 } 12742 return retval; 12743 } 12744 // $ANTLR end "insn_format30t" 12745 12746 12747 public static class insn_format31c_return extends ParserRuleReturnScope { 12748 CommonTree tree; 12749 @Override 12750 public CommonTree getTree() { return tree; } 12751 }; 12752 12753 12754 // $ANTLR start "insn_format31c" 12755 // smaliParser.g:999:1: insn_format31c : INSTRUCTION_FORMAT31c REGISTER COMMA STRING_LITERAL -> ^( I_STATEMENT_FORMAT31c[$start, \"I_STATEMENT_FORMAT31c\"] INSTRUCTION_FORMAT31c REGISTER STRING_LITERAL ) ; 12756 public final smaliParser.insn_format31c_return insn_format31c() throws RecognitionException { 12757 smaliParser.insn_format31c_return retval = new smaliParser.insn_format31c_return(); 12758 retval.start = input.LT(1); 12759 12760 CommonTree root_0 = null; 12761 12762 Token INSTRUCTION_FORMAT31c393=null; 12763 Token REGISTER394=null; 12764 Token COMMA395=null; 12765 Token STRING_LITERAL396=null; 12766 12767 CommonTree INSTRUCTION_FORMAT31c393_tree=null; 12768 CommonTree REGISTER394_tree=null; 12769 CommonTree COMMA395_tree=null; 12770 CommonTree STRING_LITERAL396_tree=null; 12771 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12772 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 12773 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT31c=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT31c"); 12774 RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL"); 12775 12776 try { 12777 // smaliParser.g:1000:3: ( INSTRUCTION_FORMAT31c REGISTER COMMA STRING_LITERAL -> ^( I_STATEMENT_FORMAT31c[$start, \"I_STATEMENT_FORMAT31c\"] INSTRUCTION_FORMAT31c REGISTER STRING_LITERAL ) ) 12778 // smaliParser.g:1001:5: INSTRUCTION_FORMAT31c REGISTER COMMA STRING_LITERAL 12779 { 12780 INSTRUCTION_FORMAT31c393=(Token)match(input,INSTRUCTION_FORMAT31c,FOLLOW_INSTRUCTION_FORMAT31c_in_insn_format31c5019); 12781 stream_INSTRUCTION_FORMAT31c.add(INSTRUCTION_FORMAT31c393); 12782 12783 REGISTER394=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format31c5021); 12784 stream_REGISTER.add(REGISTER394); 12785 12786 COMMA395=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format31c5023); 12787 stream_COMMA.add(COMMA395); 12788 12789 STRING_LITERAL396=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_insn_format31c5025); 12790 stream_STRING_LITERAL.add(STRING_LITERAL396); 12791 12792 // AST REWRITE 12793 // elements: REGISTER, STRING_LITERAL, INSTRUCTION_FORMAT31c 12794 // token labels: 12795 // rule labels: retval 12796 // token list labels: 12797 // rule list labels: 12798 // wildcard labels: 12799 retval.tree = root_0; 12800 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12801 12802 root_0 = (CommonTree)adaptor.nil(); 12803 // 1002:5: -> ^( I_STATEMENT_FORMAT31c[$start, \"I_STATEMENT_FORMAT31c\"] INSTRUCTION_FORMAT31c REGISTER STRING_LITERAL ) 12804 { 12805 // smaliParser.g:1002:7: ^( I_STATEMENT_FORMAT31c[$start, \"I_STATEMENT_FORMAT31c\"] INSTRUCTION_FORMAT31c REGISTER STRING_LITERAL ) 12806 { 12807 CommonTree root_1 = (CommonTree)adaptor.nil(); 12808 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT31c, (retval.start), "I_STATEMENT_FORMAT31c"), root_1); 12809 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT31c.nextNode()); 12810 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12811 adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode()); 12812 adaptor.addChild(root_0, root_1); 12813 } 12814 12815 } 12816 12817 12818 retval.tree = root_0; 12819 12820 } 12821 12822 retval.stop = input.LT(-1); 12823 12824 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12825 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12826 12827 } 12828 catch (RecognitionException re) { 12829 reportError(re); 12830 recover(input,re); 12831 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12832 } 12833 finally { 12834 // do for sure before leaving 12835 } 12836 return retval; 12837 } 12838 // $ANTLR end "insn_format31c" 12839 12840 12841 public static class insn_format31i_return extends ParserRuleReturnScope { 12842 CommonTree tree; 12843 @Override 12844 public CommonTree getTree() { return tree; } 12845 }; 12846 12847 12848 // $ANTLR start "insn_format31i" 12849 // smaliParser.g:1004:1: insn_format31i : instruction_format31i REGISTER COMMA fixed_32bit_literal -> ^( I_STATEMENT_FORMAT31i[$start, \"I_STATEMENT_FORMAT31i\"] instruction_format31i REGISTER fixed_32bit_literal ) ; 12850 public final smaliParser.insn_format31i_return insn_format31i() throws RecognitionException { 12851 smaliParser.insn_format31i_return retval = new smaliParser.insn_format31i_return(); 12852 retval.start = input.LT(1); 12853 12854 CommonTree root_0 = null; 12855 12856 Token REGISTER398=null; 12857 Token COMMA399=null; 12858 ParserRuleReturnScope instruction_format31i397 =null; 12859 ParserRuleReturnScope fixed_32bit_literal400 =null; 12860 12861 CommonTree REGISTER398_tree=null; 12862 CommonTree COMMA399_tree=null; 12863 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12864 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 12865 RewriteRuleSubtreeStream stream_fixed_32bit_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_32bit_literal"); 12866 RewriteRuleSubtreeStream stream_instruction_format31i=new RewriteRuleSubtreeStream(adaptor,"rule instruction_format31i"); 12867 12868 try { 12869 // smaliParser.g:1005:3: ( instruction_format31i REGISTER COMMA fixed_32bit_literal -> ^( I_STATEMENT_FORMAT31i[$start, \"I_STATEMENT_FORMAT31i\"] instruction_format31i REGISTER fixed_32bit_literal ) ) 12870 // smaliParser.g:1006:5: instruction_format31i REGISTER COMMA fixed_32bit_literal 12871 { 12872 pushFollow(FOLLOW_instruction_format31i_in_insn_format31i5056); 12873 instruction_format31i397=instruction_format31i(); 12874 state._fsp--; 12875 12876 stream_instruction_format31i.add(instruction_format31i397.getTree()); 12877 REGISTER398=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format31i5058); 12878 stream_REGISTER.add(REGISTER398); 12879 12880 COMMA399=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format31i5060); 12881 stream_COMMA.add(COMMA399); 12882 12883 pushFollow(FOLLOW_fixed_32bit_literal_in_insn_format31i5062); 12884 fixed_32bit_literal400=fixed_32bit_literal(); 12885 state._fsp--; 12886 12887 stream_fixed_32bit_literal.add(fixed_32bit_literal400.getTree()); 12888 // AST REWRITE 12889 // elements: instruction_format31i, REGISTER, fixed_32bit_literal 12890 // token labels: 12891 // rule labels: retval 12892 // token list labels: 12893 // rule list labels: 12894 // wildcard labels: 12895 retval.tree = root_0; 12896 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12897 12898 root_0 = (CommonTree)adaptor.nil(); 12899 // 1007:5: -> ^( I_STATEMENT_FORMAT31i[$start, \"I_STATEMENT_FORMAT31i\"] instruction_format31i REGISTER fixed_32bit_literal ) 12900 { 12901 // smaliParser.g:1007:8: ^( I_STATEMENT_FORMAT31i[$start, \"I_STATEMENT_FORMAT31i\"] instruction_format31i REGISTER fixed_32bit_literal ) 12902 { 12903 CommonTree root_1 = (CommonTree)adaptor.nil(); 12904 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT31i, (retval.start), "I_STATEMENT_FORMAT31i"), root_1); 12905 adaptor.addChild(root_1, stream_instruction_format31i.nextTree()); 12906 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12907 adaptor.addChild(root_1, stream_fixed_32bit_literal.nextTree()); 12908 adaptor.addChild(root_0, root_1); 12909 } 12910 12911 } 12912 12913 12914 retval.tree = root_0; 12915 12916 } 12917 12918 retval.stop = input.LT(-1); 12919 12920 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12921 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12922 12923 } 12924 catch (RecognitionException re) { 12925 reportError(re); 12926 recover(input,re); 12927 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12928 } 12929 finally { 12930 // do for sure before leaving 12931 } 12932 return retval; 12933 } 12934 // $ANTLR end "insn_format31i" 12935 12936 12937 public static class insn_format31t_return extends ParserRuleReturnScope { 12938 CommonTree tree; 12939 @Override 12940 public CommonTree getTree() { return tree; } 12941 }; 12942 12943 12944 // $ANTLR start "insn_format31t" 12945 // smaliParser.g:1009:1: insn_format31t : INSTRUCTION_FORMAT31t REGISTER COMMA label_ref -> ^( I_STATEMENT_FORMAT31t[$start, \"I_STATEMENT_FORMAT31t\"] INSTRUCTION_FORMAT31t REGISTER label_ref ) ; 12946 public final smaliParser.insn_format31t_return insn_format31t() throws RecognitionException { 12947 smaliParser.insn_format31t_return retval = new smaliParser.insn_format31t_return(); 12948 retval.start = input.LT(1); 12949 12950 CommonTree root_0 = null; 12951 12952 Token INSTRUCTION_FORMAT31t401=null; 12953 Token REGISTER402=null; 12954 Token COMMA403=null; 12955 ParserRuleReturnScope label_ref404 =null; 12956 12957 CommonTree INSTRUCTION_FORMAT31t401_tree=null; 12958 CommonTree REGISTER402_tree=null; 12959 CommonTree COMMA403_tree=null; 12960 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12961 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 12962 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT31t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT31t"); 12963 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 12964 12965 try { 12966 // smaliParser.g:1010:3: ( INSTRUCTION_FORMAT31t REGISTER COMMA label_ref -> ^( I_STATEMENT_FORMAT31t[$start, \"I_STATEMENT_FORMAT31t\"] INSTRUCTION_FORMAT31t REGISTER label_ref ) ) 12967 // smaliParser.g:1011:5: INSTRUCTION_FORMAT31t REGISTER COMMA label_ref 12968 { 12969 INSTRUCTION_FORMAT31t401=(Token)match(input,INSTRUCTION_FORMAT31t,FOLLOW_INSTRUCTION_FORMAT31t_in_insn_format31t5094); 12970 stream_INSTRUCTION_FORMAT31t.add(INSTRUCTION_FORMAT31t401); 12971 12972 REGISTER402=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format31t5096); 12973 stream_REGISTER.add(REGISTER402); 12974 12975 COMMA403=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format31t5098); 12976 stream_COMMA.add(COMMA403); 12977 12978 pushFollow(FOLLOW_label_ref_in_insn_format31t5100); 12979 label_ref404=label_ref(); 12980 state._fsp--; 12981 12982 stream_label_ref.add(label_ref404.getTree()); 12983 // AST REWRITE 12984 // elements: INSTRUCTION_FORMAT31t, REGISTER, label_ref 12985 // token labels: 12986 // rule labels: retval 12987 // token list labels: 12988 // rule list labels: 12989 // wildcard labels: 12990 retval.tree = root_0; 12991 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12992 12993 root_0 = (CommonTree)adaptor.nil(); 12994 // 1012:5: -> ^( I_STATEMENT_FORMAT31t[$start, \"I_STATEMENT_FORMAT31t\"] INSTRUCTION_FORMAT31t REGISTER label_ref ) 12995 { 12996 // smaliParser.g:1012:8: ^( I_STATEMENT_FORMAT31t[$start, \"I_STATEMENT_FORMAT31t\"] INSTRUCTION_FORMAT31t REGISTER label_ref ) 12997 { 12998 CommonTree root_1 = (CommonTree)adaptor.nil(); 12999 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT31t, (retval.start), "I_STATEMENT_FORMAT31t"), root_1); 13000 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT31t.nextNode()); 13001 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 13002 adaptor.addChild(root_1, stream_label_ref.nextTree()); 13003 adaptor.addChild(root_0, root_1); 13004 } 13005 13006 } 13007 13008 13009 retval.tree = root_0; 13010 13011 } 13012 13013 retval.stop = input.LT(-1); 13014 13015 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13016 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13017 13018 } 13019 catch (RecognitionException re) { 13020 reportError(re); 13021 recover(input,re); 13022 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13023 } 13024 finally { 13025 // do for sure before leaving 13026 } 13027 return retval; 13028 } 13029 // $ANTLR end "insn_format31t" 13030 13031 13032 public static class insn_format32x_return extends ParserRuleReturnScope { 13033 CommonTree tree; 13034 @Override 13035 public CommonTree getTree() { return tree; } 13036 }; 13037 13038 13039 // $ANTLR start "insn_format32x" 13040 // smaliParser.g:1014:1: insn_format32x : INSTRUCTION_FORMAT32x REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT32x[$start, \"I_STATEMENT_FORMAT32x\"] INSTRUCTION_FORMAT32x REGISTER REGISTER ) ; 13041 public final smaliParser.insn_format32x_return insn_format32x() throws RecognitionException { 13042 smaliParser.insn_format32x_return retval = new smaliParser.insn_format32x_return(); 13043 retval.start = input.LT(1); 13044 13045 CommonTree root_0 = null; 13046 13047 Token INSTRUCTION_FORMAT32x405=null; 13048 Token REGISTER406=null; 13049 Token COMMA407=null; 13050 Token REGISTER408=null; 13051 13052 CommonTree INSTRUCTION_FORMAT32x405_tree=null; 13053 CommonTree REGISTER406_tree=null; 13054 CommonTree COMMA407_tree=null; 13055 CommonTree REGISTER408_tree=null; 13056 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 13057 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 13058 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT32x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT32x"); 13059 13060 try { 13061 // smaliParser.g:1015:3: ( INSTRUCTION_FORMAT32x REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT32x[$start, \"I_STATEMENT_FORMAT32x\"] INSTRUCTION_FORMAT32x REGISTER REGISTER ) ) 13062 // smaliParser.g:1016:5: INSTRUCTION_FORMAT32x REGISTER COMMA REGISTER 13063 { 13064 INSTRUCTION_FORMAT32x405=(Token)match(input,INSTRUCTION_FORMAT32x,FOLLOW_INSTRUCTION_FORMAT32x_in_insn_format32x5132); 13065 stream_INSTRUCTION_FORMAT32x.add(INSTRUCTION_FORMAT32x405); 13066 13067 REGISTER406=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format32x5134); 13068 stream_REGISTER.add(REGISTER406); 13069 13070 COMMA407=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format32x5136); 13071 stream_COMMA.add(COMMA407); 13072 13073 REGISTER408=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format32x5138); 13074 stream_REGISTER.add(REGISTER408); 13075 13076 // AST REWRITE 13077 // elements: INSTRUCTION_FORMAT32x, REGISTER, REGISTER 13078 // token labels: 13079 // rule labels: retval 13080 // token list labels: 13081 // rule list labels: 13082 // wildcard labels: 13083 retval.tree = root_0; 13084 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 13085 13086 root_0 = (CommonTree)adaptor.nil(); 13087 // 1017:5: -> ^( I_STATEMENT_FORMAT32x[$start, \"I_STATEMENT_FORMAT32x\"] INSTRUCTION_FORMAT32x REGISTER REGISTER ) 13088 { 13089 // smaliParser.g:1017:8: ^( I_STATEMENT_FORMAT32x[$start, \"I_STATEMENT_FORMAT32x\"] INSTRUCTION_FORMAT32x REGISTER REGISTER ) 13090 { 13091 CommonTree root_1 = (CommonTree)adaptor.nil(); 13092 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT32x, (retval.start), "I_STATEMENT_FORMAT32x"), root_1); 13093 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT32x.nextNode()); 13094 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 13095 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 13096 adaptor.addChild(root_0, root_1); 13097 } 13098 13099 } 13100 13101 13102 retval.tree = root_0; 13103 13104 } 13105 13106 retval.stop = input.LT(-1); 13107 13108 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13109 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13110 13111 } 13112 catch (RecognitionException re) { 13113 reportError(re); 13114 recover(input,re); 13115 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13116 } 13117 finally { 13118 // do for sure before leaving 13119 } 13120 return retval; 13121 } 13122 // $ANTLR end "insn_format32x" 13123 13124 13125 public static class insn_format35c_method_return extends ParserRuleReturnScope { 13126 CommonTree tree; 13127 @Override 13128 public CommonTree getTree() { return tree; } 13129 }; 13130 13131 13132 // $ANTLR start "insn_format35c_method" 13133 // smaliParser.g:1019:1: insn_format35c_method : INSTRUCTION_FORMAT35c_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference -> ^( I_STATEMENT_FORMAT35c_METHOD[$start, \"I_STATEMENT_FORMAT35c_METHOD\"] INSTRUCTION_FORMAT35c_METHOD register_list method_reference ) ; 13134 public final smaliParser.insn_format35c_method_return insn_format35c_method() throws RecognitionException { 13135 smaliParser.insn_format35c_method_return retval = new smaliParser.insn_format35c_method_return(); 13136 retval.start = input.LT(1); 13137 13138 CommonTree root_0 = null; 13139 13140 Token INSTRUCTION_FORMAT35c_METHOD409=null; 13141 Token OPEN_BRACE410=null; 13142 Token CLOSE_BRACE412=null; 13143 Token COMMA413=null; 13144 ParserRuleReturnScope register_list411 =null; 13145 ParserRuleReturnScope method_reference414 =null; 13146 13147 CommonTree INSTRUCTION_FORMAT35c_METHOD409_tree=null; 13148 CommonTree OPEN_BRACE410_tree=null; 13149 CommonTree CLOSE_BRACE412_tree=null; 13150 CommonTree COMMA413_tree=null; 13151 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35c_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35c_METHOD"); 13152 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 13153 RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE"); 13154 RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE"); 13155 RewriteRuleSubtreeStream stream_method_reference=new RewriteRuleSubtreeStream(adaptor,"rule method_reference"); 13156 RewriteRuleSubtreeStream stream_register_list=new RewriteRuleSubtreeStream(adaptor,"rule register_list"); 13157 13158 try { 13159 // smaliParser.g:1020:3: ( INSTRUCTION_FORMAT35c_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference -> ^( I_STATEMENT_FORMAT35c_METHOD[$start, \"I_STATEMENT_FORMAT35c_METHOD\"] INSTRUCTION_FORMAT35c_METHOD register_list method_reference ) ) 13160 // smaliParser.g:1021:5: INSTRUCTION_FORMAT35c_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference 13161 { 13162 INSTRUCTION_FORMAT35c_METHOD409=(Token)match(input,INSTRUCTION_FORMAT35c_METHOD,FOLLOW_INSTRUCTION_FORMAT35c_METHOD_in_insn_format35c_method5170); 13163 stream_INSTRUCTION_FORMAT35c_METHOD.add(INSTRUCTION_FORMAT35c_METHOD409); 13164 13165 OPEN_BRACE410=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format35c_method5172); 13166 stream_OPEN_BRACE.add(OPEN_BRACE410); 13167 13168 pushFollow(FOLLOW_register_list_in_insn_format35c_method5174); 13169 register_list411=register_list(); 13170 state._fsp--; 13171 13172 stream_register_list.add(register_list411.getTree()); 13173 CLOSE_BRACE412=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format35c_method5176); 13174 stream_CLOSE_BRACE.add(CLOSE_BRACE412); 13175 13176 COMMA413=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format35c_method5178); 13177 stream_COMMA.add(COMMA413); 13178 13179 pushFollow(FOLLOW_method_reference_in_insn_format35c_method5180); 13180 method_reference414=method_reference(); 13181 state._fsp--; 13182 13183 stream_method_reference.add(method_reference414.getTree()); 13184 // AST REWRITE 13185 // elements: INSTRUCTION_FORMAT35c_METHOD, register_list, method_reference 13186 // token labels: 13187 // rule labels: retval 13188 // token list labels: 13189 // rule list labels: 13190 // wildcard labels: 13191 retval.tree = root_0; 13192 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 13193 13194 root_0 = (CommonTree)adaptor.nil(); 13195 // 1022:5: -> ^( I_STATEMENT_FORMAT35c_METHOD[$start, \"I_STATEMENT_FORMAT35c_METHOD\"] INSTRUCTION_FORMAT35c_METHOD register_list method_reference ) 13196 { 13197 // smaliParser.g:1022:8: ^( I_STATEMENT_FORMAT35c_METHOD[$start, \"I_STATEMENT_FORMAT35c_METHOD\"] INSTRUCTION_FORMAT35c_METHOD register_list method_reference ) 13198 { 13199 CommonTree root_1 = (CommonTree)adaptor.nil(); 13200 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT35c_METHOD, (retval.start), "I_STATEMENT_FORMAT35c_METHOD"), root_1); 13201 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT35c_METHOD.nextNode()); 13202 adaptor.addChild(root_1, stream_register_list.nextTree()); 13203 adaptor.addChild(root_1, stream_method_reference.nextTree()); 13204 adaptor.addChild(root_0, root_1); 13205 } 13206 13207 } 13208 13209 13210 retval.tree = root_0; 13211 13212 } 13213 13214 retval.stop = input.LT(-1); 13215 13216 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13217 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13218 13219 } 13220 catch (RecognitionException re) { 13221 reportError(re); 13222 recover(input,re); 13223 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13224 } 13225 finally { 13226 // do for sure before leaving 13227 } 13228 return retval; 13229 } 13230 // $ANTLR end "insn_format35c_method" 13231 13232 13233 public static class insn_format35c_type_return extends ParserRuleReturnScope { 13234 CommonTree tree; 13235 @Override 13236 public CommonTree getTree() { return tree; } 13237 }; 13238 13239 13240 // $ANTLR start "insn_format35c_type" 13241 // smaliParser.g:1024:1: insn_format35c_type : INSTRUCTION_FORMAT35c_TYPE OPEN_BRACE register_list CLOSE_BRACE COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT35c_TYPE[$start, \"I_STATEMENT_FORMAT35c_TYPE\"] INSTRUCTION_FORMAT35c_TYPE register_list nonvoid_type_descriptor ) ; 13242 public final smaliParser.insn_format35c_type_return insn_format35c_type() throws RecognitionException { 13243 smaliParser.insn_format35c_type_return retval = new smaliParser.insn_format35c_type_return(); 13244 retval.start = input.LT(1); 13245 13246 CommonTree root_0 = null; 13247 13248 Token INSTRUCTION_FORMAT35c_TYPE415=null; 13249 Token OPEN_BRACE416=null; 13250 Token CLOSE_BRACE418=null; 13251 Token COMMA419=null; 13252 ParserRuleReturnScope register_list417 =null; 13253 ParserRuleReturnScope nonvoid_type_descriptor420 =null; 13254 13255 CommonTree INSTRUCTION_FORMAT35c_TYPE415_tree=null; 13256 CommonTree OPEN_BRACE416_tree=null; 13257 CommonTree CLOSE_BRACE418_tree=null; 13258 CommonTree COMMA419_tree=null; 13259 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 13260 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35c_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35c_TYPE"); 13261 RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE"); 13262 RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE"); 13263 RewriteRuleSubtreeStream stream_register_list=new RewriteRuleSubtreeStream(adaptor,"rule register_list"); 13264 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 13265 13266 try { 13267 // smaliParser.g:1025:3: ( INSTRUCTION_FORMAT35c_TYPE OPEN_BRACE register_list CLOSE_BRACE COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT35c_TYPE[$start, \"I_STATEMENT_FORMAT35c_TYPE\"] INSTRUCTION_FORMAT35c_TYPE register_list nonvoid_type_descriptor ) ) 13268 // smaliParser.g:1026:5: INSTRUCTION_FORMAT35c_TYPE OPEN_BRACE register_list CLOSE_BRACE COMMA nonvoid_type_descriptor 13269 { 13270 INSTRUCTION_FORMAT35c_TYPE415=(Token)match(input,INSTRUCTION_FORMAT35c_TYPE,FOLLOW_INSTRUCTION_FORMAT35c_TYPE_in_insn_format35c_type5212); 13271 stream_INSTRUCTION_FORMAT35c_TYPE.add(INSTRUCTION_FORMAT35c_TYPE415); 13272 13273 OPEN_BRACE416=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format35c_type5214); 13274 stream_OPEN_BRACE.add(OPEN_BRACE416); 13275 13276 pushFollow(FOLLOW_register_list_in_insn_format35c_type5216); 13277 register_list417=register_list(); 13278 state._fsp--; 13279 13280 stream_register_list.add(register_list417.getTree()); 13281 CLOSE_BRACE418=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format35c_type5218); 13282 stream_CLOSE_BRACE.add(CLOSE_BRACE418); 13283 13284 COMMA419=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format35c_type5220); 13285 stream_COMMA.add(COMMA419); 13286 13287 pushFollow(FOLLOW_nonvoid_type_descriptor_in_insn_format35c_type5222); 13288 nonvoid_type_descriptor420=nonvoid_type_descriptor(); 13289 state._fsp--; 13290 13291 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor420.getTree()); 13292 // AST REWRITE 13293 // elements: register_list, INSTRUCTION_FORMAT35c_TYPE, nonvoid_type_descriptor 13294 // token labels: 13295 // rule labels: retval 13296 // token list labels: 13297 // rule list labels: 13298 // wildcard labels: 13299 retval.tree = root_0; 13300 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 13301 13302 root_0 = (CommonTree)adaptor.nil(); 13303 // 1027:5: -> ^( I_STATEMENT_FORMAT35c_TYPE[$start, \"I_STATEMENT_FORMAT35c_TYPE\"] INSTRUCTION_FORMAT35c_TYPE register_list nonvoid_type_descriptor ) 13304 { 13305 // smaliParser.g:1027:8: ^( I_STATEMENT_FORMAT35c_TYPE[$start, \"I_STATEMENT_FORMAT35c_TYPE\"] INSTRUCTION_FORMAT35c_TYPE register_list nonvoid_type_descriptor ) 13306 { 13307 CommonTree root_1 = (CommonTree)adaptor.nil(); 13308 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT35c_TYPE, (retval.start), "I_STATEMENT_FORMAT35c_TYPE"), root_1); 13309 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT35c_TYPE.nextNode()); 13310 adaptor.addChild(root_1, stream_register_list.nextTree()); 13311 adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree()); 13312 adaptor.addChild(root_0, root_1); 13313 } 13314 13315 } 13316 13317 13318 retval.tree = root_0; 13319 13320 } 13321 13322 retval.stop = input.LT(-1); 13323 13324 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13325 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13326 13327 } 13328 catch (RecognitionException re) { 13329 reportError(re); 13330 recover(input,re); 13331 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13332 } 13333 finally { 13334 // do for sure before leaving 13335 } 13336 return retval; 13337 } 13338 // $ANTLR end "insn_format35c_type" 13339 13340 13341 public static class insn_format35c_method_odex_return extends ParserRuleReturnScope { 13342 CommonTree tree; 13343 @Override 13344 public CommonTree getTree() { return tree; } 13345 }; 13346 13347 13348 // $ANTLR start "insn_format35c_method_odex" 13349 // smaliParser.g:1029:1: insn_format35c_method_odex : INSTRUCTION_FORMAT35c_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference ; 13350 public final smaliParser.insn_format35c_method_odex_return insn_format35c_method_odex() throws RecognitionException { 13351 smaliParser.insn_format35c_method_odex_return retval = new smaliParser.insn_format35c_method_odex_return(); 13352 retval.start = input.LT(1); 13353 13354 CommonTree root_0 = null; 13355 13356 Token INSTRUCTION_FORMAT35c_METHOD_ODEX421=null; 13357 Token OPEN_BRACE422=null; 13358 Token CLOSE_BRACE424=null; 13359 Token COMMA425=null; 13360 ParserRuleReturnScope register_list423 =null; 13361 ParserRuleReturnScope method_reference426 =null; 13362 13363 CommonTree INSTRUCTION_FORMAT35c_METHOD_ODEX421_tree=null; 13364 CommonTree OPEN_BRACE422_tree=null; 13365 CommonTree CLOSE_BRACE424_tree=null; 13366 CommonTree COMMA425_tree=null; 13367 13368 try { 13369 // smaliParser.g:1030:3: ( INSTRUCTION_FORMAT35c_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference ) 13370 // smaliParser.g:1031:5: INSTRUCTION_FORMAT35c_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference 13371 { 13372 root_0 = (CommonTree)adaptor.nil(); 13373 13374 13375 INSTRUCTION_FORMAT35c_METHOD_ODEX421=(Token)match(input,INSTRUCTION_FORMAT35c_METHOD_ODEX,FOLLOW_INSTRUCTION_FORMAT35c_METHOD_ODEX_in_insn_format35c_method_odex5254); 13376 INSTRUCTION_FORMAT35c_METHOD_ODEX421_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT35c_METHOD_ODEX421); 13377 adaptor.addChild(root_0, INSTRUCTION_FORMAT35c_METHOD_ODEX421_tree); 13378 13379 OPEN_BRACE422=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format35c_method_odex5256); 13380 OPEN_BRACE422_tree = (CommonTree)adaptor.create(OPEN_BRACE422); 13381 adaptor.addChild(root_0, OPEN_BRACE422_tree); 13382 13383 pushFollow(FOLLOW_register_list_in_insn_format35c_method_odex5258); 13384 register_list423=register_list(); 13385 state._fsp--; 13386 13387 adaptor.addChild(root_0, register_list423.getTree()); 13388 13389 CLOSE_BRACE424=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format35c_method_odex5260); 13390 CLOSE_BRACE424_tree = (CommonTree)adaptor.create(CLOSE_BRACE424); 13391 adaptor.addChild(root_0, CLOSE_BRACE424_tree); 13392 13393 COMMA425=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format35c_method_odex5262); 13394 COMMA425_tree = (CommonTree)adaptor.create(COMMA425); 13395 adaptor.addChild(root_0, COMMA425_tree); 13396 13397 pushFollow(FOLLOW_method_reference_in_insn_format35c_method_odex5264); 13398 method_reference426=method_reference(); 13399 state._fsp--; 13400 13401 adaptor.addChild(root_0, method_reference426.getTree()); 13402 13403 13404 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT35c_METHOD_ODEX421!=null?INSTRUCTION_FORMAT35c_METHOD_ODEX421.getText():null)); 13405 13406 } 13407 13408 retval.stop = input.LT(-1); 13409 13410 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13411 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13412 13413 } 13414 catch (RecognitionException re) { 13415 reportError(re); 13416 recover(input,re); 13417 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13418 } 13419 finally { 13420 // do for sure before leaving 13421 } 13422 return retval; 13423 } 13424 // $ANTLR end "insn_format35c_method_odex" 13425 13426 13427 public static class insn_format35mi_method_return extends ParserRuleReturnScope { 13428 CommonTree tree; 13429 @Override 13430 public CommonTree getTree() { return tree; } 13431 }; 13432 13433 13434 // $ANTLR start "insn_format35mi_method" 13435 // smaliParser.g:1036:1: insn_format35mi_method : INSTRUCTION_FORMAT35mi_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA INLINE_INDEX ; 13436 public final smaliParser.insn_format35mi_method_return insn_format35mi_method() throws RecognitionException { 13437 smaliParser.insn_format35mi_method_return retval = new smaliParser.insn_format35mi_method_return(); 13438 retval.start = input.LT(1); 13439 13440 CommonTree root_0 = null; 13441 13442 Token INSTRUCTION_FORMAT35mi_METHOD427=null; 13443 Token OPEN_BRACE428=null; 13444 Token CLOSE_BRACE430=null; 13445 Token COMMA431=null; 13446 Token INLINE_INDEX432=null; 13447 ParserRuleReturnScope register_list429 =null; 13448 13449 CommonTree INSTRUCTION_FORMAT35mi_METHOD427_tree=null; 13450 CommonTree OPEN_BRACE428_tree=null; 13451 CommonTree CLOSE_BRACE430_tree=null; 13452 CommonTree COMMA431_tree=null; 13453 CommonTree INLINE_INDEX432_tree=null; 13454 13455 try { 13456 // smaliParser.g:1037:3: ( INSTRUCTION_FORMAT35mi_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA INLINE_INDEX ) 13457 // smaliParser.g:1038:5: INSTRUCTION_FORMAT35mi_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA INLINE_INDEX 13458 { 13459 root_0 = (CommonTree)adaptor.nil(); 13460 13461 13462 INSTRUCTION_FORMAT35mi_METHOD427=(Token)match(input,INSTRUCTION_FORMAT35mi_METHOD,FOLLOW_INSTRUCTION_FORMAT35mi_METHOD_in_insn_format35mi_method5285); 13463 INSTRUCTION_FORMAT35mi_METHOD427_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT35mi_METHOD427); 13464 adaptor.addChild(root_0, INSTRUCTION_FORMAT35mi_METHOD427_tree); 13465 13466 OPEN_BRACE428=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format35mi_method5287); 13467 OPEN_BRACE428_tree = (CommonTree)adaptor.create(OPEN_BRACE428); 13468 adaptor.addChild(root_0, OPEN_BRACE428_tree); 13469 13470 pushFollow(FOLLOW_register_list_in_insn_format35mi_method5289); 13471 register_list429=register_list(); 13472 state._fsp--; 13473 13474 adaptor.addChild(root_0, register_list429.getTree()); 13475 13476 CLOSE_BRACE430=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format35mi_method5291); 13477 CLOSE_BRACE430_tree = (CommonTree)adaptor.create(CLOSE_BRACE430); 13478 adaptor.addChild(root_0, CLOSE_BRACE430_tree); 13479 13480 COMMA431=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format35mi_method5293); 13481 COMMA431_tree = (CommonTree)adaptor.create(COMMA431); 13482 adaptor.addChild(root_0, COMMA431_tree); 13483 13484 INLINE_INDEX432=(Token)match(input,INLINE_INDEX,FOLLOW_INLINE_INDEX_in_insn_format35mi_method5295); 13485 INLINE_INDEX432_tree = (CommonTree)adaptor.create(INLINE_INDEX432); 13486 adaptor.addChild(root_0, INLINE_INDEX432_tree); 13487 13488 13489 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT35mi_METHOD427!=null?INSTRUCTION_FORMAT35mi_METHOD427.getText():null)); 13490 13491 } 13492 13493 retval.stop = input.LT(-1); 13494 13495 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13496 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13497 13498 } 13499 catch (RecognitionException re) { 13500 reportError(re); 13501 recover(input,re); 13502 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13503 } 13504 finally { 13505 // do for sure before leaving 13506 } 13507 return retval; 13508 } 13509 // $ANTLR end "insn_format35mi_method" 13510 13511 13512 public static class insn_format35ms_method_return extends ParserRuleReturnScope { 13513 CommonTree tree; 13514 @Override 13515 public CommonTree getTree() { return tree; } 13516 }; 13517 13518 13519 // $ANTLR start "insn_format35ms_method" 13520 // smaliParser.g:1043:1: insn_format35ms_method : INSTRUCTION_FORMAT35ms_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA VTABLE_INDEX ; 13521 public final smaliParser.insn_format35ms_method_return insn_format35ms_method() throws RecognitionException { 13522 smaliParser.insn_format35ms_method_return retval = new smaliParser.insn_format35ms_method_return(); 13523 retval.start = input.LT(1); 13524 13525 CommonTree root_0 = null; 13526 13527 Token INSTRUCTION_FORMAT35ms_METHOD433=null; 13528 Token OPEN_BRACE434=null; 13529 Token CLOSE_BRACE436=null; 13530 Token COMMA437=null; 13531 Token VTABLE_INDEX438=null; 13532 ParserRuleReturnScope register_list435 =null; 13533 13534 CommonTree INSTRUCTION_FORMAT35ms_METHOD433_tree=null; 13535 CommonTree OPEN_BRACE434_tree=null; 13536 CommonTree CLOSE_BRACE436_tree=null; 13537 CommonTree COMMA437_tree=null; 13538 CommonTree VTABLE_INDEX438_tree=null; 13539 13540 try { 13541 // smaliParser.g:1044:3: ( INSTRUCTION_FORMAT35ms_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA VTABLE_INDEX ) 13542 // smaliParser.g:1045:5: INSTRUCTION_FORMAT35ms_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA VTABLE_INDEX 13543 { 13544 root_0 = (CommonTree)adaptor.nil(); 13545 13546 13547 INSTRUCTION_FORMAT35ms_METHOD433=(Token)match(input,INSTRUCTION_FORMAT35ms_METHOD,FOLLOW_INSTRUCTION_FORMAT35ms_METHOD_in_insn_format35ms_method5316); 13548 INSTRUCTION_FORMAT35ms_METHOD433_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT35ms_METHOD433); 13549 adaptor.addChild(root_0, INSTRUCTION_FORMAT35ms_METHOD433_tree); 13550 13551 OPEN_BRACE434=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format35ms_method5318); 13552 OPEN_BRACE434_tree = (CommonTree)adaptor.create(OPEN_BRACE434); 13553 adaptor.addChild(root_0, OPEN_BRACE434_tree); 13554 13555 pushFollow(FOLLOW_register_list_in_insn_format35ms_method5320); 13556 register_list435=register_list(); 13557 state._fsp--; 13558 13559 adaptor.addChild(root_0, register_list435.getTree()); 13560 13561 CLOSE_BRACE436=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format35ms_method5322); 13562 CLOSE_BRACE436_tree = (CommonTree)adaptor.create(CLOSE_BRACE436); 13563 adaptor.addChild(root_0, CLOSE_BRACE436_tree); 13564 13565 COMMA437=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format35ms_method5324); 13566 COMMA437_tree = (CommonTree)adaptor.create(COMMA437); 13567 adaptor.addChild(root_0, COMMA437_tree); 13568 13569 VTABLE_INDEX438=(Token)match(input,VTABLE_INDEX,FOLLOW_VTABLE_INDEX_in_insn_format35ms_method5326); 13570 VTABLE_INDEX438_tree = (CommonTree)adaptor.create(VTABLE_INDEX438); 13571 adaptor.addChild(root_0, VTABLE_INDEX438_tree); 13572 13573 13574 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT35ms_METHOD433!=null?INSTRUCTION_FORMAT35ms_METHOD433.getText():null)); 13575 13576 } 13577 13578 retval.stop = input.LT(-1); 13579 13580 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13581 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13582 13583 } 13584 catch (RecognitionException re) { 13585 reportError(re); 13586 recover(input,re); 13587 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13588 } 13589 finally { 13590 // do for sure before leaving 13591 } 13592 return retval; 13593 } 13594 // $ANTLR end "insn_format35ms_method" 13595 13596 13597 public static class insn_format3rc_method_return extends ParserRuleReturnScope { 13598 CommonTree tree; 13599 @Override 13600 public CommonTree getTree() { return tree; } 13601 }; 13602 13603 13604 // $ANTLR start "insn_format3rc_method" 13605 // smaliParser.g:1050:1: insn_format3rc_method : INSTRUCTION_FORMAT3rc_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA method_reference -> ^( I_STATEMENT_FORMAT3rc_METHOD[$start, \"I_STATEMENT_FORMAT3rc_METHOD\"] INSTRUCTION_FORMAT3rc_METHOD register_range method_reference ) ; 13606 public final smaliParser.insn_format3rc_method_return insn_format3rc_method() throws RecognitionException { 13607 smaliParser.insn_format3rc_method_return retval = new smaliParser.insn_format3rc_method_return(); 13608 retval.start = input.LT(1); 13609 13610 CommonTree root_0 = null; 13611 13612 Token INSTRUCTION_FORMAT3rc_METHOD439=null; 13613 Token OPEN_BRACE440=null; 13614 Token CLOSE_BRACE442=null; 13615 Token COMMA443=null; 13616 ParserRuleReturnScope register_range441 =null; 13617 ParserRuleReturnScope method_reference444 =null; 13618 13619 CommonTree INSTRUCTION_FORMAT3rc_METHOD439_tree=null; 13620 CommonTree OPEN_BRACE440_tree=null; 13621 CommonTree CLOSE_BRACE442_tree=null; 13622 CommonTree COMMA443_tree=null; 13623 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 13624 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT3rc_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT3rc_METHOD"); 13625 RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE"); 13626 RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE"); 13627 RewriteRuleSubtreeStream stream_method_reference=new RewriteRuleSubtreeStream(adaptor,"rule method_reference"); 13628 RewriteRuleSubtreeStream stream_register_range=new RewriteRuleSubtreeStream(adaptor,"rule register_range"); 13629 13630 try { 13631 // smaliParser.g:1051:3: ( INSTRUCTION_FORMAT3rc_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA method_reference -> ^( I_STATEMENT_FORMAT3rc_METHOD[$start, \"I_STATEMENT_FORMAT3rc_METHOD\"] INSTRUCTION_FORMAT3rc_METHOD register_range method_reference ) ) 13632 // smaliParser.g:1052:5: INSTRUCTION_FORMAT3rc_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA method_reference 13633 { 13634 INSTRUCTION_FORMAT3rc_METHOD439=(Token)match(input,INSTRUCTION_FORMAT3rc_METHOD,FOLLOW_INSTRUCTION_FORMAT3rc_METHOD_in_insn_format3rc_method5347); 13635 stream_INSTRUCTION_FORMAT3rc_METHOD.add(INSTRUCTION_FORMAT3rc_METHOD439); 13636 13637 OPEN_BRACE440=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format3rc_method5349); 13638 stream_OPEN_BRACE.add(OPEN_BRACE440); 13639 13640 pushFollow(FOLLOW_register_range_in_insn_format3rc_method5351); 13641 register_range441=register_range(); 13642 state._fsp--; 13643 13644 stream_register_range.add(register_range441.getTree()); 13645 CLOSE_BRACE442=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format3rc_method5353); 13646 stream_CLOSE_BRACE.add(CLOSE_BRACE442); 13647 13648 COMMA443=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format3rc_method5355); 13649 stream_COMMA.add(COMMA443); 13650 13651 pushFollow(FOLLOW_method_reference_in_insn_format3rc_method5357); 13652 method_reference444=method_reference(); 13653 state._fsp--; 13654 13655 stream_method_reference.add(method_reference444.getTree()); 13656 // AST REWRITE 13657 // elements: register_range, INSTRUCTION_FORMAT3rc_METHOD, method_reference 13658 // token labels: 13659 // rule labels: retval 13660 // token list labels: 13661 // rule list labels: 13662 // wildcard labels: 13663 retval.tree = root_0; 13664 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 13665 13666 root_0 = (CommonTree)adaptor.nil(); 13667 // 1053:5: -> ^( I_STATEMENT_FORMAT3rc_METHOD[$start, \"I_STATEMENT_FORMAT3rc_METHOD\"] INSTRUCTION_FORMAT3rc_METHOD register_range method_reference ) 13668 { 13669 // smaliParser.g:1053:8: ^( I_STATEMENT_FORMAT3rc_METHOD[$start, \"I_STATEMENT_FORMAT3rc_METHOD\"] INSTRUCTION_FORMAT3rc_METHOD register_range method_reference ) 13670 { 13671 CommonTree root_1 = (CommonTree)adaptor.nil(); 13672 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT3rc_METHOD, (retval.start), "I_STATEMENT_FORMAT3rc_METHOD"), root_1); 13673 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT3rc_METHOD.nextNode()); 13674 adaptor.addChild(root_1, stream_register_range.nextTree()); 13675 adaptor.addChild(root_1, stream_method_reference.nextTree()); 13676 adaptor.addChild(root_0, root_1); 13677 } 13678 13679 } 13680 13681 13682 retval.tree = root_0; 13683 13684 } 13685 13686 retval.stop = input.LT(-1); 13687 13688 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13689 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13690 13691 } 13692 catch (RecognitionException re) { 13693 reportError(re); 13694 recover(input,re); 13695 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13696 } 13697 finally { 13698 // do for sure before leaving 13699 } 13700 return retval; 13701 } 13702 // $ANTLR end "insn_format3rc_method" 13703 13704 13705 public static class insn_format3rc_method_odex_return extends ParserRuleReturnScope { 13706 CommonTree tree; 13707 @Override 13708 public CommonTree getTree() { return tree; } 13709 }; 13710 13711 13712 // $ANTLR start "insn_format3rc_method_odex" 13713 // smaliParser.g:1055:1: insn_format3rc_method_odex : INSTRUCTION_FORMAT3rc_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference ; 13714 public final smaliParser.insn_format3rc_method_odex_return insn_format3rc_method_odex() throws RecognitionException { 13715 smaliParser.insn_format3rc_method_odex_return retval = new smaliParser.insn_format3rc_method_odex_return(); 13716 retval.start = input.LT(1); 13717 13718 CommonTree root_0 = null; 13719 13720 Token INSTRUCTION_FORMAT3rc_METHOD_ODEX445=null; 13721 Token OPEN_BRACE446=null; 13722 Token CLOSE_BRACE448=null; 13723 Token COMMA449=null; 13724 ParserRuleReturnScope register_list447 =null; 13725 ParserRuleReturnScope method_reference450 =null; 13726 13727 CommonTree INSTRUCTION_FORMAT3rc_METHOD_ODEX445_tree=null; 13728 CommonTree OPEN_BRACE446_tree=null; 13729 CommonTree CLOSE_BRACE448_tree=null; 13730 CommonTree COMMA449_tree=null; 13731 13732 try { 13733 // smaliParser.g:1056:3: ( INSTRUCTION_FORMAT3rc_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference ) 13734 // smaliParser.g:1057:5: INSTRUCTION_FORMAT3rc_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference 13735 { 13736 root_0 = (CommonTree)adaptor.nil(); 13737 13738 13739 INSTRUCTION_FORMAT3rc_METHOD_ODEX445=(Token)match(input,INSTRUCTION_FORMAT3rc_METHOD_ODEX,FOLLOW_INSTRUCTION_FORMAT3rc_METHOD_ODEX_in_insn_format3rc_method_odex5389); 13740 INSTRUCTION_FORMAT3rc_METHOD_ODEX445_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT3rc_METHOD_ODEX445); 13741 adaptor.addChild(root_0, INSTRUCTION_FORMAT3rc_METHOD_ODEX445_tree); 13742 13743 OPEN_BRACE446=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format3rc_method_odex5391); 13744 OPEN_BRACE446_tree = (CommonTree)adaptor.create(OPEN_BRACE446); 13745 adaptor.addChild(root_0, OPEN_BRACE446_tree); 13746 13747 pushFollow(FOLLOW_register_list_in_insn_format3rc_method_odex5393); 13748 register_list447=register_list(); 13749 state._fsp--; 13750 13751 adaptor.addChild(root_0, register_list447.getTree()); 13752 13753 CLOSE_BRACE448=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format3rc_method_odex5395); 13754 CLOSE_BRACE448_tree = (CommonTree)adaptor.create(CLOSE_BRACE448); 13755 adaptor.addChild(root_0, CLOSE_BRACE448_tree); 13756 13757 COMMA449=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format3rc_method_odex5397); 13758 COMMA449_tree = (CommonTree)adaptor.create(COMMA449); 13759 adaptor.addChild(root_0, COMMA449_tree); 13760 13761 pushFollow(FOLLOW_method_reference_in_insn_format3rc_method_odex5399); 13762 method_reference450=method_reference(); 13763 state._fsp--; 13764 13765 adaptor.addChild(root_0, method_reference450.getTree()); 13766 13767 13768 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT3rc_METHOD_ODEX445!=null?INSTRUCTION_FORMAT3rc_METHOD_ODEX445.getText():null)); 13769 13770 } 13771 13772 retval.stop = input.LT(-1); 13773 13774 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13775 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13776 13777 } 13778 catch (RecognitionException re) { 13779 reportError(re); 13780 recover(input,re); 13781 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13782 } 13783 finally { 13784 // do for sure before leaving 13785 } 13786 return retval; 13787 } 13788 // $ANTLR end "insn_format3rc_method_odex" 13789 13790 13791 public static class insn_format3rc_type_return extends ParserRuleReturnScope { 13792 CommonTree tree; 13793 @Override 13794 public CommonTree getTree() { return tree; } 13795 }; 13796 13797 13798 // $ANTLR start "insn_format3rc_type" 13799 // smaliParser.g:1062:1: insn_format3rc_type : INSTRUCTION_FORMAT3rc_TYPE OPEN_BRACE register_range CLOSE_BRACE COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT3rc_TYPE[$start, \"I_STATEMENT_FORMAT3rc_TYPE\"] INSTRUCTION_FORMAT3rc_TYPE register_range nonvoid_type_descriptor ) ; 13800 public final smaliParser.insn_format3rc_type_return insn_format3rc_type() throws RecognitionException { 13801 smaliParser.insn_format3rc_type_return retval = new smaliParser.insn_format3rc_type_return(); 13802 retval.start = input.LT(1); 13803 13804 CommonTree root_0 = null; 13805 13806 Token INSTRUCTION_FORMAT3rc_TYPE451=null; 13807 Token OPEN_BRACE452=null; 13808 Token CLOSE_BRACE454=null; 13809 Token COMMA455=null; 13810 ParserRuleReturnScope register_range453 =null; 13811 ParserRuleReturnScope nonvoid_type_descriptor456 =null; 13812 13813 CommonTree INSTRUCTION_FORMAT3rc_TYPE451_tree=null; 13814 CommonTree OPEN_BRACE452_tree=null; 13815 CommonTree CLOSE_BRACE454_tree=null; 13816 CommonTree COMMA455_tree=null; 13817 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 13818 RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE"); 13819 RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE"); 13820 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT3rc_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT3rc_TYPE"); 13821 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 13822 RewriteRuleSubtreeStream stream_register_range=new RewriteRuleSubtreeStream(adaptor,"rule register_range"); 13823 13824 try { 13825 // smaliParser.g:1063:3: ( INSTRUCTION_FORMAT3rc_TYPE OPEN_BRACE register_range CLOSE_BRACE COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT3rc_TYPE[$start, \"I_STATEMENT_FORMAT3rc_TYPE\"] INSTRUCTION_FORMAT3rc_TYPE register_range nonvoid_type_descriptor ) ) 13826 // smaliParser.g:1064:5: INSTRUCTION_FORMAT3rc_TYPE OPEN_BRACE register_range CLOSE_BRACE COMMA nonvoid_type_descriptor 13827 { 13828 INSTRUCTION_FORMAT3rc_TYPE451=(Token)match(input,INSTRUCTION_FORMAT3rc_TYPE,FOLLOW_INSTRUCTION_FORMAT3rc_TYPE_in_insn_format3rc_type5420); 13829 stream_INSTRUCTION_FORMAT3rc_TYPE.add(INSTRUCTION_FORMAT3rc_TYPE451); 13830 13831 OPEN_BRACE452=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format3rc_type5422); 13832 stream_OPEN_BRACE.add(OPEN_BRACE452); 13833 13834 pushFollow(FOLLOW_register_range_in_insn_format3rc_type5424); 13835 register_range453=register_range(); 13836 state._fsp--; 13837 13838 stream_register_range.add(register_range453.getTree()); 13839 CLOSE_BRACE454=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format3rc_type5426); 13840 stream_CLOSE_BRACE.add(CLOSE_BRACE454); 13841 13842 COMMA455=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format3rc_type5428); 13843 stream_COMMA.add(COMMA455); 13844 13845 pushFollow(FOLLOW_nonvoid_type_descriptor_in_insn_format3rc_type5430); 13846 nonvoid_type_descriptor456=nonvoid_type_descriptor(); 13847 state._fsp--; 13848 13849 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor456.getTree()); 13850 // AST REWRITE 13851 // elements: nonvoid_type_descriptor, INSTRUCTION_FORMAT3rc_TYPE, register_range 13852 // token labels: 13853 // rule labels: retval 13854 // token list labels: 13855 // rule list labels: 13856 // wildcard labels: 13857 retval.tree = root_0; 13858 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 13859 13860 root_0 = (CommonTree)adaptor.nil(); 13861 // 1065:5: -> ^( I_STATEMENT_FORMAT3rc_TYPE[$start, \"I_STATEMENT_FORMAT3rc_TYPE\"] INSTRUCTION_FORMAT3rc_TYPE register_range nonvoid_type_descriptor ) 13862 { 13863 // smaliParser.g:1065:8: ^( I_STATEMENT_FORMAT3rc_TYPE[$start, \"I_STATEMENT_FORMAT3rc_TYPE\"] INSTRUCTION_FORMAT3rc_TYPE register_range nonvoid_type_descriptor ) 13864 { 13865 CommonTree root_1 = (CommonTree)adaptor.nil(); 13866 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT3rc_TYPE, (retval.start), "I_STATEMENT_FORMAT3rc_TYPE"), root_1); 13867 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT3rc_TYPE.nextNode()); 13868 adaptor.addChild(root_1, stream_register_range.nextTree()); 13869 adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree()); 13870 adaptor.addChild(root_0, root_1); 13871 } 13872 13873 } 13874 13875 13876 retval.tree = root_0; 13877 13878 } 13879 13880 retval.stop = input.LT(-1); 13881 13882 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13883 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13884 13885 } 13886 catch (RecognitionException re) { 13887 reportError(re); 13888 recover(input,re); 13889 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13890 } 13891 finally { 13892 // do for sure before leaving 13893 } 13894 return retval; 13895 } 13896 // $ANTLR end "insn_format3rc_type" 13897 13898 13899 public static class insn_format3rmi_method_return extends ParserRuleReturnScope { 13900 CommonTree tree; 13901 @Override 13902 public CommonTree getTree() { return tree; } 13903 }; 13904 13905 13906 // $ANTLR start "insn_format3rmi_method" 13907 // smaliParser.g:1067:1: insn_format3rmi_method : INSTRUCTION_FORMAT3rmi_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA INLINE_INDEX ; 13908 public final smaliParser.insn_format3rmi_method_return insn_format3rmi_method() throws RecognitionException { 13909 smaliParser.insn_format3rmi_method_return retval = new smaliParser.insn_format3rmi_method_return(); 13910 retval.start = input.LT(1); 13911 13912 CommonTree root_0 = null; 13913 13914 Token INSTRUCTION_FORMAT3rmi_METHOD457=null; 13915 Token OPEN_BRACE458=null; 13916 Token CLOSE_BRACE460=null; 13917 Token COMMA461=null; 13918 Token INLINE_INDEX462=null; 13919 ParserRuleReturnScope register_range459 =null; 13920 13921 CommonTree INSTRUCTION_FORMAT3rmi_METHOD457_tree=null; 13922 CommonTree OPEN_BRACE458_tree=null; 13923 CommonTree CLOSE_BRACE460_tree=null; 13924 CommonTree COMMA461_tree=null; 13925 CommonTree INLINE_INDEX462_tree=null; 13926 13927 try { 13928 // smaliParser.g:1068:3: ( INSTRUCTION_FORMAT3rmi_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA INLINE_INDEX ) 13929 // smaliParser.g:1069:5: INSTRUCTION_FORMAT3rmi_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA INLINE_INDEX 13930 { 13931 root_0 = (CommonTree)adaptor.nil(); 13932 13933 13934 INSTRUCTION_FORMAT3rmi_METHOD457=(Token)match(input,INSTRUCTION_FORMAT3rmi_METHOD,FOLLOW_INSTRUCTION_FORMAT3rmi_METHOD_in_insn_format3rmi_method5462); 13935 INSTRUCTION_FORMAT3rmi_METHOD457_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT3rmi_METHOD457); 13936 adaptor.addChild(root_0, INSTRUCTION_FORMAT3rmi_METHOD457_tree); 13937 13938 OPEN_BRACE458=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format3rmi_method5464); 13939 OPEN_BRACE458_tree = (CommonTree)adaptor.create(OPEN_BRACE458); 13940 adaptor.addChild(root_0, OPEN_BRACE458_tree); 13941 13942 pushFollow(FOLLOW_register_range_in_insn_format3rmi_method5466); 13943 register_range459=register_range(); 13944 state._fsp--; 13945 13946 adaptor.addChild(root_0, register_range459.getTree()); 13947 13948 CLOSE_BRACE460=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format3rmi_method5468); 13949 CLOSE_BRACE460_tree = (CommonTree)adaptor.create(CLOSE_BRACE460); 13950 adaptor.addChild(root_0, CLOSE_BRACE460_tree); 13951 13952 COMMA461=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format3rmi_method5470); 13953 COMMA461_tree = (CommonTree)adaptor.create(COMMA461); 13954 adaptor.addChild(root_0, COMMA461_tree); 13955 13956 INLINE_INDEX462=(Token)match(input,INLINE_INDEX,FOLLOW_INLINE_INDEX_in_insn_format3rmi_method5472); 13957 INLINE_INDEX462_tree = (CommonTree)adaptor.create(INLINE_INDEX462); 13958 adaptor.addChild(root_0, INLINE_INDEX462_tree); 13959 13960 13961 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT3rmi_METHOD457!=null?INSTRUCTION_FORMAT3rmi_METHOD457.getText():null)); 13962 13963 } 13964 13965 retval.stop = input.LT(-1); 13966 13967 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13968 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13969 13970 } 13971 catch (RecognitionException re) { 13972 reportError(re); 13973 recover(input,re); 13974 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13975 } 13976 finally { 13977 // do for sure before leaving 13978 } 13979 return retval; 13980 } 13981 // $ANTLR end "insn_format3rmi_method" 13982 13983 13984 public static class insn_format3rms_method_return extends ParserRuleReturnScope { 13985 CommonTree tree; 13986 @Override 13987 public CommonTree getTree() { return tree; } 13988 }; 13989 13990 13991 // $ANTLR start "insn_format3rms_method" 13992 // smaliParser.g:1074:1: insn_format3rms_method : INSTRUCTION_FORMAT3rms_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA VTABLE_INDEX ; 13993 public final smaliParser.insn_format3rms_method_return insn_format3rms_method() throws RecognitionException { 13994 smaliParser.insn_format3rms_method_return retval = new smaliParser.insn_format3rms_method_return(); 13995 retval.start = input.LT(1); 13996 13997 CommonTree root_0 = null; 13998 13999 Token INSTRUCTION_FORMAT3rms_METHOD463=null; 14000 Token OPEN_BRACE464=null; 14001 Token CLOSE_BRACE466=null; 14002 Token COMMA467=null; 14003 Token VTABLE_INDEX468=null; 14004 ParserRuleReturnScope register_range465 =null; 14005 14006 CommonTree INSTRUCTION_FORMAT3rms_METHOD463_tree=null; 14007 CommonTree OPEN_BRACE464_tree=null; 14008 CommonTree CLOSE_BRACE466_tree=null; 14009 CommonTree COMMA467_tree=null; 14010 CommonTree VTABLE_INDEX468_tree=null; 14011 14012 try { 14013 // smaliParser.g:1075:3: ( INSTRUCTION_FORMAT3rms_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA VTABLE_INDEX ) 14014 // smaliParser.g:1076:5: INSTRUCTION_FORMAT3rms_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA VTABLE_INDEX 14015 { 14016 root_0 = (CommonTree)adaptor.nil(); 14017 14018 14019 INSTRUCTION_FORMAT3rms_METHOD463=(Token)match(input,INSTRUCTION_FORMAT3rms_METHOD,FOLLOW_INSTRUCTION_FORMAT3rms_METHOD_in_insn_format3rms_method5493); 14020 INSTRUCTION_FORMAT3rms_METHOD463_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT3rms_METHOD463); 14021 adaptor.addChild(root_0, INSTRUCTION_FORMAT3rms_METHOD463_tree); 14022 14023 OPEN_BRACE464=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format3rms_method5495); 14024 OPEN_BRACE464_tree = (CommonTree)adaptor.create(OPEN_BRACE464); 14025 adaptor.addChild(root_0, OPEN_BRACE464_tree); 14026 14027 pushFollow(FOLLOW_register_range_in_insn_format3rms_method5497); 14028 register_range465=register_range(); 14029 state._fsp--; 14030 14031 adaptor.addChild(root_0, register_range465.getTree()); 14032 14033 CLOSE_BRACE466=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format3rms_method5499); 14034 CLOSE_BRACE466_tree = (CommonTree)adaptor.create(CLOSE_BRACE466); 14035 adaptor.addChild(root_0, CLOSE_BRACE466_tree); 14036 14037 COMMA467=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format3rms_method5501); 14038 COMMA467_tree = (CommonTree)adaptor.create(COMMA467); 14039 adaptor.addChild(root_0, COMMA467_tree); 14040 14041 VTABLE_INDEX468=(Token)match(input,VTABLE_INDEX,FOLLOW_VTABLE_INDEX_in_insn_format3rms_method5503); 14042 VTABLE_INDEX468_tree = (CommonTree)adaptor.create(VTABLE_INDEX468); 14043 adaptor.addChild(root_0, VTABLE_INDEX468_tree); 14044 14045 14046 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT3rms_METHOD463!=null?INSTRUCTION_FORMAT3rms_METHOD463.getText():null)); 14047 14048 } 14049 14050 retval.stop = input.LT(-1); 14051 14052 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 14053 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 14054 14055 } 14056 catch (RecognitionException re) { 14057 reportError(re); 14058 recover(input,re); 14059 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 14060 } 14061 finally { 14062 // do for sure before leaving 14063 } 14064 return retval; 14065 } 14066 // $ANTLR end "insn_format3rms_method" 14067 14068 14069 public static class insn_format45cc_method_return extends ParserRuleReturnScope { 14070 CommonTree tree; 14071 @Override 14072 public CommonTree getTree() { return tree; } 14073 }; 14074 14075 14076 // $ANTLR start "insn_format45cc_method" 14077 // smaliParser.g:1081:1: insn_format45cc_method : INSTRUCTION_FORMAT45cc_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference COMMA method_prototype -> ^( I_STATEMENT_FORMAT45cc_METHOD[$start, \"I_STATEMENT_FORMAT45cc_METHOD\"] INSTRUCTION_FORMAT45cc_METHOD register_list method_reference method_prototype ) ; 14078 public final smaliParser.insn_format45cc_method_return insn_format45cc_method() throws RecognitionException { 14079 smaliParser.insn_format45cc_method_return retval = new smaliParser.insn_format45cc_method_return(); 14080 retval.start = input.LT(1); 14081 14082 CommonTree root_0 = null; 14083 14084 Token INSTRUCTION_FORMAT45cc_METHOD469=null; 14085 Token OPEN_BRACE470=null; 14086 Token CLOSE_BRACE472=null; 14087 Token COMMA473=null; 14088 Token COMMA475=null; 14089 ParserRuleReturnScope register_list471 =null; 14090 ParserRuleReturnScope method_reference474 =null; 14091 ParserRuleReturnScope method_prototype476 =null; 14092 14093 CommonTree INSTRUCTION_FORMAT45cc_METHOD469_tree=null; 14094 CommonTree OPEN_BRACE470_tree=null; 14095 CommonTree CLOSE_BRACE472_tree=null; 14096 CommonTree COMMA473_tree=null; 14097 CommonTree COMMA475_tree=null; 14098 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 14099 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT45cc_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT45cc_METHOD"); 14100 RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE"); 14101 RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE"); 14102 RewriteRuleSubtreeStream stream_method_reference=new RewriteRuleSubtreeStream(adaptor,"rule method_reference"); 14103 RewriteRuleSubtreeStream stream_method_prototype=new RewriteRuleSubtreeStream(adaptor,"rule method_prototype"); 14104 RewriteRuleSubtreeStream stream_register_list=new RewriteRuleSubtreeStream(adaptor,"rule register_list"); 14105 14106 try { 14107 // smaliParser.g:1082:3: ( INSTRUCTION_FORMAT45cc_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference COMMA method_prototype -> ^( I_STATEMENT_FORMAT45cc_METHOD[$start, \"I_STATEMENT_FORMAT45cc_METHOD\"] INSTRUCTION_FORMAT45cc_METHOD register_list method_reference method_prototype ) ) 14108 // smaliParser.g:1083:5: INSTRUCTION_FORMAT45cc_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference COMMA method_prototype 14109 { 14110 INSTRUCTION_FORMAT45cc_METHOD469=(Token)match(input,INSTRUCTION_FORMAT45cc_METHOD,FOLLOW_INSTRUCTION_FORMAT45cc_METHOD_in_insn_format45cc_method5524); 14111 stream_INSTRUCTION_FORMAT45cc_METHOD.add(INSTRUCTION_FORMAT45cc_METHOD469); 14112 14113 OPEN_BRACE470=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format45cc_method5526); 14114 stream_OPEN_BRACE.add(OPEN_BRACE470); 14115 14116 pushFollow(FOLLOW_register_list_in_insn_format45cc_method5528); 14117 register_list471=register_list(); 14118 state._fsp--; 14119 14120 stream_register_list.add(register_list471.getTree()); 14121 CLOSE_BRACE472=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format45cc_method5530); 14122 stream_CLOSE_BRACE.add(CLOSE_BRACE472); 14123 14124 COMMA473=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format45cc_method5532); 14125 stream_COMMA.add(COMMA473); 14126 14127 pushFollow(FOLLOW_method_reference_in_insn_format45cc_method5534); 14128 method_reference474=method_reference(); 14129 state._fsp--; 14130 14131 stream_method_reference.add(method_reference474.getTree()); 14132 COMMA475=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format45cc_method5536); 14133 stream_COMMA.add(COMMA475); 14134 14135 pushFollow(FOLLOW_method_prototype_in_insn_format45cc_method5538); 14136 method_prototype476=method_prototype(); 14137 state._fsp--; 14138 14139 stream_method_prototype.add(method_prototype476.getTree()); 14140 // AST REWRITE 14141 // elements: method_reference, method_prototype, INSTRUCTION_FORMAT45cc_METHOD, register_list 14142 // token labels: 14143 // rule labels: retval 14144 // token list labels: 14145 // rule list labels: 14146 // wildcard labels: 14147 retval.tree = root_0; 14148 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 14149 14150 root_0 = (CommonTree)adaptor.nil(); 14151 // 1084:5: -> ^( I_STATEMENT_FORMAT45cc_METHOD[$start, \"I_STATEMENT_FORMAT45cc_METHOD\"] INSTRUCTION_FORMAT45cc_METHOD register_list method_reference method_prototype ) 14152 { 14153 // smaliParser.g:1084:8: ^( I_STATEMENT_FORMAT45cc_METHOD[$start, \"I_STATEMENT_FORMAT45cc_METHOD\"] INSTRUCTION_FORMAT45cc_METHOD register_list method_reference method_prototype ) 14154 { 14155 CommonTree root_1 = (CommonTree)adaptor.nil(); 14156 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT45cc_METHOD, (retval.start), "I_STATEMENT_FORMAT45cc_METHOD"), root_1); 14157 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT45cc_METHOD.nextNode()); 14158 adaptor.addChild(root_1, stream_register_list.nextTree()); 14159 adaptor.addChild(root_1, stream_method_reference.nextTree()); 14160 adaptor.addChild(root_1, stream_method_prototype.nextTree()); 14161 adaptor.addChild(root_0, root_1); 14162 } 14163 14164 } 14165 14166 14167 retval.tree = root_0; 14168 14169 } 14170 14171 retval.stop = input.LT(-1); 14172 14173 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 14174 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 14175 14176 } 14177 catch (RecognitionException re) { 14178 reportError(re); 14179 recover(input,re); 14180 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 14181 } 14182 finally { 14183 // do for sure before leaving 14184 } 14185 return retval; 14186 } 14187 // $ANTLR end "insn_format45cc_method" 14188 14189 14190 public static class insn_format4rcc_method_return extends ParserRuleReturnScope { 14191 CommonTree tree; 14192 @Override 14193 public CommonTree getTree() { return tree; } 14194 }; 14195 14196 14197 // $ANTLR start "insn_format4rcc_method" 14198 // smaliParser.g:1086:1: insn_format4rcc_method : INSTRUCTION_FORMAT4rcc_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA method_reference COMMA method_prototype -> ^( I_STATEMENT_FORMAT4rcc_METHOD[$start, \"I_STATEMENT_FORMAT4rcc_METHOD\"] INSTRUCTION_FORMAT4rcc_METHOD register_range method_reference method_prototype ) ; 14199 public final smaliParser.insn_format4rcc_method_return insn_format4rcc_method() throws RecognitionException { 14200 smaliParser.insn_format4rcc_method_return retval = new smaliParser.insn_format4rcc_method_return(); 14201 retval.start = input.LT(1); 14202 14203 CommonTree root_0 = null; 14204 14205 Token INSTRUCTION_FORMAT4rcc_METHOD477=null; 14206 Token OPEN_BRACE478=null; 14207 Token CLOSE_BRACE480=null; 14208 Token COMMA481=null; 14209 Token COMMA483=null; 14210 ParserRuleReturnScope register_range479 =null; 14211 ParserRuleReturnScope method_reference482 =null; 14212 ParserRuleReturnScope method_prototype484 =null; 14213 14214 CommonTree INSTRUCTION_FORMAT4rcc_METHOD477_tree=null; 14215 CommonTree OPEN_BRACE478_tree=null; 14216 CommonTree CLOSE_BRACE480_tree=null; 14217 CommonTree COMMA481_tree=null; 14218 CommonTree COMMA483_tree=null; 14219 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 14220 RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE"); 14221 RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE"); 14222 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT4rcc_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT4rcc_METHOD"); 14223 RewriteRuleSubtreeStream stream_method_reference=new RewriteRuleSubtreeStream(adaptor,"rule method_reference"); 14224 RewriteRuleSubtreeStream stream_method_prototype=new RewriteRuleSubtreeStream(adaptor,"rule method_prototype"); 14225 RewriteRuleSubtreeStream stream_register_range=new RewriteRuleSubtreeStream(adaptor,"rule register_range"); 14226 14227 try { 14228 // smaliParser.g:1087:3: ( INSTRUCTION_FORMAT4rcc_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA method_reference COMMA method_prototype -> ^( I_STATEMENT_FORMAT4rcc_METHOD[$start, \"I_STATEMENT_FORMAT4rcc_METHOD\"] INSTRUCTION_FORMAT4rcc_METHOD register_range method_reference method_prototype ) ) 14229 // smaliParser.g:1088:5: INSTRUCTION_FORMAT4rcc_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA method_reference COMMA method_prototype 14230 { 14231 INSTRUCTION_FORMAT4rcc_METHOD477=(Token)match(input,INSTRUCTION_FORMAT4rcc_METHOD,FOLLOW_INSTRUCTION_FORMAT4rcc_METHOD_in_insn_format4rcc_method5572); 14232 stream_INSTRUCTION_FORMAT4rcc_METHOD.add(INSTRUCTION_FORMAT4rcc_METHOD477); 14233 14234 OPEN_BRACE478=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format4rcc_method5574); 14235 stream_OPEN_BRACE.add(OPEN_BRACE478); 14236 14237 pushFollow(FOLLOW_register_range_in_insn_format4rcc_method5576); 14238 register_range479=register_range(); 14239 state._fsp--; 14240 14241 stream_register_range.add(register_range479.getTree()); 14242 CLOSE_BRACE480=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format4rcc_method5578); 14243 stream_CLOSE_BRACE.add(CLOSE_BRACE480); 14244 14245 COMMA481=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format4rcc_method5580); 14246 stream_COMMA.add(COMMA481); 14247 14248 pushFollow(FOLLOW_method_reference_in_insn_format4rcc_method5582); 14249 method_reference482=method_reference(); 14250 state._fsp--; 14251 14252 stream_method_reference.add(method_reference482.getTree()); 14253 COMMA483=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format4rcc_method5584); 14254 stream_COMMA.add(COMMA483); 14255 14256 pushFollow(FOLLOW_method_prototype_in_insn_format4rcc_method5586); 14257 method_prototype484=method_prototype(); 14258 state._fsp--; 14259 14260 stream_method_prototype.add(method_prototype484.getTree()); 14261 // AST REWRITE 14262 // elements: register_range, INSTRUCTION_FORMAT4rcc_METHOD, method_reference, method_prototype 14263 // token labels: 14264 // rule labels: retval 14265 // token list labels: 14266 // rule list labels: 14267 // wildcard labels: 14268 retval.tree = root_0; 14269 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 14270 14271 root_0 = (CommonTree)adaptor.nil(); 14272 // 1089:5: -> ^( I_STATEMENT_FORMAT4rcc_METHOD[$start, \"I_STATEMENT_FORMAT4rcc_METHOD\"] INSTRUCTION_FORMAT4rcc_METHOD register_range method_reference method_prototype ) 14273 { 14274 // smaliParser.g:1089:8: ^( I_STATEMENT_FORMAT4rcc_METHOD[$start, \"I_STATEMENT_FORMAT4rcc_METHOD\"] INSTRUCTION_FORMAT4rcc_METHOD register_range method_reference method_prototype ) 14275 { 14276 CommonTree root_1 = (CommonTree)adaptor.nil(); 14277 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT4rcc_METHOD, (retval.start), "I_STATEMENT_FORMAT4rcc_METHOD"), root_1); 14278 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT4rcc_METHOD.nextNode()); 14279 adaptor.addChild(root_1, stream_register_range.nextTree()); 14280 adaptor.addChild(root_1, stream_method_reference.nextTree()); 14281 adaptor.addChild(root_1, stream_method_prototype.nextTree()); 14282 adaptor.addChild(root_0, root_1); 14283 } 14284 14285 } 14286 14287 14288 retval.tree = root_0; 14289 14290 } 14291 14292 retval.stop = input.LT(-1); 14293 14294 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 14295 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 14296 14297 } 14298 catch (RecognitionException re) { 14299 reportError(re); 14300 recover(input,re); 14301 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 14302 } 14303 finally { 14304 // do for sure before leaving 14305 } 14306 return retval; 14307 } 14308 // $ANTLR end "insn_format4rcc_method" 14309 14310 14311 public static class insn_format51l_return extends ParserRuleReturnScope { 14312 CommonTree tree; 14313 @Override 14314 public CommonTree getTree() { return tree; } 14315 }; 14316 14317 14318 // $ANTLR start "insn_format51l" 14319 // smaliParser.g:1091:1: insn_format51l : INSTRUCTION_FORMAT51l REGISTER COMMA fixed_literal -> ^( I_STATEMENT_FORMAT51l[$start, \"I_STATEMENT_FORMAT51l\"] INSTRUCTION_FORMAT51l REGISTER fixed_literal ) ; 14320 public final smaliParser.insn_format51l_return insn_format51l() throws RecognitionException { 14321 smaliParser.insn_format51l_return retval = new smaliParser.insn_format51l_return(); 14322 retval.start = input.LT(1); 14323 14324 CommonTree root_0 = null; 14325 14326 Token INSTRUCTION_FORMAT51l485=null; 14327 Token REGISTER486=null; 14328 Token COMMA487=null; 14329 ParserRuleReturnScope fixed_literal488 =null; 14330 14331 CommonTree INSTRUCTION_FORMAT51l485_tree=null; 14332 CommonTree REGISTER486_tree=null; 14333 CommonTree COMMA487_tree=null; 14334 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 14335 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 14336 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT51l=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT51l"); 14337 RewriteRuleSubtreeStream stream_fixed_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_literal"); 14338 14339 try { 14340 // smaliParser.g:1092:3: ( INSTRUCTION_FORMAT51l REGISTER COMMA fixed_literal -> ^( I_STATEMENT_FORMAT51l[$start, \"I_STATEMENT_FORMAT51l\"] INSTRUCTION_FORMAT51l REGISTER fixed_literal ) ) 14341 // smaliParser.g:1093:5: INSTRUCTION_FORMAT51l REGISTER COMMA fixed_literal 14342 { 14343 INSTRUCTION_FORMAT51l485=(Token)match(input,INSTRUCTION_FORMAT51l,FOLLOW_INSTRUCTION_FORMAT51l_in_insn_format51l5620); 14344 stream_INSTRUCTION_FORMAT51l.add(INSTRUCTION_FORMAT51l485); 14345 14346 REGISTER486=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format51l5622); 14347 stream_REGISTER.add(REGISTER486); 14348 14349 COMMA487=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format51l5624); 14350 stream_COMMA.add(COMMA487); 14351 14352 pushFollow(FOLLOW_fixed_literal_in_insn_format51l5626); 14353 fixed_literal488=fixed_literal(); 14354 state._fsp--; 14355 14356 stream_fixed_literal.add(fixed_literal488.getTree()); 14357 // AST REWRITE 14358 // elements: REGISTER, INSTRUCTION_FORMAT51l, fixed_literal 14359 // token labels: 14360 // rule labels: retval 14361 // token list labels: 14362 // rule list labels: 14363 // wildcard labels: 14364 retval.tree = root_0; 14365 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 14366 14367 root_0 = (CommonTree)adaptor.nil(); 14368 // 1094:5: -> ^( I_STATEMENT_FORMAT51l[$start, \"I_STATEMENT_FORMAT51l\"] INSTRUCTION_FORMAT51l REGISTER fixed_literal ) 14369 { 14370 // smaliParser.g:1094:8: ^( I_STATEMENT_FORMAT51l[$start, \"I_STATEMENT_FORMAT51l\"] INSTRUCTION_FORMAT51l REGISTER fixed_literal ) 14371 { 14372 CommonTree root_1 = (CommonTree)adaptor.nil(); 14373 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT51l, (retval.start), "I_STATEMENT_FORMAT51l"), root_1); 14374 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT51l.nextNode()); 14375 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 14376 adaptor.addChild(root_1, stream_fixed_literal.nextTree()); 14377 adaptor.addChild(root_0, root_1); 14378 } 14379 14380 } 14381 14382 14383 retval.tree = root_0; 14384 14385 } 14386 14387 retval.stop = input.LT(-1); 14388 14389 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 14390 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 14391 14392 } 14393 catch (RecognitionException re) { 14394 reportError(re); 14395 recover(input,re); 14396 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 14397 } 14398 finally { 14399 // do for sure before leaving 14400 } 14401 return retval; 14402 } 14403 // $ANTLR end "insn_format51l" 14404 14405 14406 public static class insn_array_data_directive_return extends ParserRuleReturnScope { 14407 CommonTree tree; 14408 @Override 14409 public CommonTree getTree() { return tree; } 14410 }; 14411 14412 14413 // $ANTLR start "insn_array_data_directive" 14414 // smaliParser.g:1096:1: insn_array_data_directive : ARRAY_DATA_DIRECTIVE parsed_integer_literal ( fixed_literal )* END_ARRAY_DATA_DIRECTIVE -> ^( I_STATEMENT_ARRAY_DATA[$start, \"I_STATEMENT_ARRAY_DATA\"] ^( I_ARRAY_ELEMENT_SIZE parsed_integer_literal ) ^( I_ARRAY_ELEMENTS ( fixed_literal )* ) ) ; 14415 public final smaliParser.insn_array_data_directive_return insn_array_data_directive() throws RecognitionException { 14416 smaliParser.insn_array_data_directive_return retval = new smaliParser.insn_array_data_directive_return(); 14417 retval.start = input.LT(1); 14418 14419 CommonTree root_0 = null; 14420 14421 Token ARRAY_DATA_DIRECTIVE489=null; 14422 Token END_ARRAY_DATA_DIRECTIVE492=null; 14423 ParserRuleReturnScope parsed_integer_literal490 =null; 14424 ParserRuleReturnScope fixed_literal491 =null; 14425 14426 CommonTree ARRAY_DATA_DIRECTIVE489_tree=null; 14427 CommonTree END_ARRAY_DATA_DIRECTIVE492_tree=null; 14428 RewriteRuleTokenStream stream_END_ARRAY_DATA_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_ARRAY_DATA_DIRECTIVE"); 14429 RewriteRuleTokenStream stream_ARRAY_DATA_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token ARRAY_DATA_DIRECTIVE"); 14430 RewriteRuleSubtreeStream stream_parsed_integer_literal=new RewriteRuleSubtreeStream(adaptor,"rule parsed_integer_literal"); 14431 RewriteRuleSubtreeStream stream_fixed_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_literal"); 14432 14433 try { 14434 // smaliParser.g:1097:3: ( ARRAY_DATA_DIRECTIVE parsed_integer_literal ( fixed_literal )* END_ARRAY_DATA_DIRECTIVE -> ^( I_STATEMENT_ARRAY_DATA[$start, \"I_STATEMENT_ARRAY_DATA\"] ^( I_ARRAY_ELEMENT_SIZE parsed_integer_literal ) ^( I_ARRAY_ELEMENTS ( fixed_literal )* ) ) ) 14435 // smaliParser.g:1097:5: ARRAY_DATA_DIRECTIVE parsed_integer_literal ( fixed_literal )* END_ARRAY_DATA_DIRECTIVE 14436 { 14437 ARRAY_DATA_DIRECTIVE489=(Token)match(input,ARRAY_DATA_DIRECTIVE,FOLLOW_ARRAY_DATA_DIRECTIVE_in_insn_array_data_directive5653); 14438 stream_ARRAY_DATA_DIRECTIVE.add(ARRAY_DATA_DIRECTIVE489); 14439 14440 pushFollow(FOLLOW_parsed_integer_literal_in_insn_array_data_directive5659); 14441 parsed_integer_literal490=parsed_integer_literal(); 14442 state._fsp--; 14443 14444 stream_parsed_integer_literal.add(parsed_integer_literal490.getTree()); 14445 14446 int elementWidth = (parsed_integer_literal490!=null?((smaliParser.parsed_integer_literal_return)parsed_integer_literal490).value:0); 14447 if (elementWidth != 4 && elementWidth != 8 && elementWidth != 1 && elementWidth != 2) { 14448 throw new SemanticException(input, (retval.start), "Invalid element width: %d. Must be 1, 2, 4 or 8", elementWidth); 14449 } 14450 14451 // smaliParser.g:1105:5: ( fixed_literal )* 14452 loop52: 14453 while (true) { 14454 int alt52=2; 14455 int LA52_0 = input.LA(1); 14456 if ( ((LA52_0 >= BOOL_LITERAL && LA52_0 <= BYTE_LITERAL)||LA52_0==CHAR_LITERAL||(LA52_0 >= DOUBLE_LITERAL && LA52_0 <= DOUBLE_LITERAL_OR_ID)||(LA52_0 >= FLOAT_LITERAL && LA52_0 <= FLOAT_LITERAL_OR_ID)||LA52_0==LONG_LITERAL||LA52_0==NEGATIVE_INTEGER_LITERAL||LA52_0==POSITIVE_INTEGER_LITERAL||LA52_0==SHORT_LITERAL) ) { 14457 alt52=1; 14458 } 14459 14460 switch (alt52) { 14461 case 1 : 14462 // smaliParser.g:1105:5: fixed_literal 14463 { 14464 pushFollow(FOLLOW_fixed_literal_in_insn_array_data_directive5671); 14465 fixed_literal491=fixed_literal(); 14466 state._fsp--; 14467 14468 stream_fixed_literal.add(fixed_literal491.getTree()); 14469 } 14470 break; 14471 14472 default : 14473 break loop52; 14474 } 14475 } 14476 14477 END_ARRAY_DATA_DIRECTIVE492=(Token)match(input,END_ARRAY_DATA_DIRECTIVE,FOLLOW_END_ARRAY_DATA_DIRECTIVE_in_insn_array_data_directive5674); 14478 stream_END_ARRAY_DATA_DIRECTIVE.add(END_ARRAY_DATA_DIRECTIVE492); 14479 14480 // AST REWRITE 14481 // elements: parsed_integer_literal, fixed_literal 14482 // token labels: 14483 // rule labels: retval 14484 // token list labels: 14485 // rule list labels: 14486 // wildcard labels: 14487 retval.tree = root_0; 14488 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 14489 14490 root_0 = (CommonTree)adaptor.nil(); 14491 // 1107:5: -> ^( I_STATEMENT_ARRAY_DATA[$start, \"I_STATEMENT_ARRAY_DATA\"] ^( I_ARRAY_ELEMENT_SIZE parsed_integer_literal ) ^( I_ARRAY_ELEMENTS ( fixed_literal )* ) ) 14492 { 14493 // smaliParser.g:1107:8: ^( I_STATEMENT_ARRAY_DATA[$start, \"I_STATEMENT_ARRAY_DATA\"] ^( I_ARRAY_ELEMENT_SIZE parsed_integer_literal ) ^( I_ARRAY_ELEMENTS ( fixed_literal )* ) ) 14494 { 14495 CommonTree root_1 = (CommonTree)adaptor.nil(); 14496 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_ARRAY_DATA, (retval.start), "I_STATEMENT_ARRAY_DATA"), root_1); 14497 // smaliParser.g:1107:67: ^( I_ARRAY_ELEMENT_SIZE parsed_integer_literal ) 14498 { 14499 CommonTree root_2 = (CommonTree)adaptor.nil(); 14500 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ARRAY_ELEMENT_SIZE, "I_ARRAY_ELEMENT_SIZE"), root_2); 14501 adaptor.addChild(root_2, stream_parsed_integer_literal.nextTree()); 14502 adaptor.addChild(root_1, root_2); 14503 } 14504 14505 // smaliParser.g:1108:8: ^( I_ARRAY_ELEMENTS ( fixed_literal )* ) 14506 { 14507 CommonTree root_2 = (CommonTree)adaptor.nil(); 14508 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ARRAY_ELEMENTS, "I_ARRAY_ELEMENTS"), root_2); 14509 // smaliParser.g:1108:27: ( fixed_literal )* 14510 while ( stream_fixed_literal.hasNext() ) { 14511 adaptor.addChild(root_2, stream_fixed_literal.nextTree()); 14512 } 14513 stream_fixed_literal.reset(); 14514 14515 adaptor.addChild(root_1, root_2); 14516 } 14517 14518 adaptor.addChild(root_0, root_1); 14519 } 14520 14521 } 14522 14523 14524 retval.tree = root_0; 14525 14526 } 14527 14528 retval.stop = input.LT(-1); 14529 14530 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 14531 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 14532 14533 } 14534 catch (RecognitionException re) { 14535 reportError(re); 14536 recover(input,re); 14537 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 14538 } 14539 finally { 14540 // do for sure before leaving 14541 } 14542 return retval; 14543 } 14544 // $ANTLR end "insn_array_data_directive" 14545 14546 14547 public static class insn_packed_switch_directive_return extends ParserRuleReturnScope { 14548 CommonTree tree; 14549 @Override 14550 public CommonTree getTree() { return tree; } 14551 }; 14552 14553 14554 // $ANTLR start "insn_packed_switch_directive" 14555 // smaliParser.g:1110:1: insn_packed_switch_directive : PACKED_SWITCH_DIRECTIVE fixed_32bit_literal ( label_ref )* END_PACKED_SWITCH_DIRECTIVE -> ^( I_STATEMENT_PACKED_SWITCH[$start, \"I_STATEMENT_PACKED_SWITCH\"] ^( I_PACKED_SWITCH_START_KEY[$start, \"I_PACKED_SWITCH_START_KEY\"] fixed_32bit_literal ) ^( I_PACKED_SWITCH_ELEMENTS[$start, \"I_PACKED_SWITCH_ELEMENTS\"] ( label_ref )* ) ) ; 14556 public final smaliParser.insn_packed_switch_directive_return insn_packed_switch_directive() throws RecognitionException { 14557 smaliParser.insn_packed_switch_directive_return retval = new smaliParser.insn_packed_switch_directive_return(); 14558 retval.start = input.LT(1); 14559 14560 CommonTree root_0 = null; 14561 14562 Token PACKED_SWITCH_DIRECTIVE493=null; 14563 Token END_PACKED_SWITCH_DIRECTIVE496=null; 14564 ParserRuleReturnScope fixed_32bit_literal494 =null; 14565 ParserRuleReturnScope label_ref495 =null; 14566 14567 CommonTree PACKED_SWITCH_DIRECTIVE493_tree=null; 14568 CommonTree END_PACKED_SWITCH_DIRECTIVE496_tree=null; 14569 RewriteRuleTokenStream stream_END_PACKED_SWITCH_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_PACKED_SWITCH_DIRECTIVE"); 14570 RewriteRuleTokenStream stream_PACKED_SWITCH_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token PACKED_SWITCH_DIRECTIVE"); 14571 RewriteRuleSubtreeStream stream_fixed_32bit_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_32bit_literal"); 14572 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 14573 14574 try { 14575 // smaliParser.g:1111:5: ( PACKED_SWITCH_DIRECTIVE fixed_32bit_literal ( label_ref )* END_PACKED_SWITCH_DIRECTIVE -> ^( I_STATEMENT_PACKED_SWITCH[$start, \"I_STATEMENT_PACKED_SWITCH\"] ^( I_PACKED_SWITCH_START_KEY[$start, \"I_PACKED_SWITCH_START_KEY\"] fixed_32bit_literal ) ^( I_PACKED_SWITCH_ELEMENTS[$start, \"I_PACKED_SWITCH_ELEMENTS\"] ( label_ref )* ) ) ) 14576 // smaliParser.g:1111:9: PACKED_SWITCH_DIRECTIVE fixed_32bit_literal ( label_ref )* END_PACKED_SWITCH_DIRECTIVE 14577 { 14578 PACKED_SWITCH_DIRECTIVE493=(Token)match(input,PACKED_SWITCH_DIRECTIVE,FOLLOW_PACKED_SWITCH_DIRECTIVE_in_insn_packed_switch_directive5720); 14579 stream_PACKED_SWITCH_DIRECTIVE.add(PACKED_SWITCH_DIRECTIVE493); 14580 14581 pushFollow(FOLLOW_fixed_32bit_literal_in_insn_packed_switch_directive5726); 14582 fixed_32bit_literal494=fixed_32bit_literal(); 14583 state._fsp--; 14584 14585 stream_fixed_32bit_literal.add(fixed_32bit_literal494.getTree()); 14586 // smaliParser.g:1113:5: ( label_ref )* 14587 loop53: 14588 while (true) { 14589 int alt53=2; 14590 int LA53_0 = input.LA(1); 14591 if ( (LA53_0==COLON) ) { 14592 alt53=1; 14593 } 14594 14595 switch (alt53) { 14596 case 1 : 14597 // smaliParser.g:1113:5: label_ref 14598 { 14599 pushFollow(FOLLOW_label_ref_in_insn_packed_switch_directive5732); 14600 label_ref495=label_ref(); 14601 state._fsp--; 14602 14603 stream_label_ref.add(label_ref495.getTree()); 14604 } 14605 break; 14606 14607 default : 14608 break loop53; 14609 } 14610 } 14611 14612 END_PACKED_SWITCH_DIRECTIVE496=(Token)match(input,END_PACKED_SWITCH_DIRECTIVE,FOLLOW_END_PACKED_SWITCH_DIRECTIVE_in_insn_packed_switch_directive5739); 14613 stream_END_PACKED_SWITCH_DIRECTIVE.add(END_PACKED_SWITCH_DIRECTIVE496); 14614 14615 // AST REWRITE 14616 // elements: fixed_32bit_literal, label_ref 14617 // token labels: 14618 // rule labels: retval 14619 // token list labels: 14620 // rule list labels: 14621 // wildcard labels: 14622 retval.tree = root_0; 14623 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 14624 14625 root_0 = (CommonTree)adaptor.nil(); 14626 // 1115:5: -> ^( I_STATEMENT_PACKED_SWITCH[$start, \"I_STATEMENT_PACKED_SWITCH\"] ^( I_PACKED_SWITCH_START_KEY[$start, \"I_PACKED_SWITCH_START_KEY\"] fixed_32bit_literal ) ^( I_PACKED_SWITCH_ELEMENTS[$start, \"I_PACKED_SWITCH_ELEMENTS\"] ( label_ref )* ) ) 14627 { 14628 // smaliParser.g:1115:8: ^( I_STATEMENT_PACKED_SWITCH[$start, \"I_STATEMENT_PACKED_SWITCH\"] ^( I_PACKED_SWITCH_START_KEY[$start, \"I_PACKED_SWITCH_START_KEY\"] fixed_32bit_literal ) ^( I_PACKED_SWITCH_ELEMENTS[$start, \"I_PACKED_SWITCH_ELEMENTS\"] ( label_ref )* ) ) 14629 { 14630 CommonTree root_1 = (CommonTree)adaptor.nil(); 14631 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_PACKED_SWITCH, (retval.start), "I_STATEMENT_PACKED_SWITCH"), root_1); 14632 // smaliParser.g:1116:10: ^( I_PACKED_SWITCH_START_KEY[$start, \"I_PACKED_SWITCH_START_KEY\"] fixed_32bit_literal ) 14633 { 14634 CommonTree root_2 = (CommonTree)adaptor.nil(); 14635 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_PACKED_SWITCH_START_KEY, (retval.start), "I_PACKED_SWITCH_START_KEY"), root_2); 14636 adaptor.addChild(root_2, stream_fixed_32bit_literal.nextTree()); 14637 adaptor.addChild(root_1, root_2); 14638 } 14639 14640 // smaliParser.g:1117:10: ^( I_PACKED_SWITCH_ELEMENTS[$start, \"I_PACKED_SWITCH_ELEMENTS\"] ( label_ref )* ) 14641 { 14642 CommonTree root_2 = (CommonTree)adaptor.nil(); 14643 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_PACKED_SWITCH_ELEMENTS, (retval.start), "I_PACKED_SWITCH_ELEMENTS"), root_2); 14644 // smaliParser.g:1118:11: ( label_ref )* 14645 while ( stream_label_ref.hasNext() ) { 14646 adaptor.addChild(root_2, stream_label_ref.nextTree()); 14647 } 14648 stream_label_ref.reset(); 14649 14650 adaptor.addChild(root_1, root_2); 14651 } 14652 14653 adaptor.addChild(root_0, root_1); 14654 } 14655 14656 } 14657 14658 14659 retval.tree = root_0; 14660 14661 } 14662 14663 retval.stop = input.LT(-1); 14664 14665 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 14666 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 14667 14668 } 14669 catch (RecognitionException re) { 14670 reportError(re); 14671 recover(input,re); 14672 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 14673 } 14674 finally { 14675 // do for sure before leaving 14676 } 14677 return retval; 14678 } 14679 // $ANTLR end "insn_packed_switch_directive" 14680 14681 14682 public static class insn_sparse_switch_directive_return extends ParserRuleReturnScope { 14683 CommonTree tree; 14684 @Override 14685 public CommonTree getTree() { return tree; } 14686 }; 14687 14688 14689 // $ANTLR start "insn_sparse_switch_directive" 14690 // smaliParser.g:1121:1: insn_sparse_switch_directive : SPARSE_SWITCH_DIRECTIVE ( fixed_32bit_literal ARROW label_ref )* END_SPARSE_SWITCH_DIRECTIVE -> ^( I_STATEMENT_SPARSE_SWITCH[$start, \"I_STATEMENT_SPARSE_SWITCH\"] ^( I_SPARSE_SWITCH_ELEMENTS[$start, \"I_SPARSE_SWITCH_ELEMENTS\"] ( fixed_32bit_literal label_ref )* ) ) ; 14691 public final smaliParser.insn_sparse_switch_directive_return insn_sparse_switch_directive() throws RecognitionException { 14692 smaliParser.insn_sparse_switch_directive_return retval = new smaliParser.insn_sparse_switch_directive_return(); 14693 retval.start = input.LT(1); 14694 14695 CommonTree root_0 = null; 14696 14697 Token SPARSE_SWITCH_DIRECTIVE497=null; 14698 Token ARROW499=null; 14699 Token END_SPARSE_SWITCH_DIRECTIVE501=null; 14700 ParserRuleReturnScope fixed_32bit_literal498 =null; 14701 ParserRuleReturnScope label_ref500 =null; 14702 14703 CommonTree SPARSE_SWITCH_DIRECTIVE497_tree=null; 14704 CommonTree ARROW499_tree=null; 14705 CommonTree END_SPARSE_SWITCH_DIRECTIVE501_tree=null; 14706 RewriteRuleTokenStream stream_ARROW=new RewriteRuleTokenStream(adaptor,"token ARROW"); 14707 RewriteRuleTokenStream stream_SPARSE_SWITCH_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token SPARSE_SWITCH_DIRECTIVE"); 14708 RewriteRuleTokenStream stream_END_SPARSE_SWITCH_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_SPARSE_SWITCH_DIRECTIVE"); 14709 RewriteRuleSubtreeStream stream_fixed_32bit_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_32bit_literal"); 14710 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 14711 14712 try { 14713 // smaliParser.g:1122:3: ( SPARSE_SWITCH_DIRECTIVE ( fixed_32bit_literal ARROW label_ref )* END_SPARSE_SWITCH_DIRECTIVE -> ^( I_STATEMENT_SPARSE_SWITCH[$start, \"I_STATEMENT_SPARSE_SWITCH\"] ^( I_SPARSE_SWITCH_ELEMENTS[$start, \"I_SPARSE_SWITCH_ELEMENTS\"] ( fixed_32bit_literal label_ref )* ) ) ) 14714 // smaliParser.g:1122:7: SPARSE_SWITCH_DIRECTIVE ( fixed_32bit_literal ARROW label_ref )* END_SPARSE_SWITCH_DIRECTIVE 14715 { 14716 SPARSE_SWITCH_DIRECTIVE497=(Token)match(input,SPARSE_SWITCH_DIRECTIVE,FOLLOW_SPARSE_SWITCH_DIRECTIVE_in_insn_sparse_switch_directive5813); 14717 stream_SPARSE_SWITCH_DIRECTIVE.add(SPARSE_SWITCH_DIRECTIVE497); 14718 14719 // smaliParser.g:1123:5: ( fixed_32bit_literal ARROW label_ref )* 14720 loop54: 14721 while (true) { 14722 int alt54=2; 14723 int LA54_0 = input.LA(1); 14724 if ( ((LA54_0 >= BOOL_LITERAL && LA54_0 <= BYTE_LITERAL)||LA54_0==CHAR_LITERAL||(LA54_0 >= FLOAT_LITERAL && LA54_0 <= FLOAT_LITERAL_OR_ID)||LA54_0==LONG_LITERAL||LA54_0==NEGATIVE_INTEGER_LITERAL||LA54_0==POSITIVE_INTEGER_LITERAL||LA54_0==SHORT_LITERAL) ) { 14725 alt54=1; 14726 } 14727 14728 switch (alt54) { 14729 case 1 : 14730 // smaliParser.g:1123:6: fixed_32bit_literal ARROW label_ref 14731 { 14732 pushFollow(FOLLOW_fixed_32bit_literal_in_insn_sparse_switch_directive5820); 14733 fixed_32bit_literal498=fixed_32bit_literal(); 14734 state._fsp--; 14735 14736 stream_fixed_32bit_literal.add(fixed_32bit_literal498.getTree()); 14737 ARROW499=(Token)match(input,ARROW,FOLLOW_ARROW_in_insn_sparse_switch_directive5822); 14738 stream_ARROW.add(ARROW499); 14739 14740 pushFollow(FOLLOW_label_ref_in_insn_sparse_switch_directive5824); 14741 label_ref500=label_ref(); 14742 state._fsp--; 14743 14744 stream_label_ref.add(label_ref500.getTree()); 14745 } 14746 break; 14747 14748 default : 14749 break loop54; 14750 } 14751 } 14752 14753 END_SPARSE_SWITCH_DIRECTIVE501=(Token)match(input,END_SPARSE_SWITCH_DIRECTIVE,FOLLOW_END_SPARSE_SWITCH_DIRECTIVE_in_insn_sparse_switch_directive5832); 14754 stream_END_SPARSE_SWITCH_DIRECTIVE.add(END_SPARSE_SWITCH_DIRECTIVE501); 14755 14756 // AST REWRITE 14757 // elements: fixed_32bit_literal, label_ref 14758 // token labels: 14759 // rule labels: retval 14760 // token list labels: 14761 // rule list labels: 14762 // wildcard labels: 14763 retval.tree = root_0; 14764 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 14765 14766 root_0 = (CommonTree)adaptor.nil(); 14767 // 1125:5: -> ^( I_STATEMENT_SPARSE_SWITCH[$start, \"I_STATEMENT_SPARSE_SWITCH\"] ^( I_SPARSE_SWITCH_ELEMENTS[$start, \"I_SPARSE_SWITCH_ELEMENTS\"] ( fixed_32bit_literal label_ref )* ) ) 14768 { 14769 // smaliParser.g:1125:8: ^( I_STATEMENT_SPARSE_SWITCH[$start, \"I_STATEMENT_SPARSE_SWITCH\"] ^( I_SPARSE_SWITCH_ELEMENTS[$start, \"I_SPARSE_SWITCH_ELEMENTS\"] ( fixed_32bit_literal label_ref )* ) ) 14770 { 14771 CommonTree root_1 = (CommonTree)adaptor.nil(); 14772 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_SPARSE_SWITCH, (retval.start), "I_STATEMENT_SPARSE_SWITCH"), root_1); 14773 // smaliParser.g:1126:8: ^( I_SPARSE_SWITCH_ELEMENTS[$start, \"I_SPARSE_SWITCH_ELEMENTS\"] ( fixed_32bit_literal label_ref )* ) 14774 { 14775 CommonTree root_2 = (CommonTree)adaptor.nil(); 14776 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_SPARSE_SWITCH_ELEMENTS, (retval.start), "I_SPARSE_SWITCH_ELEMENTS"), root_2); 14777 // smaliParser.g:1126:71: ( fixed_32bit_literal label_ref )* 14778 while ( stream_fixed_32bit_literal.hasNext()||stream_label_ref.hasNext() ) { 14779 adaptor.addChild(root_2, stream_fixed_32bit_literal.nextTree()); 14780 adaptor.addChild(root_2, stream_label_ref.nextTree()); 14781 } 14782 stream_fixed_32bit_literal.reset(); 14783 stream_label_ref.reset(); 14784 14785 adaptor.addChild(root_1, root_2); 14786 } 14787 14788 adaptor.addChild(root_0, root_1); 14789 } 14790 14791 } 14792 14793 14794 retval.tree = root_0; 14795 14796 } 14797 14798 retval.stop = input.LT(-1); 14799 14800 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 14801 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 14802 14803 } 14804 catch (RecognitionException re) { 14805 reportError(re); 14806 recover(input,re); 14807 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 14808 } 14809 finally { 14810 // do for sure before leaving 14811 } 14812 return retval; 14813 } 14814 // $ANTLR end "insn_sparse_switch_directive" 14815 14816 // Delegated rules 14817 14818 14819 protected DFA30 dfa30 = new DFA30(this); 14820 protected DFA38 dfa38 = new DFA38(this); 14821 protected DFA40 dfa40 = new DFA40(this); 14822 static final String DFA30_eotS = 14823 "\55\uffff"; 14824 static final String DFA30_eofS = 14825 "\55\uffff"; 14826 static final String DFA30_minS = 14827 "\1\4\52\23\2\uffff"; 14828 static final String DFA30_maxS = 14829 "\1\u00c6\12\u00b4\1\u00b7\37\u00b4\2\uffff"; 14830 static final String DFA30_acceptS = 14831 "\53\uffff\1\1\1\2"; 14832 static final String DFA30_specialS = 14833 "\55\uffff}>"; 14834 static final String[] DFA30_transitionS = { 14835 "\1\2\1\uffff\1\16\3\uffff\1\10\14\uffff\1\7\17\uffff\1\6\2\uffff\1\17"+ 14836 "\1\20\1\21\1\uffff\1\22\1\uffff\1\23\2\uffff\1\24\1\25\1\26\1\27\3\uffff"+ 14837 "\1\30\1\uffff\1\31\1\32\1\33\1\34\1\uffff\1\35\1\36\1\uffff\1\37\3\uffff"+ 14838 "\1\40\1\41\1\uffff\1\42\1\43\1\44\1\45\1\46\5\uffff\1\47\1\50\1\51\127"+ 14839 "\uffff\1\52\1\uffff\1\5\1\11\4\uffff\1\13\1\4\1\14\1\uffff\1\12\3\uffff"+ 14840 "\1\1\5\uffff\1\3\1\15", 14841 "\1\53\u00a0\uffff\1\54", 14842 "\1\53\u00a0\uffff\1\54", 14843 "\1\53\u00a0\uffff\1\54", 14844 "\1\53\u00a0\uffff\1\54", 14845 "\1\53\u00a0\uffff\1\54", 14846 "\1\53\u00a0\uffff\1\54", 14847 "\1\53\u00a0\uffff\1\54", 14848 "\1\53\u00a0\uffff\1\54", 14849 "\1\53\u00a0\uffff\1\54", 14850 "\1\53\u00a0\uffff\1\54", 14851 "\1\53\u00a0\uffff\1\54\2\uffff\1\13", 14852 "\1\53\u00a0\uffff\1\54", 14853 "\1\53\u00a0\uffff\1\54", 14854 "\1\53\u00a0\uffff\1\54", 14855 "\1\53\u00a0\uffff\1\54", 14856 "\1\53\u00a0\uffff\1\54", 14857 "\1\53\u00a0\uffff\1\54", 14858 "\1\53\u00a0\uffff\1\54", 14859 "\1\53\u00a0\uffff\1\54", 14860 "\1\53\u00a0\uffff\1\54", 14861 "\1\53\u00a0\uffff\1\54", 14862 "\1\53\u00a0\uffff\1\54", 14863 "\1\53\u00a0\uffff\1\54", 14864 "\1\53\u00a0\uffff\1\54", 14865 "\1\53\u00a0\uffff\1\54", 14866 "\1\53\u00a0\uffff\1\54", 14867 "\1\53\u00a0\uffff\1\54", 14868 "\1\53\u00a0\uffff\1\54", 14869 "\1\53\u00a0\uffff\1\54", 14870 "\1\53\u00a0\uffff\1\54", 14871 "\1\53\u00a0\uffff\1\54", 14872 "\1\53\u00a0\uffff\1\54", 14873 "\1\53\u00a0\uffff\1\54", 14874 "\1\53\u00a0\uffff\1\54", 14875 "\1\53\u00a0\uffff\1\54", 14876 "\1\53\u00a0\uffff\1\54", 14877 "\1\53\u00a0\uffff\1\54", 14878 "\1\53\u00a0\uffff\1\54", 14879 "\1\53\u00a0\uffff\1\54", 14880 "\1\53\u00a0\uffff\1\54", 14881 "\1\53\u00a0\uffff\1\54", 14882 "\1\53\u00a0\uffff\1\54", 14883 "", 14884 "" 14885 }; 14886 14887 static final short[] DFA30_eot = DFA.unpackEncodedString(DFA30_eotS); 14888 static final short[] DFA30_eof = DFA.unpackEncodedString(DFA30_eofS); 14889 static final char[] DFA30_min = DFA.unpackEncodedStringToUnsignedChars(DFA30_minS); 14890 static final char[] DFA30_max = DFA.unpackEncodedStringToUnsignedChars(DFA30_maxS); 14891 static final short[] DFA30_accept = DFA.unpackEncodedString(DFA30_acceptS); 14892 static final short[] DFA30_special = DFA.unpackEncodedString(DFA30_specialS); 14893 static final short[][] DFA30_transition; 14894 14895 static { 14896 int numStates = DFA30_transitionS.length; 14897 DFA30_transition = new short[numStates][]; 14898 for (int i=0; i<numStates; i++) { 14899 DFA30_transition[i] = DFA.unpackEncodedString(DFA30_transitionS[i]); 14900 } 14901 } 14902 14903 protected class DFA30 extends DFA { 14904 14905 public DFA30(BaseRecognizer recognizer) { 14906 this.recognizer = recognizer; 14907 this.decisionNumber = 30; 14908 this.eot = DFA30_eot; 14909 this.eof = DFA30_eof; 14910 this.min = DFA30_min; 14911 this.max = DFA30_max; 14912 this.accept = DFA30_accept; 14913 this.special = DFA30_special; 14914 this.transition = DFA30_transition; 14915 } 14916 @Override 14917 public String getDescription() { 14918 return "695:7: ( member_name COLON nonvoid_type_descriptor -> ^( I_ENCODED_FIELD ( reference_type_descriptor )? member_name nonvoid_type_descriptor ) | member_name method_prototype -> ^( I_ENCODED_METHOD ( reference_type_descriptor )? member_name method_prototype ) )"; 14919 } 14920 } 14921 14922 static final String DFA38_eotS = 14923 "\62\uffff"; 14924 static final String DFA38_eofS = 14925 "\62\uffff"; 14926 static final String DFA38_minS = 14927 "\1\4\1\5\1\17\52\23\1\uffff\1\4\1\11\2\uffff"; 14928 static final String DFA38_maxS = 14929 "\1\u00c6\1\u00c1\1\u00b9\12\u00b4\1\u00b7\37\u00b4\1\uffff\1\u00c6\1\11"+ 14930 "\2\uffff"; 14931 static final String DFA38_acceptS = 14932 "\55\uffff\1\1\2\uffff\1\2\1\3"; 14933 static final String DFA38_specialS = 14934 "\62\uffff}>"; 14935 static final String[] DFA38_transitionS = { 14936 "\1\4\1\uffff\1\20\1\uffff\1\2\1\uffff\1\12\4\uffff\1\1\7\uffff\1\11\17"+ 14937 "\uffff\1\10\2\uffff\1\21\1\22\1\23\1\uffff\1\24\1\uffff\1\25\2\uffff"+ 14938 "\1\26\1\27\1\30\1\31\3\uffff\1\32\1\uffff\1\33\1\34\1\35\1\36\1\uffff"+ 14939 "\1\37\1\40\1\uffff\1\41\3\uffff\1\42\1\43\1\uffff\1\44\1\45\1\46\1\47"+ 14940 "\1\50\5\uffff\1\51\1\52\1\53\127\uffff\1\54\1\uffff\1\7\1\13\4\uffff"+ 14941 "\1\15\1\6\1\16\1\uffff\1\14\3\uffff\1\3\5\uffff\1\5\1\17", 14942 "\1\55\1\uffff\1\55\1\uffff\1\56\2\uffff\2\55\5\uffff\1\55\7\uffff\2"+ 14943 "\55\5\uffff\1\55\7\uffff\56\55\123\uffff\3\55\7\uffff\2\55\3\uffff\1"+ 14944 "\55\1\uffff\2\55\2\uffff\2\55", 14945 "\1\57\u00a9\uffff\1\57", 14946 "\1\60\u00a0\uffff\1\61", 14947 "\1\60\u00a0\uffff\1\61", 14948 "\1\60\u00a0\uffff\1\61", 14949 "\1\60\u00a0\uffff\1\61", 14950 "\1\60\u00a0\uffff\1\61", 14951 "\1\60\u00a0\uffff\1\61", 14952 "\1\60\u00a0\uffff\1\61", 14953 "\1\60\u00a0\uffff\1\61", 14954 "\1\60\u00a0\uffff\1\61", 14955 "\1\60\u00a0\uffff\1\61", 14956 "\1\60\u00a0\uffff\1\61\2\uffff\1\15", 14957 "\1\60\u00a0\uffff\1\61", 14958 "\1\60\u00a0\uffff\1\61", 14959 "\1\60\u00a0\uffff\1\61", 14960 "\1\60\u00a0\uffff\1\61", 14961 "\1\60\u00a0\uffff\1\61", 14962 "\1\60\u00a0\uffff\1\61", 14963 "\1\60\u00a0\uffff\1\61", 14964 "\1\60\u00a0\uffff\1\61", 14965 "\1\60\u00a0\uffff\1\61", 14966 "\1\60\u00a0\uffff\1\61", 14967 "\1\60\u00a0\uffff\1\61", 14968 "\1\60\u00a0\uffff\1\61", 14969 "\1\60\u00a0\uffff\1\61", 14970 "\1\60\u00a0\uffff\1\61", 14971 "\1\60\u00a0\uffff\1\61", 14972 "\1\60\u00a0\uffff\1\61", 14973 "\1\60\u00a0\uffff\1\61", 14974 "\1\60\u00a0\uffff\1\61", 14975 "\1\60\u00a0\uffff\1\61", 14976 "\1\60\u00a0\uffff\1\61", 14977 "\1\60\u00a0\uffff\1\61", 14978 "\1\60\u00a0\uffff\1\61", 14979 "\1\60\u00a0\uffff\1\61", 14980 "\1\60\u00a0\uffff\1\61", 14981 "\1\60\u00a0\uffff\1\61", 14982 "\1\60\u00a0\uffff\1\61", 14983 "\1\60\u00a0\uffff\1\61", 14984 "\1\60\u00a0\uffff\1\61", 14985 "\1\60\u00a0\uffff\1\61", 14986 "\1\60\u00a0\uffff\1\61", 14987 "\1\60\u00a0\uffff\1\61", 14988 "", 14989 "\1\4\1\uffff\1\20\3\uffff\1\12\14\uffff\1\11\17\uffff\1\10\2\uffff\1"+ 14990 "\21\1\22\1\23\1\uffff\1\24\1\uffff\1\25\2\uffff\1\26\1\27\1\30\1\31\3"+ 14991 "\uffff\1\32\1\uffff\1\33\1\34\1\35\1\36\1\uffff\1\37\1\40\1\uffff\1\41"+ 14992 "\3\uffff\1\42\1\43\1\uffff\1\44\1\45\1\46\1\47\1\50\5\uffff\1\51\1\52"+ 14993 "\1\53\127\uffff\1\54\1\uffff\1\7\1\13\4\uffff\1\15\1\6\1\16\1\uffff\1"+ 14994 "\14\3\uffff\1\3\5\uffff\1\5\1\17", 14995 "\1\56", 14996 "", 14997 "" 14998 }; 14999 15000 static final short[] DFA38_eot = DFA.unpackEncodedString(DFA38_eotS); 15001 static final short[] DFA38_eof = DFA.unpackEncodedString(DFA38_eofS); 15002 static final char[] DFA38_min = DFA.unpackEncodedStringToUnsignedChars(DFA38_minS); 15003 static final char[] DFA38_max = DFA.unpackEncodedStringToUnsignedChars(DFA38_maxS); 15004 static final short[] DFA38_accept = DFA.unpackEncodedString(DFA38_acceptS); 15005 static final short[] DFA38_special = DFA.unpackEncodedString(DFA38_specialS); 15006 static final short[][] DFA38_transition; 15007 15008 static { 15009 int numStates = DFA38_transitionS.length; 15010 DFA38_transition = new short[numStates][]; 15011 for (int i=0; i<numStates; i++) { 15012 DFA38_transition[i] = DFA.unpackEncodedString(DFA38_transitionS[i]); 15013 } 15014 } 15015 15016 protected class DFA38 extends DFA { 15017 15018 public DFA38(BaseRecognizer recognizer) { 15019 this.recognizer = recognizer; 15020 this.decisionNumber = 38; 15021 this.eot = DFA38_eot; 15022 this.eof = DFA38_eof; 15023 this.min = DFA38_min; 15024 this.max = DFA38_max; 15025 this.accept = DFA38_accept; 15026 this.special = DFA38_special; 15027 this.transition = DFA38_transition; 15028 } 15029 @Override 15030 public String getDescription() { 15031 return "723:1: verification_error_reference : ( CLASS_DESCRIPTOR | field_reference | method_reference );"; 15032 } 15033 } 15034 15035 static final String DFA40_eotS = 15036 "\103\uffff"; 15037 static final String DFA40_eofS = 15038 "\103\uffff"; 15039 static final String DFA40_minS = 15040 "\1\5\100\uffff\1\0\1\uffff"; 15041 static final String DFA40_maxS = 15042 "\1\u00c1\100\uffff\1\0\1\uffff"; 15043 static final String DFA40_acceptS = 15044 "\1\uffff\1\2\100\uffff\1\1"; 15045 static final String DFA40_specialS = 15046 "\101\uffff\1\0\1\uffff}>"; 15047 static final String[] DFA40_transitionS = { 15048 "\1\101\1\uffff\1\1\4\uffff\2\1\5\uffff\1\1\7\uffff\2\1\1\uffff\1\1\3"+ 15049 "\uffff\1\1\7\uffff\56\1\123\uffff\3\1\7\uffff\2\1\3\uffff\1\1\1\uffff"+ 15050 "\2\1\2\uffff\2\1", 15051 "", 15052 "", 15053 "", 15054 "", 15055 "", 15056 "", 15057 "", 15058 "", 15059 "", 15060 "", 15061 "", 15062 "", 15063 "", 15064 "", 15065 "", 15066 "", 15067 "", 15068 "", 15069 "", 15070 "", 15071 "", 15072 "", 15073 "", 15074 "", 15075 "", 15076 "", 15077 "", 15078 "", 15079 "", 15080 "", 15081 "", 15082 "", 15083 "", 15084 "", 15085 "", 15086 "", 15087 "", 15088 "", 15089 "", 15090 "", 15091 "", 15092 "", 15093 "", 15094 "", 15095 "", 15096 "", 15097 "", 15098 "", 15099 "", 15100 "", 15101 "", 15102 "", 15103 "", 15104 "", 15105 "", 15106 "", 15107 "", 15108 "", 15109 "", 15110 "", 15111 "", 15112 "", 15113 "", 15114 "", 15115 "\1\uffff", 15116 "" 15117 }; 15118 15119 static final short[] DFA40_eot = DFA.unpackEncodedString(DFA40_eotS); 15120 static final short[] DFA40_eof = DFA.unpackEncodedString(DFA40_eofS); 15121 static final char[] DFA40_min = DFA.unpackEncodedStringToUnsignedChars(DFA40_minS); 15122 static final char[] DFA40_max = DFA.unpackEncodedStringToUnsignedChars(DFA40_maxS); 15123 static final short[] DFA40_accept = DFA.unpackEncodedString(DFA40_acceptS); 15124 static final short[] DFA40_special = DFA.unpackEncodedString(DFA40_specialS); 15125 static final short[][] DFA40_transition; 15126 15127 static { 15128 int numStates = DFA40_transitionS.length; 15129 DFA40_transition = new short[numStates][]; 15130 for (int i=0; i<numStates; i++) { 15131 DFA40_transition[i] = DFA.unpackEncodedString(DFA40_transitionS[i]); 15132 } 15133 } 15134 15135 protected class DFA40 extends DFA { 15136 15137 public DFA40(BaseRecognizer recognizer) { 15138 this.recognizer = recognizer; 15139 this.decisionNumber = 40; 15140 this.eot = DFA40_eot; 15141 this.eof = DFA40_eof; 15142 this.min = DFA40_min; 15143 this.max = DFA40_max; 15144 this.accept = DFA40_accept; 15145 this.special = DFA40_special; 15146 this.transition = DFA40_transition; 15147 } 15148 @Override 15149 public String getDescription() { 15150 return "()* loopback of 741:5: ({...}? annotation )*"; 15151 } 15152 @Override 15153 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { 15154 TokenStream input = (TokenStream)_input; 15155 int _s = s; 15156 switch ( s ) { 15157 case 0 : 15158 int LA40_65 = input.LA(1); 15159 15160 int index40_65 = input.index(); 15161 input.rewind(); 15162 s = -1; 15163 if ( ((input.LA(1) == ANNOTATION_DIRECTIVE)) ) {s = 66;} 15164 else if ( (true) ) {s = 1;} 15165 15166 input.seek(index40_65); 15167 if ( s>=0 ) return s; 15168 break; 15169 } 15170 NoViableAltException nvae = 15171 new NoViableAltException(getDescription(), 40, _s, input); 15172 error(nvae); 15173 throw nvae; 15174 } 15175 } 15176 15177 public static final BitSet FOLLOW_class_spec_in_smali_file1075 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x0001000000000000L,0x0000000000000011L}); 15178 public static final BitSet FOLLOW_super_spec_in_smali_file1086 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x0001000000000000L,0x0000000000000011L}); 15179 public static final BitSet FOLLOW_implements_spec_in_smali_file1094 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x0001000000000000L,0x0000000000000011L}); 15180 public static final BitSet FOLLOW_source_spec_in_smali_file1103 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x0001000000000000L,0x0000000000000011L}); 15181 public static final BitSet FOLLOW_method_in_smali_file1111 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x0001000000000000L,0x0000000000000011L}); 15182 public static final BitSet FOLLOW_field_in_smali_file1117 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x0001000000000000L,0x0000000000000011L}); 15183 public static final BitSet FOLLOW_annotation_in_smali_file1123 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x0001000000000000L,0x0000000000000011L}); 15184 public static final BitSet FOLLOW_EOF_in_smali_file1134 = new BitSet(new long[]{0x0000000000000002L}); 15185 public static final BitSet FOLLOW_CLASS_DIRECTIVE_in_class_spec1221 = new BitSet(new long[]{0x0000000000008010L}); 15186 public static final BitSet FOLLOW_access_list_in_class_spec1223 = new BitSet(new long[]{0x0000000000008000L}); 15187 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_class_spec1225 = new BitSet(new long[]{0x0000000000000002L}); 15188 public static final BitSet FOLLOW_SUPER_DIRECTIVE_in_super_spec1243 = new BitSet(new long[]{0x0000000000008000L}); 15189 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_super_spec1245 = new BitSet(new long[]{0x0000000000000002L}); 15190 public static final BitSet FOLLOW_IMPLEMENTS_DIRECTIVE_in_implements_spec1264 = new BitSet(new long[]{0x0000000000008000L}); 15191 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_implements_spec1266 = new BitSet(new long[]{0x0000000000000002L}); 15192 public static final BitSet FOLLOW_SOURCE_DIRECTIVE_in_source_spec1285 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15193 public static final BitSet FOLLOW_STRING_LITERAL_in_source_spec1287 = new BitSet(new long[]{0x0000000000000002L}); 15194 public static final BitSet FOLLOW_ACCESS_SPEC_in_access_list1306 = new BitSet(new long[]{0x0000000000000012L}); 15195 public static final BitSet FOLLOW_FIELD_DIRECTIVE_in_field1337 = new BitSet(new long[]{0xF4795C8000800450L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L}); 15196 public static final BitSet FOLLOW_access_list_in_field1339 = new BitSet(new long[]{0xF4795C8000800450L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L}); 15197 public static final BitSet FOLLOW_member_name_in_field1341 = new BitSet(new long[]{0x0000000000080000L}); 15198 public static final BitSet FOLLOW_COLON_in_field1343 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0200000000000000L}); 15199 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_field1345 = new BitSet(new long[]{0x0000000804000022L}); 15200 public static final BitSet FOLLOW_EQUAL_in_field1348 = new BitSet(new long[]{0xF4795CC200C0CD50L,0x0000000000E0FB16L,0xCB8EC00000000000L,0x000000000000006CL}); 15201 public static final BitSet FOLLOW_literal_in_field1350 = new BitSet(new long[]{0x0000000004000022L}); 15202 public static final BitSet FOLLOW_annotation_in_field1363 = new BitSet(new long[]{0x0000000004000022L}); 15203 public static final BitSet FOLLOW_END_FIELD_DIRECTIVE_in_field1377 = new BitSet(new long[]{0x0000000000000002L}); 15204 public static final BitSet FOLLOW_METHOD_DIRECTIVE_in_method1488 = new BitSet(new long[]{0xF4795C8000800450L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L}); 15205 public static final BitSet FOLLOW_access_list_in_method1490 = new BitSet(new long[]{0xF4795C8000800450L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L}); 15206 public static final BitSet FOLLOW_member_name_in_method1492 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0010000000000000L}); 15207 public static final BitSet FOLLOW_method_prototype_in_method1494 = new BitSet(new long[]{0xFFFFFC04180830A0L,0x0000000000FFFFFFL,0x3460380000000000L,0x0000000000000003L}); 15208 public static final BitSet FOLLOW_statements_and_directives_in_method1496 = new BitSet(new long[]{0x0000000010000000L}); 15209 public static final BitSet FOLLOW_END_METHOD_DIRECTIVE_in_method1502 = new BitSet(new long[]{0x0000000000000002L}); 15210 public static final BitSet FOLLOW_ordered_method_item_in_statements_and_directives1547 = new BitSet(new long[]{0xFFFFFC04080830A2L,0x0000000000FFFFFFL,0x3460380000000000L,0x0000000000000003L}); 15211 public static final BitSet FOLLOW_registers_directive_in_statements_and_directives1555 = new BitSet(new long[]{0xFFFFFC04080830A2L,0x0000000000FFFFFFL,0x3460380000000000L,0x0000000000000003L}); 15212 public static final BitSet FOLLOW_catch_directive_in_statements_and_directives1563 = new BitSet(new long[]{0xFFFFFC04080830A2L,0x0000000000FFFFFFL,0x3460380000000000L,0x0000000000000003L}); 15213 public static final BitSet FOLLOW_catchall_directive_in_statements_and_directives1571 = new BitSet(new long[]{0xFFFFFC04080830A2L,0x0000000000FFFFFFL,0x3460380000000000L,0x0000000000000003L}); 15214 public static final BitSet FOLLOW_parameter_directive_in_statements_and_directives1579 = new BitSet(new long[]{0xFFFFFC04080830A2L,0x0000000000FFFFFFL,0x3460380000000000L,0x0000000000000003L}); 15215 public static final BitSet FOLLOW_annotation_in_statements_and_directives1587 = new BitSet(new long[]{0xFFFFFC04080830A2L,0x0000000000FFFFFFL,0x3460380000000000L,0x0000000000000003L}); 15216 public static final BitSet FOLLOW_label_in_ordered_method_item1672 = new BitSet(new long[]{0x0000000000000002L}); 15217 public static final BitSet FOLLOW_instruction_in_ordered_method_item1678 = new BitSet(new long[]{0x0000000000000002L}); 15218 public static final BitSet FOLLOW_debug_directive_in_ordered_method_item1684 = new BitSet(new long[]{0x0000000000000002L}); 15219 public static final BitSet FOLLOW_REGISTERS_DIRECTIVE_in_registers_directive1704 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x4102400000000000L}); 15220 public static final BitSet FOLLOW_integral_literal_in_registers_directive1708 = new BitSet(new long[]{0x0000000000000002L}); 15221 public static final BitSet FOLLOW_LOCALS_DIRECTIVE_in_registers_directive1728 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x4102400000000000L}); 15222 public static final BitSet FOLLOW_integral_literal_in_registers_directive1732 = new BitSet(new long[]{0x0000000000000002L}); 15223 public static final BitSet FOLLOW_PARAM_LIST_OR_ID_PRIMITIVE_TYPE_in_param_list_or_id1764 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0080000000000000L}); 15224 public static final BitSet FOLLOW_SIMPLE_NAME_in_simple_name1777 = new BitSet(new long[]{0x0000000000000002L}); 15225 public static final BitSet FOLLOW_ACCESS_SPEC_in_simple_name1783 = new BitSet(new long[]{0x0000000000000002L}); 15226 public static final BitSet FOLLOW_VERIFICATION_ERROR_TYPE_in_simple_name1794 = new BitSet(new long[]{0x0000000000000002L}); 15227 public static final BitSet FOLLOW_POSITIVE_INTEGER_LITERAL_in_simple_name1805 = new BitSet(new long[]{0x0000000000000002L}); 15228 public static final BitSet FOLLOW_NEGATIVE_INTEGER_LITERAL_in_simple_name1816 = new BitSet(new long[]{0x0000000000000002L}); 15229 public static final BitSet FOLLOW_FLOAT_LITERAL_OR_ID_in_simple_name1827 = new BitSet(new long[]{0x0000000000000002L}); 15230 public static final BitSet FOLLOW_DOUBLE_LITERAL_OR_ID_in_simple_name1838 = new BitSet(new long[]{0x0000000000000002L}); 15231 public static final BitSet FOLLOW_BOOL_LITERAL_in_simple_name1849 = new BitSet(new long[]{0x0000000000000002L}); 15232 public static final BitSet FOLLOW_NULL_LITERAL_in_simple_name1860 = new BitSet(new long[]{0x0000000000000002L}); 15233 public static final BitSet FOLLOW_REGISTER_in_simple_name1871 = new BitSet(new long[]{0x0000000000000002L}); 15234 public static final BitSet FOLLOW_param_list_or_id_in_simple_name1882 = new BitSet(new long[]{0x0000000000000002L}); 15235 public static final BitSet FOLLOW_PRIMITIVE_TYPE_in_simple_name1892 = new BitSet(new long[]{0x0000000000000002L}); 15236 public static final BitSet FOLLOW_VOID_TYPE_in_simple_name1903 = new BitSet(new long[]{0x0000000000000002L}); 15237 public static final BitSet FOLLOW_ANNOTATION_VISIBILITY_in_simple_name1914 = new BitSet(new long[]{0x0000000000000002L}); 15238 public static final BitSet FOLLOW_INSTRUCTION_FORMAT10t_in_simple_name1925 = new BitSet(new long[]{0x0000000000000002L}); 15239 public static final BitSet FOLLOW_INSTRUCTION_FORMAT10x_in_simple_name1936 = new BitSet(new long[]{0x0000000000000002L}); 15240 public static final BitSet FOLLOW_INSTRUCTION_FORMAT10x_ODEX_in_simple_name1947 = new BitSet(new long[]{0x0000000000000002L}); 15241 public static final BitSet FOLLOW_INSTRUCTION_FORMAT11x_in_simple_name1958 = new BitSet(new long[]{0x0000000000000002L}); 15242 public static final BitSet FOLLOW_INSTRUCTION_FORMAT12x_OR_ID_in_simple_name1969 = new BitSet(new long[]{0x0000000000000002L}); 15243 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_FIELD_in_simple_name1980 = new BitSet(new long[]{0x0000000000000002L}); 15244 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_FIELD_ODEX_in_simple_name1991 = new BitSet(new long[]{0x0000000000000002L}); 15245 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_STRING_in_simple_name2002 = new BitSet(new long[]{0x0000000000000002L}); 15246 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_TYPE_in_simple_name2013 = new BitSet(new long[]{0x0000000000000002L}); 15247 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21t_in_simple_name2024 = new BitSet(new long[]{0x0000000000000002L}); 15248 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_FIELD_in_simple_name2035 = new BitSet(new long[]{0x0000000000000002L}); 15249 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_FIELD_ODEX_in_simple_name2046 = new BitSet(new long[]{0x0000000000000002L}); 15250 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_TYPE_in_simple_name2057 = new BitSet(new long[]{0x0000000000000002L}); 15251 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22cs_FIELD_in_simple_name2068 = new BitSet(new long[]{0x0000000000000002L}); 15252 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22s_OR_ID_in_simple_name2079 = new BitSet(new long[]{0x0000000000000002L}); 15253 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22t_in_simple_name2090 = new BitSet(new long[]{0x0000000000000002L}); 15254 public static final BitSet FOLLOW_INSTRUCTION_FORMAT23x_in_simple_name2101 = new BitSet(new long[]{0x0000000000000002L}); 15255 public static final BitSet FOLLOW_INSTRUCTION_FORMAT31i_OR_ID_in_simple_name2112 = new BitSet(new long[]{0x0000000000000002L}); 15256 public static final BitSet FOLLOW_INSTRUCTION_FORMAT31t_in_simple_name2123 = new BitSet(new long[]{0x0000000000000002L}); 15257 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_METHOD_in_simple_name2134 = new BitSet(new long[]{0x0000000000000002L}); 15258 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_METHOD_ODEX_in_simple_name2145 = new BitSet(new long[]{0x0000000000000002L}); 15259 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_TYPE_in_simple_name2156 = new BitSet(new long[]{0x0000000000000002L}); 15260 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35mi_METHOD_in_simple_name2167 = new BitSet(new long[]{0x0000000000000002L}); 15261 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35ms_METHOD_in_simple_name2178 = new BitSet(new long[]{0x0000000000000002L}); 15262 public static final BitSet FOLLOW_INSTRUCTION_FORMAT45cc_METHOD_in_simple_name2189 = new BitSet(new long[]{0x0000000000000002L}); 15263 public static final BitSet FOLLOW_INSTRUCTION_FORMAT4rcc_METHOD_in_simple_name2200 = new BitSet(new long[]{0x0000000000000002L}); 15264 public static final BitSet FOLLOW_INSTRUCTION_FORMAT51l_in_simple_name2211 = new BitSet(new long[]{0x0000000000000002L}); 15265 public static final BitSet FOLLOW_simple_name_in_member_name2226 = new BitSet(new long[]{0x0000000000000002L}); 15266 public static final BitSet FOLLOW_MEMBER_NAME_in_member_name2232 = new BitSet(new long[]{0x0000000000000002L}); 15267 public static final BitSet FOLLOW_OPEN_PAREN_in_method_prototype2247 = new BitSet(new long[]{0x0000000000048100L,0x0000000000000000L,0x0280000000000000L}); 15268 public static final BitSet FOLLOW_param_list_in_method_prototype2249 = new BitSet(new long[]{0x0000000000040000L}); 15269 public static final BitSet FOLLOW_CLOSE_PAREN_in_method_prototype2251 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0200000000000000L,0x0000000000000040L}); 15270 public static final BitSet FOLLOW_type_descriptor_in_method_prototype2253 = new BitSet(new long[]{0x0000000000000002L}); 15271 public static final BitSet FOLLOW_PARAM_LIST_OR_ID_PRIMITIVE_TYPE_in_param_list_or_id_primitive_type2283 = new BitSet(new long[]{0x0000000000000002L}); 15272 public static final BitSet FOLLOW_param_list_or_id_primitive_type_in_param_list2298 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0080000000000000L}); 15273 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_param_list2305 = new BitSet(new long[]{0x0000000000008102L,0x0000000000000000L,0x0200000000000000L}); 15274 public static final BitSet FOLLOW_ARRAY_TYPE_PREFIX_in_array_descriptor2316 = new BitSet(new long[]{0x0000000000008000L,0x0000000000000000L,0x0200000000000000L}); 15275 public static final BitSet FOLLOW_set_in_array_descriptor2318 = new BitSet(new long[]{0x0000000000000002L}); 15276 public static final BitSet FOLLOW_VOID_TYPE_in_type_descriptor2334 = new BitSet(new long[]{0x0000000000000002L}); 15277 public static final BitSet FOLLOW_PRIMITIVE_TYPE_in_type_descriptor2340 = new BitSet(new long[]{0x0000000000000002L}); 15278 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_type_descriptor2346 = new BitSet(new long[]{0x0000000000000002L}); 15279 public static final BitSet FOLLOW_array_descriptor_in_type_descriptor2352 = new BitSet(new long[]{0x0000000000000002L}); 15280 public static final BitSet FOLLOW_PRIMITIVE_TYPE_in_nonvoid_type_descriptor2362 = new BitSet(new long[]{0x0000000000000002L}); 15281 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_nonvoid_type_descriptor2368 = new BitSet(new long[]{0x0000000000000002L}); 15282 public static final BitSet FOLLOW_array_descriptor_in_nonvoid_type_descriptor2374 = new BitSet(new long[]{0x0000000000000002L}); 15283 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_reference_type_descriptor2384 = new BitSet(new long[]{0x0000000000000002L}); 15284 public static final BitSet FOLLOW_array_descriptor_in_reference_type_descriptor2390 = new BitSet(new long[]{0x0000000000000002L}); 15285 public static final BitSet FOLLOW_POSITIVE_INTEGER_LITERAL_in_integer_literal2400 = new BitSet(new long[]{0x0000000000000002L}); 15286 public static final BitSet FOLLOW_NEGATIVE_INTEGER_LITERAL_in_integer_literal2411 = new BitSet(new long[]{0x0000000000000002L}); 15287 public static final BitSet FOLLOW_FLOAT_LITERAL_OR_ID_in_float_literal2426 = new BitSet(new long[]{0x0000000000000002L}); 15288 public static final BitSet FOLLOW_FLOAT_LITERAL_in_float_literal2437 = new BitSet(new long[]{0x0000000000000002L}); 15289 public static final BitSet FOLLOW_DOUBLE_LITERAL_OR_ID_in_double_literal2447 = new BitSet(new long[]{0x0000000000000002L}); 15290 public static final BitSet FOLLOW_DOUBLE_LITERAL_in_double_literal2458 = new BitSet(new long[]{0x0000000000000002L}); 15291 public static final BitSet FOLLOW_LONG_LITERAL_in_literal2468 = new BitSet(new long[]{0x0000000000000002L}); 15292 public static final BitSet FOLLOW_integer_literal_in_literal2474 = new BitSet(new long[]{0x0000000000000002L}); 15293 public static final BitSet FOLLOW_SHORT_LITERAL_in_literal2480 = new BitSet(new long[]{0x0000000000000002L}); 15294 public static final BitSet FOLLOW_BYTE_LITERAL_in_literal2486 = new BitSet(new long[]{0x0000000000000002L}); 15295 public static final BitSet FOLLOW_float_literal_in_literal2492 = new BitSet(new long[]{0x0000000000000002L}); 15296 public static final BitSet FOLLOW_double_literal_in_literal2498 = new BitSet(new long[]{0x0000000000000002L}); 15297 public static final BitSet FOLLOW_CHAR_LITERAL_in_literal2504 = new BitSet(new long[]{0x0000000000000002L}); 15298 public static final BitSet FOLLOW_STRING_LITERAL_in_literal2510 = new BitSet(new long[]{0x0000000000000002L}); 15299 public static final BitSet FOLLOW_BOOL_LITERAL_in_literal2516 = new BitSet(new long[]{0x0000000000000002L}); 15300 public static final BitSet FOLLOW_NULL_LITERAL_in_literal2522 = new BitSet(new long[]{0x0000000000000002L}); 15301 public static final BitSet FOLLOW_array_literal_in_literal2528 = new BitSet(new long[]{0x0000000000000002L}); 15302 public static final BitSet FOLLOW_subannotation_in_literal2534 = new BitSet(new long[]{0x0000000000000002L}); 15303 public static final BitSet FOLLOW_type_field_method_literal_in_literal2540 = new BitSet(new long[]{0x0000000000000002L}); 15304 public static final BitSet FOLLOW_enum_literal_in_literal2546 = new BitSet(new long[]{0x0000000000000002L}); 15305 public static final BitSet FOLLOW_integer_literal_in_parsed_integer_literal2559 = new BitSet(new long[]{0x0000000000000002L}); 15306 public static final BitSet FOLLOW_LONG_LITERAL_in_integral_literal2571 = new BitSet(new long[]{0x0000000000000002L}); 15307 public static final BitSet FOLLOW_integer_literal_in_integral_literal2577 = new BitSet(new long[]{0x0000000000000002L}); 15308 public static final BitSet FOLLOW_SHORT_LITERAL_in_integral_literal2583 = new BitSet(new long[]{0x0000000000000002L}); 15309 public static final BitSet FOLLOW_CHAR_LITERAL_in_integral_literal2589 = new BitSet(new long[]{0x0000000000000002L}); 15310 public static final BitSet FOLLOW_BYTE_LITERAL_in_integral_literal2595 = new BitSet(new long[]{0x0000000000000002L}); 15311 public static final BitSet FOLLOW_LONG_LITERAL_in_fixed_32bit_literal2605 = new BitSet(new long[]{0x0000000000000002L}); 15312 public static final BitSet FOLLOW_integer_literal_in_fixed_32bit_literal2611 = new BitSet(new long[]{0x0000000000000002L}); 15313 public static final BitSet FOLLOW_SHORT_LITERAL_in_fixed_32bit_literal2617 = new BitSet(new long[]{0x0000000000000002L}); 15314 public static final BitSet FOLLOW_BYTE_LITERAL_in_fixed_32bit_literal2623 = new BitSet(new long[]{0x0000000000000002L}); 15315 public static final BitSet FOLLOW_float_literal_in_fixed_32bit_literal2629 = new BitSet(new long[]{0x0000000000000002L}); 15316 public static final BitSet FOLLOW_CHAR_LITERAL_in_fixed_32bit_literal2635 = new BitSet(new long[]{0x0000000000000002L}); 15317 public static final BitSet FOLLOW_BOOL_LITERAL_in_fixed_32bit_literal2641 = new BitSet(new long[]{0x0000000000000002L}); 15318 public static final BitSet FOLLOW_integer_literal_in_fixed_literal2651 = new BitSet(new long[]{0x0000000000000002L}); 15319 public static final BitSet FOLLOW_LONG_LITERAL_in_fixed_literal2657 = new BitSet(new long[]{0x0000000000000002L}); 15320 public static final BitSet FOLLOW_SHORT_LITERAL_in_fixed_literal2663 = new BitSet(new long[]{0x0000000000000002L}); 15321 public static final BitSet FOLLOW_BYTE_LITERAL_in_fixed_literal2669 = new BitSet(new long[]{0x0000000000000002L}); 15322 public static final BitSet FOLLOW_float_literal_in_fixed_literal2675 = new BitSet(new long[]{0x0000000000000002L}); 15323 public static final BitSet FOLLOW_double_literal_in_fixed_literal2681 = new BitSet(new long[]{0x0000000000000002L}); 15324 public static final BitSet FOLLOW_CHAR_LITERAL_in_fixed_literal2687 = new BitSet(new long[]{0x0000000000000002L}); 15325 public static final BitSet FOLLOW_BOOL_LITERAL_in_fixed_literal2693 = new BitSet(new long[]{0x0000000000000002L}); 15326 public static final BitSet FOLLOW_OPEN_BRACE_in_array_literal2703 = new BitSet(new long[]{0xF4795CC200C2CD50L,0x0000000000E0FB16L,0xCB8EC00000000000L,0x000000000000006CL}); 15327 public static final BitSet FOLLOW_literal_in_array_literal2706 = new BitSet(new long[]{0x0000000000120000L}); 15328 public static final BitSet FOLLOW_COMMA_in_array_literal2709 = new BitSet(new long[]{0xF4795CC200C0CD50L,0x0000000000E0FB16L,0xCB8EC00000000000L,0x000000000000006CL}); 15329 public static final BitSet FOLLOW_literal_in_array_literal2711 = new BitSet(new long[]{0x0000000000120000L}); 15330 public static final BitSet FOLLOW_CLOSE_BRACE_in_array_literal2719 = new BitSet(new long[]{0x0000000000000002L}); 15331 public static final BitSet FOLLOW_simple_name_in_annotation_element2743 = new BitSet(new long[]{0x0000000800000000L}); 15332 public static final BitSet FOLLOW_EQUAL_in_annotation_element2745 = new BitSet(new long[]{0xF4795CC200C0CD50L,0x0000000000E0FB16L,0xCB8EC00000000000L,0x000000000000006CL}); 15333 public static final BitSet FOLLOW_literal_in_annotation_element2747 = new BitSet(new long[]{0x0000000000000002L}); 15334 public static final BitSet FOLLOW_ANNOTATION_DIRECTIVE_in_annotation2772 = new BitSet(new long[]{0x0000000000000040L}); 15335 public static final BitSet FOLLOW_ANNOTATION_VISIBILITY_in_annotation2774 = new BitSet(new long[]{0x0000000000008000L}); 15336 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_annotation2776 = new BitSet(new long[]{0xF4795C8001800450L,0x0000000000E0FB16L,0x8B86000000000000L,0x0000000000000060L}); 15337 public static final BitSet FOLLOW_annotation_element_in_annotation2782 = new BitSet(new long[]{0xF4795C8001800450L,0x0000000000E0FB16L,0x8B86000000000000L,0x0000000000000060L}); 15338 public static final BitSet FOLLOW_END_ANNOTATION_DIRECTIVE_in_annotation2785 = new BitSet(new long[]{0x0000000000000002L}); 15339 public static final BitSet FOLLOW_SUBANNOTATION_DIRECTIVE_in_subannotation2818 = new BitSet(new long[]{0x0000000000008000L}); 15340 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_subannotation2820 = new BitSet(new long[]{0xF4795C8100800450L,0x0000000000E0FB16L,0x8B86000000000000L,0x0000000000000060L}); 15341 public static final BitSet FOLLOW_annotation_element_in_subannotation2822 = new BitSet(new long[]{0xF4795C8100800450L,0x0000000000E0FB16L,0x8B86000000000000L,0x0000000000000060L}); 15342 public static final BitSet FOLLOW_END_SUBANNOTATION_DIRECTIVE_in_subannotation2825 = new BitSet(new long[]{0x0000000000000002L}); 15343 public static final BitSet FOLLOW_ENUM_DIRECTIVE_in_enum_literal2852 = new BitSet(new long[]{0xF4795C8000808550L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L}); 15344 public static final BitSet FOLLOW_field_reference_in_enum_literal2854 = new BitSet(new long[]{0x0000000000000002L}); 15345 public static final BitSet FOLLOW_reference_type_descriptor_in_type_field_method_literal2874 = new BitSet(new long[]{0x0000000000000002L}); 15346 public static final BitSet FOLLOW_reference_type_descriptor_in_type_field_method_literal2883 = new BitSet(new long[]{0x0000000000000200L}); 15347 public static final BitSet FOLLOW_ARROW_in_type_field_method_literal2885 = new BitSet(new long[]{0xF4795C8000800450L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L}); 15348 public static final BitSet FOLLOW_member_name_in_type_field_method_literal2897 = new BitSet(new long[]{0x0000000000080000L}); 15349 public static final BitSet FOLLOW_COLON_in_type_field_method_literal2899 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0200000000000000L}); 15350 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_type_field_method_literal2901 = new BitSet(new long[]{0x0000000000000002L}); 15351 public static final BitSet FOLLOW_member_name_in_type_field_method_literal2924 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0010000000000000L}); 15352 public static final BitSet FOLLOW_method_prototype_in_type_field_method_literal2926 = new BitSet(new long[]{0x0000000000000002L}); 15353 public static final BitSet FOLLOW_PRIMITIVE_TYPE_in_type_field_method_literal2959 = new BitSet(new long[]{0x0000000000000002L}); 15354 public static final BitSet FOLLOW_VOID_TYPE_in_type_field_method_literal2965 = new BitSet(new long[]{0x0000000000000002L}); 15355 public static final BitSet FOLLOW_reference_type_descriptor_in_method_reference2976 = new BitSet(new long[]{0x0000000000000200L}); 15356 public static final BitSet FOLLOW_ARROW_in_method_reference2978 = new BitSet(new long[]{0xF4795C8000800450L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L}); 15357 public static final BitSet FOLLOW_member_name_in_method_reference2982 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0010000000000000L}); 15358 public static final BitSet FOLLOW_method_prototype_in_method_reference2984 = new BitSet(new long[]{0x0000000000000002L}); 15359 public static final BitSet FOLLOW_reference_type_descriptor_in_field_reference3006 = new BitSet(new long[]{0x0000000000000200L}); 15360 public static final BitSet FOLLOW_ARROW_in_field_reference3008 = new BitSet(new long[]{0xF4795C8000800450L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L}); 15361 public static final BitSet FOLLOW_member_name_in_field_reference3012 = new BitSet(new long[]{0x0000000000080000L}); 15362 public static final BitSet FOLLOW_COLON_in_field_reference3014 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0200000000000000L}); 15363 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_field_reference3016 = new BitSet(new long[]{0x0000000000000002L}); 15364 public static final BitSet FOLLOW_COLON_in_label3037 = new BitSet(new long[]{0xF4795C8000800450L,0x0000000000E0FB16L,0x8B86000000000000L,0x0000000000000060L}); 15365 public static final BitSet FOLLOW_simple_name_in_label3039 = new BitSet(new long[]{0x0000000000000002L}); 15366 public static final BitSet FOLLOW_COLON_in_label_ref3058 = new BitSet(new long[]{0xF4795C8000800450L,0x0000000000E0FB16L,0x8B86000000000000L,0x0000000000000060L}); 15367 public static final BitSet FOLLOW_simple_name_in_label_ref3060 = new BitSet(new long[]{0x0000000000000002L}); 15368 public static final BitSet FOLLOW_REGISTER_in_register_list3074 = new BitSet(new long[]{0x0000000000100002L}); 15369 public static final BitSet FOLLOW_COMMA_in_register_list3077 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15370 public static final BitSet FOLLOW_REGISTER_in_register_list3079 = new BitSet(new long[]{0x0000000000100002L}); 15371 public static final BitSet FOLLOW_REGISTER_in_register_range3114 = new BitSet(new long[]{0x0000000000200002L}); 15372 public static final BitSet FOLLOW_DOTDOT_in_register_range3117 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15373 public static final BitSet FOLLOW_REGISTER_in_register_range3121 = new BitSet(new long[]{0x0000000000000002L}); 15374 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_verification_error_reference3150 = new BitSet(new long[]{0x0000000000000002L}); 15375 public static final BitSet FOLLOW_field_reference_in_verification_error_reference3154 = new BitSet(new long[]{0x0000000000000002L}); 15376 public static final BitSet FOLLOW_method_reference_in_verification_error_reference3158 = new BitSet(new long[]{0x0000000000000002L}); 15377 public static final BitSet FOLLOW_CATCH_DIRECTIVE_in_catch_directive3168 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0200000000000000L}); 15378 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_catch_directive3170 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L}); 15379 public static final BitSet FOLLOW_OPEN_BRACE_in_catch_directive3172 = new BitSet(new long[]{0x0000000000080000L}); 15380 public static final BitSet FOLLOW_label_ref_in_catch_directive3176 = new BitSet(new long[]{0x0000000000200000L}); 15381 public static final BitSet FOLLOW_DOTDOT_in_catch_directive3178 = new BitSet(new long[]{0x0000000000080000L}); 15382 public static final BitSet FOLLOW_label_ref_in_catch_directive3182 = new BitSet(new long[]{0x0000000000020000L}); 15383 public static final BitSet FOLLOW_CLOSE_BRACE_in_catch_directive3184 = new BitSet(new long[]{0x0000000000080000L}); 15384 public static final BitSet FOLLOW_label_ref_in_catch_directive3188 = new BitSet(new long[]{0x0000000000000002L}); 15385 public static final BitSet FOLLOW_CATCHALL_DIRECTIVE_in_catchall_directive3220 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L}); 15386 public static final BitSet FOLLOW_OPEN_BRACE_in_catchall_directive3222 = new BitSet(new long[]{0x0000000000080000L}); 15387 public static final BitSet FOLLOW_label_ref_in_catchall_directive3226 = new BitSet(new long[]{0x0000000000200000L}); 15388 public static final BitSet FOLLOW_DOTDOT_in_catchall_directive3228 = new BitSet(new long[]{0x0000000000080000L}); 15389 public static final BitSet FOLLOW_label_ref_in_catchall_directive3232 = new BitSet(new long[]{0x0000000000020000L}); 15390 public static final BitSet FOLLOW_CLOSE_BRACE_in_catchall_directive3234 = new BitSet(new long[]{0x0000000000080000L}); 15391 public static final BitSet FOLLOW_label_ref_in_catchall_directive3238 = new BitSet(new long[]{0x0000000000000002L}); 15392 public static final BitSet FOLLOW_PARAMETER_DIRECTIVE_in_parameter_directive3277 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15393 public static final BitSet FOLLOW_REGISTER_in_parameter_directive3279 = new BitSet(new long[]{0x0000000040100022L}); 15394 public static final BitSet FOLLOW_COMMA_in_parameter_directive3282 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15395 public static final BitSet FOLLOW_STRING_LITERAL_in_parameter_directive3284 = new BitSet(new long[]{0x0000000040000022L}); 15396 public static final BitSet FOLLOW_annotation_in_parameter_directive3295 = new BitSet(new long[]{0x0000000040000022L}); 15397 public static final BitSet FOLLOW_END_PARAMETER_DIRECTIVE_in_parameter_directive3308 = new BitSet(new long[]{0x0000000000000002L}); 15398 public static final BitSet FOLLOW_line_directive_in_debug_directive3381 = new BitSet(new long[]{0x0000000000000002L}); 15399 public static final BitSet FOLLOW_local_directive_in_debug_directive3387 = new BitSet(new long[]{0x0000000000000002L}); 15400 public static final BitSet FOLLOW_end_local_directive_in_debug_directive3393 = new BitSet(new long[]{0x0000000000000002L}); 15401 public static final BitSet FOLLOW_restart_local_directive_in_debug_directive3399 = new BitSet(new long[]{0x0000000000000002L}); 15402 public static final BitSet FOLLOW_prologue_directive_in_debug_directive3405 = new BitSet(new long[]{0x0000000000000002L}); 15403 public static final BitSet FOLLOW_epilogue_directive_in_debug_directive3411 = new BitSet(new long[]{0x0000000000000002L}); 15404 public static final BitSet FOLLOW_source_directive_in_debug_directive3417 = new BitSet(new long[]{0x0000000000000002L}); 15405 public static final BitSet FOLLOW_LINE_DIRECTIVE_in_line_directive3427 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x4102400000000000L}); 15406 public static final BitSet FOLLOW_integral_literal_in_line_directive3429 = new BitSet(new long[]{0x0000000000000002L}); 15407 public static final BitSet FOLLOW_LOCAL_DIRECTIVE_in_local_directive3452 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15408 public static final BitSet FOLLOW_REGISTER_in_local_directive3454 = new BitSet(new long[]{0x0000000000100002L}); 15409 public static final BitSet FOLLOW_COMMA_in_local_directive3457 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0004000000000000L,0x0000000000000004L}); 15410 public static final BitSet FOLLOW_NULL_LITERAL_in_local_directive3460 = new BitSet(new long[]{0x0000000000080000L}); 15411 public static final BitSet FOLLOW_STRING_LITERAL_in_local_directive3466 = new BitSet(new long[]{0x0000000000080000L}); 15412 public static final BitSet FOLLOW_COLON_in_local_directive3469 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0200000000000000L,0x0000000000000040L}); 15413 public static final BitSet FOLLOW_VOID_TYPE_in_local_directive3472 = new BitSet(new long[]{0x0000000000100002L}); 15414 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_local_directive3476 = new BitSet(new long[]{0x0000000000100002L}); 15415 public static final BitSet FOLLOW_COMMA_in_local_directive3510 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15416 public static final BitSet FOLLOW_STRING_LITERAL_in_local_directive3514 = new BitSet(new long[]{0x0000000000000002L}); 15417 public static final BitSet FOLLOW_END_LOCAL_DIRECTIVE_in_end_local_directive3556 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15418 public static final BitSet FOLLOW_REGISTER_in_end_local_directive3558 = new BitSet(new long[]{0x0000000000000002L}); 15419 public static final BitSet FOLLOW_RESTART_LOCAL_DIRECTIVE_in_restart_local_directive3581 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15420 public static final BitSet FOLLOW_REGISTER_in_restart_local_directive3583 = new BitSet(new long[]{0x0000000000000002L}); 15421 public static final BitSet FOLLOW_PROLOGUE_DIRECTIVE_in_prologue_directive3606 = new BitSet(new long[]{0x0000000000000002L}); 15422 public static final BitSet FOLLOW_EPILOGUE_DIRECTIVE_in_epilogue_directive3627 = new BitSet(new long[]{0x0000000000000002L}); 15423 public static final BitSet FOLLOW_SOURCE_DIRECTIVE_in_source_directive3648 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15424 public static final BitSet FOLLOW_STRING_LITERAL_in_source_directive3650 = new BitSet(new long[]{0x0000000000000002L}); 15425 public static final BitSet FOLLOW_INSTRUCTION_FORMAT12x_in_instruction_format12x3675 = new BitSet(new long[]{0x0000000000000002L}); 15426 public static final BitSet FOLLOW_INSTRUCTION_FORMAT12x_OR_ID_in_instruction_format12x3681 = new BitSet(new long[]{0x0000000000000002L}); 15427 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22s_in_instruction_format22s3696 = new BitSet(new long[]{0x0000000000000002L}); 15428 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22s_OR_ID_in_instruction_format22s3702 = new BitSet(new long[]{0x0000000000000002L}); 15429 public static final BitSet FOLLOW_INSTRUCTION_FORMAT31i_in_instruction_format31i3717 = new BitSet(new long[]{0x0000000000000002L}); 15430 public static final BitSet FOLLOW_INSTRUCTION_FORMAT31i_OR_ID_in_instruction_format31i3723 = new BitSet(new long[]{0x0000000000000002L}); 15431 public static final BitSet FOLLOW_insn_format10t_in_instruction3740 = new BitSet(new long[]{0x0000000000000002L}); 15432 public static final BitSet FOLLOW_insn_format10x_in_instruction3746 = new BitSet(new long[]{0x0000000000000002L}); 15433 public static final BitSet FOLLOW_insn_format10x_odex_in_instruction3752 = new BitSet(new long[]{0x0000000000000002L}); 15434 public static final BitSet FOLLOW_insn_format11n_in_instruction3758 = new BitSet(new long[]{0x0000000000000002L}); 15435 public static final BitSet FOLLOW_insn_format11x_in_instruction3764 = new BitSet(new long[]{0x0000000000000002L}); 15436 public static final BitSet FOLLOW_insn_format12x_in_instruction3770 = new BitSet(new long[]{0x0000000000000002L}); 15437 public static final BitSet FOLLOW_insn_format20bc_in_instruction3776 = new BitSet(new long[]{0x0000000000000002L}); 15438 public static final BitSet FOLLOW_insn_format20t_in_instruction3782 = new BitSet(new long[]{0x0000000000000002L}); 15439 public static final BitSet FOLLOW_insn_format21c_field_in_instruction3788 = new BitSet(new long[]{0x0000000000000002L}); 15440 public static final BitSet FOLLOW_insn_format21c_field_odex_in_instruction3794 = new BitSet(new long[]{0x0000000000000002L}); 15441 public static final BitSet FOLLOW_insn_format21c_string_in_instruction3800 = new BitSet(new long[]{0x0000000000000002L}); 15442 public static final BitSet FOLLOW_insn_format21c_type_in_instruction3806 = new BitSet(new long[]{0x0000000000000002L}); 15443 public static final BitSet FOLLOW_insn_format21ih_in_instruction3812 = new BitSet(new long[]{0x0000000000000002L}); 15444 public static final BitSet FOLLOW_insn_format21lh_in_instruction3818 = new BitSet(new long[]{0x0000000000000002L}); 15445 public static final BitSet FOLLOW_insn_format21s_in_instruction3824 = new BitSet(new long[]{0x0000000000000002L}); 15446 public static final BitSet FOLLOW_insn_format21t_in_instruction3830 = new BitSet(new long[]{0x0000000000000002L}); 15447 public static final BitSet FOLLOW_insn_format22b_in_instruction3836 = new BitSet(new long[]{0x0000000000000002L}); 15448 public static final BitSet FOLLOW_insn_format22c_field_in_instruction3842 = new BitSet(new long[]{0x0000000000000002L}); 15449 public static final BitSet FOLLOW_insn_format22c_field_odex_in_instruction3848 = new BitSet(new long[]{0x0000000000000002L}); 15450 public static final BitSet FOLLOW_insn_format22c_type_in_instruction3854 = new BitSet(new long[]{0x0000000000000002L}); 15451 public static final BitSet FOLLOW_insn_format22cs_field_in_instruction3860 = new BitSet(new long[]{0x0000000000000002L}); 15452 public static final BitSet FOLLOW_insn_format22s_in_instruction3866 = new BitSet(new long[]{0x0000000000000002L}); 15453 public static final BitSet FOLLOW_insn_format22t_in_instruction3872 = new BitSet(new long[]{0x0000000000000002L}); 15454 public static final BitSet FOLLOW_insn_format22x_in_instruction3878 = new BitSet(new long[]{0x0000000000000002L}); 15455 public static final BitSet FOLLOW_insn_format23x_in_instruction3884 = new BitSet(new long[]{0x0000000000000002L}); 15456 public static final BitSet FOLLOW_insn_format30t_in_instruction3890 = new BitSet(new long[]{0x0000000000000002L}); 15457 public static final BitSet FOLLOW_insn_format31c_in_instruction3896 = new BitSet(new long[]{0x0000000000000002L}); 15458 public static final BitSet FOLLOW_insn_format31i_in_instruction3902 = new BitSet(new long[]{0x0000000000000002L}); 15459 public static final BitSet FOLLOW_insn_format31t_in_instruction3908 = new BitSet(new long[]{0x0000000000000002L}); 15460 public static final BitSet FOLLOW_insn_format32x_in_instruction3914 = new BitSet(new long[]{0x0000000000000002L}); 15461 public static final BitSet FOLLOW_insn_format35c_method_in_instruction3920 = new BitSet(new long[]{0x0000000000000002L}); 15462 public static final BitSet FOLLOW_insn_format35c_type_in_instruction3926 = new BitSet(new long[]{0x0000000000000002L}); 15463 public static final BitSet FOLLOW_insn_format35c_method_odex_in_instruction3932 = new BitSet(new long[]{0x0000000000000002L}); 15464 public static final BitSet FOLLOW_insn_format35mi_method_in_instruction3938 = new BitSet(new long[]{0x0000000000000002L}); 15465 public static final BitSet FOLLOW_insn_format35ms_method_in_instruction3944 = new BitSet(new long[]{0x0000000000000002L}); 15466 public static final BitSet FOLLOW_insn_format3rc_method_in_instruction3950 = new BitSet(new long[]{0x0000000000000002L}); 15467 public static final BitSet FOLLOW_insn_format3rc_method_odex_in_instruction3956 = new BitSet(new long[]{0x0000000000000002L}); 15468 public static final BitSet FOLLOW_insn_format3rc_type_in_instruction3962 = new BitSet(new long[]{0x0000000000000002L}); 15469 public static final BitSet FOLLOW_insn_format3rmi_method_in_instruction3968 = new BitSet(new long[]{0x0000000000000002L}); 15470 public static final BitSet FOLLOW_insn_format3rms_method_in_instruction3974 = new BitSet(new long[]{0x0000000000000002L}); 15471 public static final BitSet FOLLOW_insn_format45cc_method_in_instruction3980 = new BitSet(new long[]{0x0000000000000002L}); 15472 public static final BitSet FOLLOW_insn_format4rcc_method_in_instruction3986 = new BitSet(new long[]{0x0000000000000002L}); 15473 public static final BitSet FOLLOW_insn_format51l_in_instruction3992 = new BitSet(new long[]{0x0000000000000002L}); 15474 public static final BitSet FOLLOW_insn_array_data_directive_in_instruction3998 = new BitSet(new long[]{0x0000000000000002L}); 15475 public static final BitSet FOLLOW_insn_packed_switch_directive_in_instruction4004 = new BitSet(new long[]{0x0000000000000002L}); 15476 public static final BitSet FOLLOW_insn_sparse_switch_directive_in_instruction4010 = new BitSet(new long[]{0x0000000000000002L}); 15477 public static final BitSet FOLLOW_INSTRUCTION_FORMAT10t_in_insn_format10t4030 = new BitSet(new long[]{0x0000000000080000L}); 15478 public static final BitSet FOLLOW_label_ref_in_insn_format10t4032 = new BitSet(new long[]{0x0000000000000002L}); 15479 public static final BitSet FOLLOW_INSTRUCTION_FORMAT10x_in_insn_format10x4062 = new BitSet(new long[]{0x0000000000000002L}); 15480 public static final BitSet FOLLOW_INSTRUCTION_FORMAT10x_ODEX_in_insn_format10x_odex4090 = new BitSet(new long[]{0x0000000000000002L}); 15481 public static final BitSet FOLLOW_INSTRUCTION_FORMAT11n_in_insn_format11n4111 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15482 public static final BitSet FOLLOW_REGISTER_in_insn_format11n4113 = new BitSet(new long[]{0x0000000000100000L}); 15483 public static final BitSet FOLLOW_COMMA_in_insn_format11n4115 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x4102400000000000L}); 15484 public static final BitSet FOLLOW_integral_literal_in_insn_format11n4117 = new BitSet(new long[]{0x0000000000000002L}); 15485 public static final BitSet FOLLOW_INSTRUCTION_FORMAT11x_in_insn_format11x4149 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15486 public static final BitSet FOLLOW_REGISTER_in_insn_format11x4151 = new BitSet(new long[]{0x0000000000000002L}); 15487 public static final BitSet FOLLOW_instruction_format12x_in_insn_format12x4181 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15488 public static final BitSet FOLLOW_REGISTER_in_insn_format12x4183 = new BitSet(new long[]{0x0000000000100000L}); 15489 public static final BitSet FOLLOW_COMMA_in_insn_format12x4185 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15490 public static final BitSet FOLLOW_REGISTER_in_insn_format12x4187 = new BitSet(new long[]{0x0000000000000002L}); 15491 public static final BitSet FOLLOW_INSTRUCTION_FORMAT20bc_in_insn_format20bc4219 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000020L}); 15492 public static final BitSet FOLLOW_VERIFICATION_ERROR_TYPE_in_insn_format20bc4221 = new BitSet(new long[]{0x0000000000100000L}); 15493 public static final BitSet FOLLOW_COMMA_in_insn_format20bc4223 = new BitSet(new long[]{0xF4795C8000808550L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L}); 15494 public static final BitSet FOLLOW_verification_error_reference_in_insn_format20bc4225 = new BitSet(new long[]{0x0000000000000002L}); 15495 public static final BitSet FOLLOW_INSTRUCTION_FORMAT20t_in_insn_format20t4262 = new BitSet(new long[]{0x0000000000080000L}); 15496 public static final BitSet FOLLOW_label_ref_in_insn_format20t4264 = new BitSet(new long[]{0x0000000000000002L}); 15497 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_FIELD_in_insn_format21c_field4294 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15498 public static final BitSet FOLLOW_REGISTER_in_insn_format21c_field4296 = new BitSet(new long[]{0x0000000000100000L}); 15499 public static final BitSet FOLLOW_COMMA_in_insn_format21c_field4298 = new BitSet(new long[]{0xF4795C8000808550L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L}); 15500 public static final BitSet FOLLOW_field_reference_in_insn_format21c_field4300 = new BitSet(new long[]{0x0000000000000002L}); 15501 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_FIELD_ODEX_in_insn_format21c_field_odex4332 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15502 public static final BitSet FOLLOW_REGISTER_in_insn_format21c_field_odex4334 = new BitSet(new long[]{0x0000000000100000L}); 15503 public static final BitSet FOLLOW_COMMA_in_insn_format21c_field_odex4336 = new BitSet(new long[]{0xF4795C8000808550L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L}); 15504 public static final BitSet FOLLOW_field_reference_in_insn_format21c_field_odex4338 = new BitSet(new long[]{0x0000000000000002L}); 15505 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_STRING_in_insn_format21c_string4376 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15506 public static final BitSet FOLLOW_REGISTER_in_insn_format21c_string4378 = new BitSet(new long[]{0x0000000000100000L}); 15507 public static final BitSet FOLLOW_COMMA_in_insn_format21c_string4380 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15508 public static final BitSet FOLLOW_STRING_LITERAL_in_insn_format21c_string4382 = new BitSet(new long[]{0x0000000000000002L}); 15509 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_TYPE_in_insn_format21c_type4414 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15510 public static final BitSet FOLLOW_REGISTER_in_insn_format21c_type4416 = new BitSet(new long[]{0x0000000000100000L}); 15511 public static final BitSet FOLLOW_COMMA_in_insn_format21c_type4418 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0200000000000000L}); 15512 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_insn_format21c_type4420 = new BitSet(new long[]{0x0000000000000002L}); 15513 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21ih_in_insn_format21ih4452 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15514 public static final BitSet FOLLOW_REGISTER_in_insn_format21ih4454 = new BitSet(new long[]{0x0000000000100000L}); 15515 public static final BitSet FOLLOW_COMMA_in_insn_format21ih4456 = new BitSet(new long[]{0x000000C000004C00L,0x0000000000000000L,0x4102400000000000L}); 15516 public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_format21ih4458 = new BitSet(new long[]{0x0000000000000002L}); 15517 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21lh_in_insn_format21lh4490 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15518 public static final BitSet FOLLOW_REGISTER_in_insn_format21lh4492 = new BitSet(new long[]{0x0000000000100000L}); 15519 public static final BitSet FOLLOW_COMMA_in_insn_format21lh4494 = new BitSet(new long[]{0x000000C000004C00L,0x0000000000000000L,0x4102400000000000L}); 15520 public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_format21lh4496 = new BitSet(new long[]{0x0000000000000002L}); 15521 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21s_in_insn_format21s4528 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15522 public static final BitSet FOLLOW_REGISTER_in_insn_format21s4530 = new BitSet(new long[]{0x0000000000100000L}); 15523 public static final BitSet FOLLOW_COMMA_in_insn_format21s4532 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x4102400000000000L}); 15524 public static final BitSet FOLLOW_integral_literal_in_insn_format21s4534 = new BitSet(new long[]{0x0000000000000002L}); 15525 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21t_in_insn_format21t4566 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15526 public static final BitSet FOLLOW_REGISTER_in_insn_format21t4568 = new BitSet(new long[]{0x0000000000100000L}); 15527 public static final BitSet FOLLOW_COMMA_in_insn_format21t4570 = new BitSet(new long[]{0x0000000000080000L}); 15528 public static final BitSet FOLLOW_label_ref_in_insn_format21t4572 = new BitSet(new long[]{0x0000000000000002L}); 15529 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22b_in_insn_format22b4604 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15530 public static final BitSet FOLLOW_REGISTER_in_insn_format22b4606 = new BitSet(new long[]{0x0000000000100000L}); 15531 public static final BitSet FOLLOW_COMMA_in_insn_format22b4608 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15532 public static final BitSet FOLLOW_REGISTER_in_insn_format22b4610 = new BitSet(new long[]{0x0000000000100000L}); 15533 public static final BitSet FOLLOW_COMMA_in_insn_format22b4612 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x4102400000000000L}); 15534 public static final BitSet FOLLOW_integral_literal_in_insn_format22b4614 = new BitSet(new long[]{0x0000000000000002L}); 15535 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_FIELD_in_insn_format22c_field4648 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15536 public static final BitSet FOLLOW_REGISTER_in_insn_format22c_field4650 = new BitSet(new long[]{0x0000000000100000L}); 15537 public static final BitSet FOLLOW_COMMA_in_insn_format22c_field4652 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15538 public static final BitSet FOLLOW_REGISTER_in_insn_format22c_field4654 = new BitSet(new long[]{0x0000000000100000L}); 15539 public static final BitSet FOLLOW_COMMA_in_insn_format22c_field4656 = new BitSet(new long[]{0xF4795C8000808550L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L}); 15540 public static final BitSet FOLLOW_field_reference_in_insn_format22c_field4658 = new BitSet(new long[]{0x0000000000000002L}); 15541 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_FIELD_ODEX_in_insn_format22c_field_odex4692 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15542 public static final BitSet FOLLOW_REGISTER_in_insn_format22c_field_odex4694 = new BitSet(new long[]{0x0000000000100000L}); 15543 public static final BitSet FOLLOW_COMMA_in_insn_format22c_field_odex4696 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15544 public static final BitSet FOLLOW_REGISTER_in_insn_format22c_field_odex4698 = new BitSet(new long[]{0x0000000000100000L}); 15545 public static final BitSet FOLLOW_COMMA_in_insn_format22c_field_odex4700 = new BitSet(new long[]{0xF4795C8000808550L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L}); 15546 public static final BitSet FOLLOW_field_reference_in_insn_format22c_field_odex4702 = new BitSet(new long[]{0x0000000000000002L}); 15547 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_TYPE_in_insn_format22c_type4742 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15548 public static final BitSet FOLLOW_REGISTER_in_insn_format22c_type4744 = new BitSet(new long[]{0x0000000000100000L}); 15549 public static final BitSet FOLLOW_COMMA_in_insn_format22c_type4746 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15550 public static final BitSet FOLLOW_REGISTER_in_insn_format22c_type4748 = new BitSet(new long[]{0x0000000000100000L}); 15551 public static final BitSet FOLLOW_COMMA_in_insn_format22c_type4750 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0200000000000000L}); 15552 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_insn_format22c_type4752 = new BitSet(new long[]{0x0000000000000002L}); 15553 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22cs_FIELD_in_insn_format22cs_field4786 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15554 public static final BitSet FOLLOW_REGISTER_in_insn_format22cs_field4788 = new BitSet(new long[]{0x0000000000100000L}); 15555 public static final BitSet FOLLOW_COMMA_in_insn_format22cs_field4790 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15556 public static final BitSet FOLLOW_REGISTER_in_insn_format22cs_field4792 = new BitSet(new long[]{0x0000000000100000L}); 15557 public static final BitSet FOLLOW_COMMA_in_insn_format22cs_field4794 = new BitSet(new long[]{0x0000002000000000L}); 15558 public static final BitSet FOLLOW_FIELD_OFFSET_in_insn_format22cs_field4796 = new BitSet(new long[]{0x0000000000000002L}); 15559 public static final BitSet FOLLOW_instruction_format22s_in_insn_format22s4817 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15560 public static final BitSet FOLLOW_REGISTER_in_insn_format22s4819 = new BitSet(new long[]{0x0000000000100000L}); 15561 public static final BitSet FOLLOW_COMMA_in_insn_format22s4821 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15562 public static final BitSet FOLLOW_REGISTER_in_insn_format22s4823 = new BitSet(new long[]{0x0000000000100000L}); 15563 public static final BitSet FOLLOW_COMMA_in_insn_format22s4825 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x4102400000000000L}); 15564 public static final BitSet FOLLOW_integral_literal_in_insn_format22s4827 = new BitSet(new long[]{0x0000000000000002L}); 15565 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22t_in_insn_format22t4861 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15566 public static final BitSet FOLLOW_REGISTER_in_insn_format22t4863 = new BitSet(new long[]{0x0000000000100000L}); 15567 public static final BitSet FOLLOW_COMMA_in_insn_format22t4865 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15568 public static final BitSet FOLLOW_REGISTER_in_insn_format22t4867 = new BitSet(new long[]{0x0000000000100000L}); 15569 public static final BitSet FOLLOW_COMMA_in_insn_format22t4869 = new BitSet(new long[]{0x0000000000080000L}); 15570 public static final BitSet FOLLOW_label_ref_in_insn_format22t4871 = new BitSet(new long[]{0x0000000000000002L}); 15571 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22x_in_insn_format22x4905 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15572 public static final BitSet FOLLOW_REGISTER_in_insn_format22x4907 = new BitSet(new long[]{0x0000000000100000L}); 15573 public static final BitSet FOLLOW_COMMA_in_insn_format22x4909 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15574 public static final BitSet FOLLOW_REGISTER_in_insn_format22x4911 = new BitSet(new long[]{0x0000000000000002L}); 15575 public static final BitSet FOLLOW_INSTRUCTION_FORMAT23x_in_insn_format23x4943 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15576 public static final BitSet FOLLOW_REGISTER_in_insn_format23x4945 = new BitSet(new long[]{0x0000000000100000L}); 15577 public static final BitSet FOLLOW_COMMA_in_insn_format23x4947 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15578 public static final BitSet FOLLOW_REGISTER_in_insn_format23x4949 = new BitSet(new long[]{0x0000000000100000L}); 15579 public static final BitSet FOLLOW_COMMA_in_insn_format23x4951 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15580 public static final BitSet FOLLOW_REGISTER_in_insn_format23x4953 = new BitSet(new long[]{0x0000000000000002L}); 15581 public static final BitSet FOLLOW_INSTRUCTION_FORMAT30t_in_insn_format30t4987 = new BitSet(new long[]{0x0000000000080000L}); 15582 public static final BitSet FOLLOW_label_ref_in_insn_format30t4989 = new BitSet(new long[]{0x0000000000000002L}); 15583 public static final BitSet FOLLOW_INSTRUCTION_FORMAT31c_in_insn_format31c5019 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15584 public static final BitSet FOLLOW_REGISTER_in_insn_format31c5021 = new BitSet(new long[]{0x0000000000100000L}); 15585 public static final BitSet FOLLOW_COMMA_in_insn_format31c5023 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L}); 15586 public static final BitSet FOLLOW_STRING_LITERAL_in_insn_format31c5025 = new BitSet(new long[]{0x0000000000000002L}); 15587 public static final BitSet FOLLOW_instruction_format31i_in_insn_format31i5056 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15588 public static final BitSet FOLLOW_REGISTER_in_insn_format31i5058 = new BitSet(new long[]{0x0000000000100000L}); 15589 public static final BitSet FOLLOW_COMMA_in_insn_format31i5060 = new BitSet(new long[]{0x000000C000004C00L,0x0000000000000000L,0x4102400000000000L}); 15590 public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_format31i5062 = new BitSet(new long[]{0x0000000000000002L}); 15591 public static final BitSet FOLLOW_INSTRUCTION_FORMAT31t_in_insn_format31t5094 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15592 public static final BitSet FOLLOW_REGISTER_in_insn_format31t5096 = new BitSet(new long[]{0x0000000000100000L}); 15593 public static final BitSet FOLLOW_COMMA_in_insn_format31t5098 = new BitSet(new long[]{0x0000000000080000L}); 15594 public static final BitSet FOLLOW_label_ref_in_insn_format31t5100 = new BitSet(new long[]{0x0000000000000002L}); 15595 public static final BitSet FOLLOW_INSTRUCTION_FORMAT32x_in_insn_format32x5132 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15596 public static final BitSet FOLLOW_REGISTER_in_insn_format32x5134 = new BitSet(new long[]{0x0000000000100000L}); 15597 public static final BitSet FOLLOW_COMMA_in_insn_format32x5136 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15598 public static final BitSet FOLLOW_REGISTER_in_insn_format32x5138 = new BitSet(new long[]{0x0000000000000002L}); 15599 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_METHOD_in_insn_format35c_method5170 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L}); 15600 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format35c_method5172 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0800000000000000L}); 15601 public static final BitSet FOLLOW_register_list_in_insn_format35c_method5174 = new BitSet(new long[]{0x0000000000020000L}); 15602 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format35c_method5176 = new BitSet(new long[]{0x0000000000100000L}); 15603 public static final BitSet FOLLOW_COMMA_in_insn_format35c_method5178 = new BitSet(new long[]{0xF4795C8000808550L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L}); 15604 public static final BitSet FOLLOW_method_reference_in_insn_format35c_method5180 = new BitSet(new long[]{0x0000000000000002L}); 15605 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_TYPE_in_insn_format35c_type5212 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L}); 15606 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format35c_type5214 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0800000000000000L}); 15607 public static final BitSet FOLLOW_register_list_in_insn_format35c_type5216 = new BitSet(new long[]{0x0000000000020000L}); 15608 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format35c_type5218 = new BitSet(new long[]{0x0000000000100000L}); 15609 public static final BitSet FOLLOW_COMMA_in_insn_format35c_type5220 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0200000000000000L}); 15610 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_insn_format35c_type5222 = new BitSet(new long[]{0x0000000000000002L}); 15611 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_METHOD_ODEX_in_insn_format35c_method_odex5254 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L}); 15612 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format35c_method_odex5256 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0800000000000000L}); 15613 public static final BitSet FOLLOW_register_list_in_insn_format35c_method_odex5258 = new BitSet(new long[]{0x0000000000020000L}); 15614 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format35c_method_odex5260 = new BitSet(new long[]{0x0000000000100000L}); 15615 public static final BitSet FOLLOW_COMMA_in_insn_format35c_method_odex5262 = new BitSet(new long[]{0xF4795C8000808550L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L}); 15616 public static final BitSet FOLLOW_method_reference_in_insn_format35c_method_odex5264 = new BitSet(new long[]{0x0000000000000002L}); 15617 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35mi_METHOD_in_insn_format35mi_method5285 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L}); 15618 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format35mi_method5287 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0800000000000000L}); 15619 public static final BitSet FOLLOW_register_list_in_insn_format35mi_method5289 = new BitSet(new long[]{0x0000000000020000L}); 15620 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format35mi_method5291 = new BitSet(new long[]{0x0000000000100000L}); 15621 public static final BitSet FOLLOW_COMMA_in_insn_format35mi_method5293 = new BitSet(new long[]{0x0000020000000000L}); 15622 public static final BitSet FOLLOW_INLINE_INDEX_in_insn_format35mi_method5295 = new BitSet(new long[]{0x0000000000000002L}); 15623 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35ms_METHOD_in_insn_format35ms_method5316 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L}); 15624 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format35ms_method5318 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0800000000000000L}); 15625 public static final BitSet FOLLOW_register_list_in_insn_format35ms_method5320 = new BitSet(new long[]{0x0000000000020000L}); 15626 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format35ms_method5322 = new BitSet(new long[]{0x0000000000100000L}); 15627 public static final BitSet FOLLOW_COMMA_in_insn_format35ms_method5324 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000080L}); 15628 public static final BitSet FOLLOW_VTABLE_INDEX_in_insn_format35ms_method5326 = new BitSet(new long[]{0x0000000000000002L}); 15629 public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rc_METHOD_in_insn_format3rc_method5347 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L}); 15630 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format3rc_method5349 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0800000000000000L}); 15631 public static final BitSet FOLLOW_register_range_in_insn_format3rc_method5351 = new BitSet(new long[]{0x0000000000020000L}); 15632 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format3rc_method5353 = new BitSet(new long[]{0x0000000000100000L}); 15633 public static final BitSet FOLLOW_COMMA_in_insn_format3rc_method5355 = new BitSet(new long[]{0xF4795C8000808550L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L}); 15634 public static final BitSet FOLLOW_method_reference_in_insn_format3rc_method5357 = new BitSet(new long[]{0x0000000000000002L}); 15635 public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rc_METHOD_ODEX_in_insn_format3rc_method_odex5389 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L}); 15636 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format3rc_method_odex5391 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0800000000000000L}); 15637 public static final BitSet FOLLOW_register_list_in_insn_format3rc_method_odex5393 = new BitSet(new long[]{0x0000000000020000L}); 15638 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format3rc_method_odex5395 = new BitSet(new long[]{0x0000000000100000L}); 15639 public static final BitSet FOLLOW_COMMA_in_insn_format3rc_method_odex5397 = new BitSet(new long[]{0xF4795C8000808550L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L}); 15640 public static final BitSet FOLLOW_method_reference_in_insn_format3rc_method_odex5399 = new BitSet(new long[]{0x0000000000000002L}); 15641 public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rc_TYPE_in_insn_format3rc_type5420 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L}); 15642 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format3rc_type5422 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0800000000000000L}); 15643 public static final BitSet FOLLOW_register_range_in_insn_format3rc_type5424 = new BitSet(new long[]{0x0000000000020000L}); 15644 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format3rc_type5426 = new BitSet(new long[]{0x0000000000100000L}); 15645 public static final BitSet FOLLOW_COMMA_in_insn_format3rc_type5428 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0200000000000000L}); 15646 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_insn_format3rc_type5430 = new BitSet(new long[]{0x0000000000000002L}); 15647 public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rmi_METHOD_in_insn_format3rmi_method5462 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L}); 15648 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format3rmi_method5464 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0800000000000000L}); 15649 public static final BitSet FOLLOW_register_range_in_insn_format3rmi_method5466 = new BitSet(new long[]{0x0000000000020000L}); 15650 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format3rmi_method5468 = new BitSet(new long[]{0x0000000000100000L}); 15651 public static final BitSet FOLLOW_COMMA_in_insn_format3rmi_method5470 = new BitSet(new long[]{0x0000020000000000L}); 15652 public static final BitSet FOLLOW_INLINE_INDEX_in_insn_format3rmi_method5472 = new BitSet(new long[]{0x0000000000000002L}); 15653 public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rms_METHOD_in_insn_format3rms_method5493 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L}); 15654 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format3rms_method5495 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0800000000000000L}); 15655 public static final BitSet FOLLOW_register_range_in_insn_format3rms_method5497 = new BitSet(new long[]{0x0000000000020000L}); 15656 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format3rms_method5499 = new BitSet(new long[]{0x0000000000100000L}); 15657 public static final BitSet FOLLOW_COMMA_in_insn_format3rms_method5501 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000080L}); 15658 public static final BitSet FOLLOW_VTABLE_INDEX_in_insn_format3rms_method5503 = new BitSet(new long[]{0x0000000000000002L}); 15659 public static final BitSet FOLLOW_INSTRUCTION_FORMAT45cc_METHOD_in_insn_format45cc_method5524 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L}); 15660 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format45cc_method5526 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0800000000000000L}); 15661 public static final BitSet FOLLOW_register_list_in_insn_format45cc_method5528 = new BitSet(new long[]{0x0000000000020000L}); 15662 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format45cc_method5530 = new BitSet(new long[]{0x0000000000100000L}); 15663 public static final BitSet FOLLOW_COMMA_in_insn_format45cc_method5532 = new BitSet(new long[]{0xF4795C8000808550L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L}); 15664 public static final BitSet FOLLOW_method_reference_in_insn_format45cc_method5534 = new BitSet(new long[]{0x0000000000100000L}); 15665 public static final BitSet FOLLOW_COMMA_in_insn_format45cc_method5536 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0010000000000000L}); 15666 public static final BitSet FOLLOW_method_prototype_in_insn_format45cc_method5538 = new BitSet(new long[]{0x0000000000000002L}); 15667 public static final BitSet FOLLOW_INSTRUCTION_FORMAT4rcc_METHOD_in_insn_format4rcc_method5572 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0008000000000000L}); 15668 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format4rcc_method5574 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0800000000000000L}); 15669 public static final BitSet FOLLOW_register_range_in_insn_format4rcc_method5576 = new BitSet(new long[]{0x0000000000020000L}); 15670 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format4rcc_method5578 = new BitSet(new long[]{0x0000000000100000L}); 15671 public static final BitSet FOLLOW_COMMA_in_insn_format4rcc_method5580 = new BitSet(new long[]{0xF4795C8000808550L,0x0000000000E0FB16L,0x8B86800000000000L,0x0000000000000060L}); 15672 public static final BitSet FOLLOW_method_reference_in_insn_format4rcc_method5582 = new BitSet(new long[]{0x0000000000100000L}); 15673 public static final BitSet FOLLOW_COMMA_in_insn_format4rcc_method5584 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0010000000000000L}); 15674 public static final BitSet FOLLOW_method_prototype_in_insn_format4rcc_method5586 = new BitSet(new long[]{0x0000000000000002L}); 15675 public static final BitSet FOLLOW_INSTRUCTION_FORMAT51l_in_insn_format51l5620 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L}); 15676 public static final BitSet FOLLOW_REGISTER_in_insn_format51l5622 = new BitSet(new long[]{0x0000000000100000L}); 15677 public static final BitSet FOLLOW_COMMA_in_insn_format51l5624 = new BitSet(new long[]{0x000000C000C04C00L,0x0000000000000000L,0x4102400000000000L}); 15678 public static final BitSet FOLLOW_fixed_literal_in_insn_format51l5626 = new BitSet(new long[]{0x0000000000000002L}); 15679 public static final BitSet FOLLOW_ARRAY_DATA_DIRECTIVE_in_insn_array_data_directive5653 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0102000000000000L}); 15680 public static final BitSet FOLLOW_parsed_integer_literal_in_insn_array_data_directive5659 = new BitSet(new long[]{0x000000C002C04C00L,0x0000000000000000L,0x4102400000000000L}); 15681 public static final BitSet FOLLOW_fixed_literal_in_insn_array_data_directive5671 = new BitSet(new long[]{0x000000C002C04C00L,0x0000000000000000L,0x4102400000000000L}); 15682 public static final BitSet FOLLOW_END_ARRAY_DATA_DIRECTIVE_in_insn_array_data_directive5674 = new BitSet(new long[]{0x0000000000000002L}); 15683 public static final BitSet FOLLOW_PACKED_SWITCH_DIRECTIVE_in_insn_packed_switch_directive5720 = new BitSet(new long[]{0x000000C000004C00L,0x0000000000000000L,0x4102400000000000L}); 15684 public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_packed_switch_directive5726 = new BitSet(new long[]{0x0000000020080000L}); 15685 public static final BitSet FOLLOW_label_ref_in_insn_packed_switch_directive5732 = new BitSet(new long[]{0x0000000020080000L}); 15686 public static final BitSet FOLLOW_END_PACKED_SWITCH_DIRECTIVE_in_insn_packed_switch_directive5739 = new BitSet(new long[]{0x0000000000000002L}); 15687 public static final BitSet FOLLOW_SPARSE_SWITCH_DIRECTIVE_in_insn_sparse_switch_directive5813 = new BitSet(new long[]{0x000000C080004C00L,0x0000000000000000L,0x4102400000000000L}); 15688 public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_sparse_switch_directive5820 = new BitSet(new long[]{0x0000000000000200L}); 15689 public static final BitSet FOLLOW_ARROW_in_insn_sparse_switch_directive5822 = new BitSet(new long[]{0x0000000000080000L}); 15690 public static final BitSet FOLLOW_label_ref_in_insn_sparse_switch_directive5824 = new BitSet(new long[]{0x000000C080004C00L,0x0000000000000000L,0x4102400000000000L}); 15691 public static final BitSet FOLLOW_END_SPARSE_SWITCH_DIRECTIVE_in_insn_sparse_switch_directive5832 = new BitSet(new long[]{0x0000000000000002L}); 15692} 15693