1 // $ANTLR 3.5.2 smaliParser.g 2017-04-20 15:20:45 2 3 package org.jf.smali; 4 5 import org.jf.dexlib2.Format; 6 import org.jf.dexlib2.Opcode; 7 import org.jf.dexlib2.Opcodes; 8 9 10 import org.antlr.runtime.*; 11 import java.util.Stack; 12 import java.util.List; 13 import java.util.ArrayList; 14 15 import org.antlr.runtime.tree.*; 16 17 18 @SuppressWarnings("all") 19 public 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,