1// $ANTLR 3.5 /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g 2015-02-19 13:37:38 2 3package org.jf.smali; 4 5import org.jf.dexlib2.Format; 6import org.jf.dexlib2.Opcode; 7import org.jf.dexlib2.Opcodes; 8 9 10import org.antlr.runtime.*; 11import java.util.Stack; 12import java.util.List; 13import java.util.ArrayList; 14 15import org.antlr.runtime.tree.*; 16 17 18@SuppressWarnings("all") 19public class smaliParser extends Parser { 20 public static final String[] tokenNames = new String[] { 21 "<invalid>", "<EOR>", "<DOWN>", "<UP>", "ACCESS_SPEC", "ANNOTATION_DIRECTIVE", 22 "ANNOTATION_VISIBILITY", "ARRAY_DATA_DIRECTIVE", "ARRAY_DESCRIPTOR", "ARROW", 23 "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_FORMAT51l", "INTEGER_LITERAL", 46 "INVALID_TOKEN", "I_ACCESS_LIST", "I_ANNOTATION", "I_ANNOTATIONS", "I_ANNOTATION_ELEMENT", 47 "I_ARRAY_ELEMENTS", "I_ARRAY_ELEMENT_SIZE", "I_CATCH", "I_CATCHALL", "I_CATCHES", 48 "I_CLASS_DEF", "I_ENCODED_ARRAY", "I_ENCODED_ENUM", "I_ENCODED_FIELD", 49 "I_ENCODED_METHOD", "I_END_LOCAL", "I_EPILOGUE", "I_FIELD", "I_FIELDS", 50 "I_FIELD_INITIAL_VALUE", "I_FIELD_TYPE", "I_IMPLEMENTS", "I_LABEL", "I_LINE", 51 "I_LOCAL", "I_LOCALS", "I_METHOD", "I_METHODS", "I_METHOD_PROTOTYPE", 52 "I_METHOD_RETURN_TYPE", "I_ORDERED_METHOD_ITEMS", "I_PACKED_SWITCH_ELEMENTS", 53 "I_PACKED_SWITCH_START_KEY", "I_PARAMETER", "I_PARAMETERS", "I_PARAMETER_NOT_SPECIFIED", 54 "I_PROLOGUE", "I_REGISTERS", "I_REGISTER_LIST", "I_REGISTER_RANGE", "I_RESTART_LOCAL", 55 "I_SOURCE", "I_SPARSE_SWITCH_ELEMENTS", "I_STATEMENT_ARRAY_DATA", "I_STATEMENT_FORMAT10t", 56 "I_STATEMENT_FORMAT10x", "I_STATEMENT_FORMAT11n", "I_STATEMENT_FORMAT11x", 57 "I_STATEMENT_FORMAT12x", "I_STATEMENT_FORMAT20bc", "I_STATEMENT_FORMAT20t", 58 "I_STATEMENT_FORMAT21c_FIELD", "I_STATEMENT_FORMAT21c_STRING", "I_STATEMENT_FORMAT21c_TYPE", 59 "I_STATEMENT_FORMAT21ih", "I_STATEMENT_FORMAT21lh", "I_STATEMENT_FORMAT21s", 60 "I_STATEMENT_FORMAT21t", "I_STATEMENT_FORMAT22b", "I_STATEMENT_FORMAT22c_FIELD", 61 "I_STATEMENT_FORMAT22c_TYPE", "I_STATEMENT_FORMAT22s", "I_STATEMENT_FORMAT22t", 62 "I_STATEMENT_FORMAT22x", "I_STATEMENT_FORMAT23x", "I_STATEMENT_FORMAT30t", 63 "I_STATEMENT_FORMAT31c", "I_STATEMENT_FORMAT31i", "I_STATEMENT_FORMAT31t", 64 "I_STATEMENT_FORMAT32x", "I_STATEMENT_FORMAT35c_METHOD", "I_STATEMENT_FORMAT35c_TYPE", 65 "I_STATEMENT_FORMAT3rc_METHOD", "I_STATEMENT_FORMAT3rc_TYPE", "I_STATEMENT_FORMAT51l", 66 "I_STATEMENT_PACKED_SWITCH", "I_STATEMENT_SPARSE_SWITCH", "I_SUBANNOTATION", 67 "I_SUPER", "LINE_COMMENT", "LINE_DIRECTIVE", "LOCALS_DIRECTIVE", "LOCAL_DIRECTIVE", 68 "LONG_LITERAL", "MEMBER_NAME", "METHOD_DIRECTIVE", "NEGATIVE_INTEGER_LITERAL", 69 "NULL_LITERAL", "OPEN_BRACE", "OPEN_PAREN", "PACKED_SWITCH_DIRECTIVE", 70 "PARAMETER_DIRECTIVE", "PARAM_LIST_END", "PARAM_LIST_OR_ID_END", "PARAM_LIST_OR_ID_START", 71 "PARAM_LIST_START", "POSITIVE_INTEGER_LITERAL", "PRIMITIVE_TYPE", "PROLOGUE_DIRECTIVE", 72 "REGISTER", "REGISTERS_DIRECTIVE", "RESTART_LOCAL_DIRECTIVE", "SHORT_LITERAL", 73 "SIMPLE_NAME", "SOURCE_DIRECTIVE", "SPARSE_SWITCH_DIRECTIVE", "STRING_LITERAL", 74 "SUBANNOTATION_DIRECTIVE", "SUPER_DIRECTIVE", "VERIFICATION_ERROR_TYPE", 75 "VOID_TYPE", "VTABLE_INDEX", "WHITE_SPACE" 76 }; 77 public static final int EOF=-1; 78 public static final int ACCESS_SPEC=4; 79 public static final int ANNOTATION_DIRECTIVE=5; 80 public static final int ANNOTATION_VISIBILITY=6; 81 public static final int ARRAY_DATA_DIRECTIVE=7; 82 public static final int ARRAY_DESCRIPTOR=8; 83 public static final int ARROW=9; 84 public static final int BOOL_LITERAL=10; 85 public static final int BYTE_LITERAL=11; 86 public static final int CATCHALL_DIRECTIVE=12; 87 public static final int CATCH_DIRECTIVE=13; 88 public static final int CHAR_LITERAL=14; 89 public static final int CLASS_DESCRIPTOR=15; 90 public static final int CLASS_DIRECTIVE=16; 91 public static final int CLOSE_BRACE=17; 92 public static final int CLOSE_PAREN=18; 93 public static final int COLON=19; 94 public static final int COMMA=20; 95 public static final int DOTDOT=21; 96 public static final int DOUBLE_LITERAL=22; 97 public static final int DOUBLE_LITERAL_OR_ID=23; 98 public static final int END_ANNOTATION_DIRECTIVE=24; 99 public static final int END_ARRAY_DATA_DIRECTIVE=25; 100 public static final int END_FIELD_DIRECTIVE=26; 101 public static final int END_LOCAL_DIRECTIVE=27; 102 public static final int END_METHOD_DIRECTIVE=28; 103 public static final int END_PACKED_SWITCH_DIRECTIVE=29; 104 public static final int END_PARAMETER_DIRECTIVE=30; 105 public static final int END_SPARSE_SWITCH_DIRECTIVE=31; 106 public static final int END_SUBANNOTATION_DIRECTIVE=32; 107 public static final int ENUM_DIRECTIVE=33; 108 public static final int EPILOGUE_DIRECTIVE=34; 109 public static final int EQUAL=35; 110 public static final int FIELD_DIRECTIVE=36; 111 public static final int FIELD_OFFSET=37; 112 public static final int FLOAT_LITERAL=38; 113 public static final int FLOAT_LITERAL_OR_ID=39; 114 public static final int IMPLEMENTS_DIRECTIVE=40; 115 public static final int INLINE_INDEX=41; 116 public static final int INSTRUCTION_FORMAT10t=42; 117 public static final int INSTRUCTION_FORMAT10x=43; 118 public static final int INSTRUCTION_FORMAT10x_ODEX=44; 119 public static final int INSTRUCTION_FORMAT11n=45; 120 public static final int INSTRUCTION_FORMAT11x=46; 121 public static final int INSTRUCTION_FORMAT12x=47; 122 public static final int INSTRUCTION_FORMAT12x_OR_ID=48; 123 public static final int INSTRUCTION_FORMAT20bc=49; 124 public static final int INSTRUCTION_FORMAT20t=50; 125 public static final int INSTRUCTION_FORMAT21c_FIELD=51; 126 public static final int INSTRUCTION_FORMAT21c_FIELD_ODEX=52; 127 public static final int INSTRUCTION_FORMAT21c_STRING=53; 128 public static final int INSTRUCTION_FORMAT21c_TYPE=54; 129 public static final int INSTRUCTION_FORMAT21ih=55; 130 public static final int INSTRUCTION_FORMAT21lh=56; 131 public static final int INSTRUCTION_FORMAT21s=57; 132 public static final int INSTRUCTION_FORMAT21t=58; 133 public static final int INSTRUCTION_FORMAT22b=59; 134 public static final int INSTRUCTION_FORMAT22c_FIELD=60; 135 public static final int INSTRUCTION_FORMAT22c_FIELD_ODEX=61; 136 public static final int INSTRUCTION_FORMAT22c_TYPE=62; 137 public static final int INSTRUCTION_FORMAT22cs_FIELD=63; 138 public static final int INSTRUCTION_FORMAT22s=64; 139 public static final int INSTRUCTION_FORMAT22s_OR_ID=65; 140 public static final int INSTRUCTION_FORMAT22t=66; 141 public static final int INSTRUCTION_FORMAT22x=67; 142 public static final int INSTRUCTION_FORMAT23x=68; 143 public static final int INSTRUCTION_FORMAT30t=69; 144 public static final int INSTRUCTION_FORMAT31c=70; 145 public static final int INSTRUCTION_FORMAT31i=71; 146 public static final int INSTRUCTION_FORMAT31i_OR_ID=72; 147 public static final int INSTRUCTION_FORMAT31t=73; 148 public static final int INSTRUCTION_FORMAT32x=74; 149 public static final int INSTRUCTION_FORMAT35c_METHOD=75; 150 public static final int INSTRUCTION_FORMAT35c_METHOD_ODEX=76; 151 public static final int INSTRUCTION_FORMAT35c_TYPE=77; 152 public static final int INSTRUCTION_FORMAT35mi_METHOD=78; 153 public static final int INSTRUCTION_FORMAT35ms_METHOD=79; 154 public static final int INSTRUCTION_FORMAT3rc_METHOD=80; 155 public static final int INSTRUCTION_FORMAT3rc_METHOD_ODEX=81; 156 public static final int INSTRUCTION_FORMAT3rc_TYPE=82; 157 public static final int INSTRUCTION_FORMAT3rmi_METHOD=83; 158 public static final int INSTRUCTION_FORMAT3rms_METHOD=84; 159 public static final int INSTRUCTION_FORMAT51l=85; 160 public static final int INTEGER_LITERAL=86; 161 public static final int INVALID_TOKEN=87; 162 public static final int I_ACCESS_LIST=88; 163 public static final int I_ANNOTATION=89; 164 public static final int I_ANNOTATIONS=90; 165 public static final int I_ANNOTATION_ELEMENT=91; 166 public static final int I_ARRAY_ELEMENTS=92; 167 public static final int I_ARRAY_ELEMENT_SIZE=93; 168 public static final int I_CATCH=94; 169 public static final int I_CATCHALL=95; 170 public static final int I_CATCHES=96; 171 public static final int I_CLASS_DEF=97; 172 public static final int I_ENCODED_ARRAY=98; 173 public static final int I_ENCODED_ENUM=99; 174 public static final int I_ENCODED_FIELD=100; 175 public static final int I_ENCODED_METHOD=101; 176 public static final int I_END_LOCAL=102; 177 public static final int I_EPILOGUE=103; 178 public static final int I_FIELD=104; 179 public static final int I_FIELDS=105; 180 public static final int I_FIELD_INITIAL_VALUE=106; 181 public static final int I_FIELD_TYPE=107; 182 public static final int I_IMPLEMENTS=108; 183 public static final int I_LABEL=109; 184 public static final int I_LINE=110; 185 public static final int I_LOCAL=111; 186 public static final int I_LOCALS=112; 187 public static final int I_METHOD=113; 188 public static final int I_METHODS=114; 189 public static final int I_METHOD_PROTOTYPE=115; 190 public static final int I_METHOD_RETURN_TYPE=116; 191 public static final int I_ORDERED_METHOD_ITEMS=117; 192 public static final int I_PACKED_SWITCH_ELEMENTS=118; 193 public static final int I_PACKED_SWITCH_START_KEY=119; 194 public static final int I_PARAMETER=120; 195 public static final int I_PARAMETERS=121; 196 public static final int I_PARAMETER_NOT_SPECIFIED=122; 197 public static final int I_PROLOGUE=123; 198 public static final int I_REGISTERS=124; 199 public static final int I_REGISTER_LIST=125; 200 public static final int I_REGISTER_RANGE=126; 201 public static final int I_RESTART_LOCAL=127; 202 public static final int I_SOURCE=128; 203 public static final int I_SPARSE_SWITCH_ELEMENTS=129; 204 public static final int I_STATEMENT_ARRAY_DATA=130; 205 public static final int I_STATEMENT_FORMAT10t=131; 206 public static final int I_STATEMENT_FORMAT10x=132; 207 public static final int I_STATEMENT_FORMAT11n=133; 208 public static final int I_STATEMENT_FORMAT11x=134; 209 public static final int I_STATEMENT_FORMAT12x=135; 210 public static final int I_STATEMENT_FORMAT20bc=136; 211 public static final int I_STATEMENT_FORMAT20t=137; 212 public static final int I_STATEMENT_FORMAT21c_FIELD=138; 213 public static final int I_STATEMENT_FORMAT21c_STRING=139; 214 public static final int I_STATEMENT_FORMAT21c_TYPE=140; 215 public static final int I_STATEMENT_FORMAT21ih=141; 216 public static final int I_STATEMENT_FORMAT21lh=142; 217 public static final int I_STATEMENT_FORMAT21s=143; 218 public static final int I_STATEMENT_FORMAT21t=144; 219 public static final int I_STATEMENT_FORMAT22b=145; 220 public static final int I_STATEMENT_FORMAT22c_FIELD=146; 221 public static final int I_STATEMENT_FORMAT22c_TYPE=147; 222 public static final int I_STATEMENT_FORMAT22s=148; 223 public static final int I_STATEMENT_FORMAT22t=149; 224 public static final int I_STATEMENT_FORMAT22x=150; 225 public static final int I_STATEMENT_FORMAT23x=151; 226 public static final int I_STATEMENT_FORMAT30t=152; 227 public static final int I_STATEMENT_FORMAT31c=153; 228 public static final int I_STATEMENT_FORMAT31i=154; 229 public static final int I_STATEMENT_FORMAT31t=155; 230 public static final int I_STATEMENT_FORMAT32x=156; 231 public static final int I_STATEMENT_FORMAT35c_METHOD=157; 232 public static final int I_STATEMENT_FORMAT35c_TYPE=158; 233 public static final int I_STATEMENT_FORMAT3rc_METHOD=159; 234 public static final int I_STATEMENT_FORMAT3rc_TYPE=160; 235 public static final int I_STATEMENT_FORMAT51l=161; 236 public static final int I_STATEMENT_PACKED_SWITCH=162; 237 public static final int I_STATEMENT_SPARSE_SWITCH=163; 238 public static final int I_SUBANNOTATION=164; 239 public static final int I_SUPER=165; 240 public static final int LINE_COMMENT=166; 241 public static final int LINE_DIRECTIVE=167; 242 public static final int LOCALS_DIRECTIVE=168; 243 public static final int LOCAL_DIRECTIVE=169; 244 public static final int LONG_LITERAL=170; 245 public static final int MEMBER_NAME=171; 246 public static final int METHOD_DIRECTIVE=172; 247 public static final int NEGATIVE_INTEGER_LITERAL=173; 248 public static final int NULL_LITERAL=174; 249 public static final int OPEN_BRACE=175; 250 public static final int OPEN_PAREN=176; 251 public static final int PACKED_SWITCH_DIRECTIVE=177; 252 public static final int PARAMETER_DIRECTIVE=178; 253 public static final int PARAM_LIST_END=179; 254 public static final int PARAM_LIST_OR_ID_END=180; 255 public static final int PARAM_LIST_OR_ID_START=181; 256 public static final int PARAM_LIST_START=182; 257 public static final int POSITIVE_INTEGER_LITERAL=183; 258 public static final int PRIMITIVE_TYPE=184; 259 public static final int PROLOGUE_DIRECTIVE=185; 260 public static final int REGISTER=186; 261 public static final int REGISTERS_DIRECTIVE=187; 262 public static final int RESTART_LOCAL_DIRECTIVE=188; 263 public static final int SHORT_LITERAL=189; 264 public static final int SIMPLE_NAME=190; 265 public static final int SOURCE_DIRECTIVE=191; 266 public static final int SPARSE_SWITCH_DIRECTIVE=192; 267 public static final int STRING_LITERAL=193; 268 public static final int SUBANNOTATION_DIRECTIVE=194; 269 public static final int SUPER_DIRECTIVE=195; 270 public static final int VERIFICATION_ERROR_TYPE=196; 271 public static final int VOID_TYPE=197; 272 public static final int VTABLE_INDEX=198; 273 public static final int WHITE_SPACE=199; 274 275 // delegates 276 public Parser[] getDelegates() { 277 return new Parser[] {}; 278 } 279 280 // delegators 281 282 283 public smaliParser(TokenStream input) { 284 this(input, new RecognizerSharedState()); 285 } 286 public smaliParser(TokenStream input, RecognizerSharedState state) { 287 super(input, state); 288 } 289 290 protected TreeAdaptor adaptor = new CommonTreeAdaptor(); 291 292 public void setTreeAdaptor(TreeAdaptor adaptor) { 293 this.adaptor = adaptor; 294 } 295 public TreeAdaptor getTreeAdaptor() { 296 return adaptor; 297 } 298 @Override public String[] getTokenNames() { return smaliParser.tokenNames; } 299 @Override public String getGrammarFileName() { return "/mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g"; } 300 301 302 public static final int ERROR_CHANNEL = 100; 303 304 private boolean verboseErrors = false; 305 private boolean allowOdex = false; 306 private int apiLevel = 15; 307 private Opcodes opcodes = new Opcodes(apiLevel); 308 309 public void setVerboseErrors(boolean verboseErrors) { 310 this.verboseErrors = verboseErrors; 311 } 312 313 public void setAllowOdex(boolean allowOdex) { 314 this.allowOdex = allowOdex; 315 } 316 317 public void setApiLevel(int apiLevel) { 318 this.opcodes = new Opcodes(apiLevel); 319 this.apiLevel = apiLevel; 320 } 321 322 public String getErrorMessage(RecognitionException e, 323 String[] tokenNames) { 324 325 if (verboseErrors) { 326 List stack = getRuleInvocationStack(e, this.getClass().getName()); 327 String msg = null; 328 329 if (e instanceof NoViableAltException) { 330 NoViableAltException nvae = (NoViableAltException)e; 331 msg = " no viable alt; token="+getTokenErrorDisplay(e.token)+ 332 " (decision="+nvae.decisionNumber+ 333 " state "+nvae.stateNumber+")"+ 334 " decision=<<"+nvae.grammarDecisionDescription+">>"; 335 } else { 336 msg = super.getErrorMessage(e, tokenNames); 337 } 338 339 return stack + " " + msg; 340 } else { 341 return super.getErrorMessage(e, tokenNames); 342 } 343 } 344 345 public String getTokenErrorDisplay(Token t) { 346 if (!verboseErrors) { 347 String s = t.getText(); 348 if ( s==null ) { 349 if ( t.getType()==Token.EOF ) { 350 s = "<EOF>"; 351 } 352 else { 353 s = "<"+tokenNames[t.getType()]+">"; 354 } 355 } 356 s = s.replaceAll("\n","\\\\n"); 357 s = s.replaceAll("\r","\\\\r"); 358 s = s.replaceAll("\t","\\\\t"); 359 return "'"+s+"'"; 360 } 361 362 CommonToken ct = (CommonToken)t; 363 364 String channelStr = ""; 365 if (t.getChannel()>0) { 366 channelStr=",channel="+t.getChannel(); 367 } 368 String txt = t.getText(); 369 if ( txt!=null ) { 370 txt = txt.replaceAll("\n","\\\\n"); 371 txt = txt.replaceAll("\r","\\\\r"); 372 txt = txt.replaceAll("\t","\\\\t"); 373 } 374 else { 375 txt = "<no text>"; 376 } 377 return "[@"+t.getTokenIndex()+","+ct.getStartIndex()+":"+ct.getStopIndex()+"='"+txt+"',<"+tokenNames[t.getType()]+">"+channelStr+","+t.getLine()+":"+t.getCharPositionInLine()+"]"; 378 } 379 380 public String getErrorHeader(RecognitionException e) { 381 return getSourceName()+"["+ e.line+","+e.charPositionInLine+"]"; 382 } 383 384 private CommonTree buildTree(int type, String text, List<CommonTree> children) { 385 CommonTree root = new CommonTree(new CommonToken(type, text)); 386 for (CommonTree child: children) { 387 root.addChild(child); 388 } 389 return root; 390 } 391 392 private CommonToken getParamListSubToken(CommonToken baseToken, String str, int typeStartIndex) { 393 CommonToken token = new CommonToken(baseToken); 394 token.setStartIndex(baseToken.getStartIndex() + typeStartIndex); 395 396 switch (str.charAt(typeStartIndex)) { 397 case 'Z': 398 case 'B': 399 case 'S': 400 case 'C': 401 case 'I': 402 case 'J': 403 case 'F': 404 case 'D': 405 { 406 token.setType(PRIMITIVE_TYPE); 407 token.setText(str.substring(typeStartIndex, typeStartIndex+1)); 408 token.setStopIndex(baseToken.getStartIndex() + typeStartIndex); 409 break; 410 } 411 case 'L': 412 { 413 int i = typeStartIndex; 414 while (str.charAt(++i) != ';'); 415 416 token.setType(CLASS_DESCRIPTOR); 417 token.setText(str.substring(typeStartIndex, i + 1)); 418 token.setStopIndex(baseToken.getStartIndex() + i); 419 break; 420 } 421 case '[': 422 { 423 int i = typeStartIndex; 424 while (str.charAt(++i) == '['); 425 426 if (str.charAt(i++) == 'L') { 427 while (str.charAt(i++) != ';'); 428 } 429 430 token.setType(ARRAY_DESCRIPTOR); 431 token.setText(str.substring(typeStartIndex, i)); 432 token.setStopIndex(baseToken.getStartIndex() + i - 1); 433 break; 434 } 435 default: 436 throw new RuntimeException(String.format("Invalid character '%c' in param list \"%s\" at position %d", str.charAt(typeStartIndex), str, typeStartIndex)); 437 } 438 439 return token; 440 } 441 442 private CommonTree parseParamList(CommonToken paramListToken) { 443 String paramList = paramListToken.getText(); 444 CommonTree root = new CommonTree(); 445 446 int startIndex = paramListToken.getStartIndex(); 447 448 int i=0; 449 while (i<paramList.length()) { 450 CommonToken token = getParamListSubToken(paramListToken, paramList, i); 451 root.addChild(new CommonTree(token)); 452 i += token.getText().length(); 453 } 454 455 if (root.getChildCount() == 0) { 456 return null; 457 } 458 return root; 459 } 460 461 private void throwOdexedInstructionException(IntStream input, String odexedInstruction) 462 throws OdexedInstructionException { 463 /*this has to be done in a separate method, otherwise java will complain about the 464 auto-generated code in the rule after the throw not being reachable*/ 465 throw new OdexedInstructionException(input, odexedInstruction); 466 } 467 468 469 protected static class smali_file_scope { 470 boolean hasClassSpec; 471 boolean hasSuperSpec; 472 boolean hasSourceSpec; 473 List<CommonTree> classAnnotations; 474 } 475 protected Stack<smali_file_scope> smali_file_stack = new Stack<smali_file_scope>(); 476 477 public static class smali_file_return extends ParserRuleReturnScope { 478 CommonTree tree; 479 @Override 480 public CommonTree getTree() { return tree; } 481 }; 482 483 484 // $ANTLR start "smali_file" 485 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:418: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 )* ) ) ; 486 public final smaliParser.smali_file_return smali_file() throws RecognitionException { 487 smali_file_stack.push(new smali_file_scope()); 488 smaliParser.smali_file_return retval = new smaliParser.smali_file_return(); 489 retval.start = input.LT(1); 490 491 CommonTree root_0 = null; 492 493 Token EOF8=null; 494 ParserRuleReturnScope class_spec1 =null; 495 ParserRuleReturnScope super_spec2 =null; 496 ParserRuleReturnScope implements_spec3 =null; 497 ParserRuleReturnScope source_spec4 =null; 498 ParserRuleReturnScope method5 =null; 499 ParserRuleReturnScope field6 =null; 500 ParserRuleReturnScope annotation7 =null; 501 502 CommonTree EOF8_tree=null; 503 RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF"); 504 RewriteRuleSubtreeStream stream_field=new RewriteRuleSubtreeStream(adaptor,"rule field"); 505 RewriteRuleSubtreeStream stream_annotation=new RewriteRuleSubtreeStream(adaptor,"rule annotation"); 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 RewriteRuleSubtreeStream stream_method=new RewriteRuleSubtreeStream(adaptor,"rule method"); 510 RewriteRuleSubtreeStream stream_class_spec=new RewriteRuleSubtreeStream(adaptor,"rule class_spec"); 511 512 smali_file_stack.peek().hasClassSpec = smali_file_stack.peek().hasSuperSpec = smali_file_stack.peek().hasSourceSpec = false; 513 smali_file_stack.peek().classAnnotations = new ArrayList<CommonTree>(); 514 515 try { 516 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:430: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 )* ) ) ) 517 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:431:3: ({...}? => class_spec |{...}? => super_spec | implements_spec |{...}? => source_spec | method | field | annotation )+ EOF 518 { 519 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:431:3: ({...}? => class_spec |{...}? => super_spec | implements_spec |{...}? => source_spec | method | field | annotation )+ 520 int cnt1=0; 521 loop1: 522 while (true) { 523 int alt1=8; 524 int LA1_0 = input.LA(1); 525 if ( (LA1_0==CLASS_DIRECTIVE) && ((!smali_file_stack.peek().hasClassSpec))) { 526 alt1=1; 527 } 528 else if ( (LA1_0==SUPER_DIRECTIVE) && ((!smali_file_stack.peek().hasSuperSpec))) { 529 alt1=2; 530 } 531 else if ( (LA1_0==IMPLEMENTS_DIRECTIVE) ) { 532 alt1=3; 533 } 534 else if ( (LA1_0==SOURCE_DIRECTIVE) && ((!smali_file_stack.peek().hasSourceSpec))) { 535 alt1=4; 536 } 537 else if ( (LA1_0==METHOD_DIRECTIVE) ) { 538 alt1=5; 539 } 540 else if ( (LA1_0==FIELD_DIRECTIVE) ) { 541 alt1=6; 542 } 543 else if ( (LA1_0==ANNOTATION_DIRECTIVE) ) { 544 alt1=7; 545 } 546 547 switch (alt1) { 548 case 1 : 549 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:431:5: {...}? => class_spec 550 { 551 if ( !((!smali_file_stack.peek().hasClassSpec)) ) { 552 throw new FailedPredicateException(input, "smali_file", "!$smali_file::hasClassSpec"); 553 } 554 pushFollow(FOLLOW_class_spec_in_smali_file1070); 555 class_spec1=class_spec(); 556 state._fsp--; 557 558 stream_class_spec.add(class_spec1.getTree()); 559 smali_file_stack.peek().hasClassSpec = true; 560 } 561 break; 562 case 2 : 563 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:432:5: {...}? => super_spec 564 { 565 if ( !((!smali_file_stack.peek().hasSuperSpec)) ) { 566 throw new FailedPredicateException(input, "smali_file", "!$smali_file::hasSuperSpec"); 567 } 568 pushFollow(FOLLOW_super_spec_in_smali_file1081); 569 super_spec2=super_spec(); 570 state._fsp--; 571 572 stream_super_spec.add(super_spec2.getTree()); 573 smali_file_stack.peek().hasSuperSpec = true; 574 } 575 break; 576 case 3 : 577 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:433:5: implements_spec 578 { 579 pushFollow(FOLLOW_implements_spec_in_smali_file1089); 580 implements_spec3=implements_spec(); 581 state._fsp--; 582 583 stream_implements_spec.add(implements_spec3.getTree()); 584 } 585 break; 586 case 4 : 587 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:434:5: {...}? => source_spec 588 { 589 if ( !((!smali_file_stack.peek().hasSourceSpec)) ) { 590 throw new FailedPredicateException(input, "smali_file", "!$smali_file::hasSourceSpec"); 591 } 592 pushFollow(FOLLOW_source_spec_in_smali_file1098); 593 source_spec4=source_spec(); 594 state._fsp--; 595 596 stream_source_spec.add(source_spec4.getTree()); 597 smali_file_stack.peek().hasSourceSpec = true; 598 } 599 break; 600 case 5 : 601 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:435:5: method 602 { 603 pushFollow(FOLLOW_method_in_smali_file1106); 604 method5=method(); 605 state._fsp--; 606 607 stream_method.add(method5.getTree()); 608 } 609 break; 610 case 6 : 611 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:436:5: field 612 { 613 pushFollow(FOLLOW_field_in_smali_file1112); 614 field6=field(); 615 state._fsp--; 616 617 stream_field.add(field6.getTree()); 618 } 619 break; 620 case 7 : 621 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:437:5: annotation 622 { 623 pushFollow(FOLLOW_annotation_in_smali_file1118); 624 annotation7=annotation(); 625 state._fsp--; 626 627 stream_annotation.add(annotation7.getTree()); 628 smali_file_stack.peek().classAnnotations.add((annotation7!=null?((CommonTree)annotation7.getTree()):null)); 629 } 630 break; 631 632 default : 633 if ( cnt1 >= 1 ) break loop1; 634 EarlyExitException eee = new EarlyExitException(1, input); 635 throw eee; 636 } 637 cnt1++; 638 } 639 640 EOF8=(Token)match(input,EOF,FOLLOW_EOF_in_smali_file1129); 641 stream_EOF.add(EOF8); 642 643 644 if (!smali_file_stack.peek().hasClassSpec) { 645 throw new SemanticException(input, "The file must contain a .class directive"); 646 } 647 648 if (!smali_file_stack.peek().hasSuperSpec) { 649 if (!(class_spec1!=null?((smaliParser.class_spec_return)class_spec1).className:null).equals("Ljava/lang/Object;")) { 650 throw new SemanticException(input, "The file must contain a .super directive"); 651 } 652 } 653 654 // AST REWRITE 655 // elements: method, field, source_spec, implements_spec, super_spec, class_spec 656 // token labels: 657 // rule labels: retval 658 // token list labels: 659 // rule list labels: 660 // wildcard labels: 661 retval.tree = root_0; 662 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 663 664 root_0 = (CommonTree)adaptor.nil(); 665 // 451:3: -> ^( I_CLASS_DEF class_spec ( super_spec )? ( implements_spec )* ( source_spec )? ^( I_METHODS ( method )* ) ^( I_FIELDS ( field )* ) ) 666 { 667 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:451:6: ^( I_CLASS_DEF class_spec ( super_spec )? ( implements_spec )* ( source_spec )? ^( I_METHODS ( method )* ) ^( I_FIELDS ( field )* ) ) 668 { 669 CommonTree root_1 = (CommonTree)adaptor.nil(); 670 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_CLASS_DEF, "I_CLASS_DEF"), root_1); 671 adaptor.addChild(root_1, stream_class_spec.nextTree()); 672 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:453:8: ( super_spec )? 673 if ( stream_super_spec.hasNext() ) { 674 adaptor.addChild(root_1, stream_super_spec.nextTree()); 675 } 676 stream_super_spec.reset(); 677 678 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:454:8: ( implements_spec )* 679 while ( stream_implements_spec.hasNext() ) { 680 adaptor.addChild(root_1, stream_implements_spec.nextTree()); 681 } 682 stream_implements_spec.reset(); 683 684 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:455:8: ( source_spec )? 685 if ( stream_source_spec.hasNext() ) { 686 adaptor.addChild(root_1, stream_source_spec.nextTree()); 687 } 688 stream_source_spec.reset(); 689 690 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:456:8: ^( I_METHODS ( method )* ) 691 { 692 CommonTree root_2 = (CommonTree)adaptor.nil(); 693 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_METHODS, "I_METHODS"), root_2); 694 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:456:20: ( method )* 695 while ( stream_method.hasNext() ) { 696 adaptor.addChild(root_2, stream_method.nextTree()); 697 } 698 stream_method.reset(); 699 700 adaptor.addChild(root_1, root_2); 701 } 702 703 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:456:29: ^( I_FIELDS ( field )* ) 704 { 705 CommonTree root_2 = (CommonTree)adaptor.nil(); 706 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELDS, "I_FIELDS"), root_2); 707 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:456:40: ( field )* 708 while ( stream_field.hasNext() ) { 709 adaptor.addChild(root_2, stream_field.nextTree()); 710 } 711 stream_field.reset(); 712 713 adaptor.addChild(root_1, root_2); 714 } 715 716 adaptor.addChild(root_1, buildTree(I_ANNOTATIONS, "I_ANNOTATIONS", smali_file_stack.peek().classAnnotations)); 717 adaptor.addChild(root_0, root_1); 718 } 719 720 } 721 722 723 retval.tree = root_0; 724 725 } 726 727 retval.stop = input.LT(-1); 728 729 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 730 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 731 732 } 733 catch (RecognitionException re) { 734 reportError(re); 735 recover(input,re); 736 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 737 } 738 finally { 739 // do for sure before leaving 740 smali_file_stack.pop(); 741 } 742 return retval; 743 } 744 // $ANTLR end "smali_file" 745 746 747 public static class class_spec_return extends ParserRuleReturnScope { 748 public String className; 749 CommonTree tree; 750 @Override 751 public CommonTree getTree() { return tree; } 752 }; 753 754 755 // $ANTLR start "class_spec" 756 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:458:1: class_spec returns [String className] : CLASS_DIRECTIVE access_list CLASS_DESCRIPTOR -> CLASS_DESCRIPTOR access_list ; 757 public final smaliParser.class_spec_return class_spec() throws RecognitionException { 758 smaliParser.class_spec_return retval = new smaliParser.class_spec_return(); 759 retval.start = input.LT(1); 760 761 CommonTree root_0 = null; 762 763 Token CLASS_DIRECTIVE9=null; 764 Token CLASS_DESCRIPTOR11=null; 765 ParserRuleReturnScope access_list10 =null; 766 767 CommonTree CLASS_DIRECTIVE9_tree=null; 768 CommonTree CLASS_DESCRIPTOR11_tree=null; 769 RewriteRuleTokenStream stream_CLASS_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token CLASS_DIRECTIVE"); 770 RewriteRuleTokenStream stream_CLASS_DESCRIPTOR=new RewriteRuleTokenStream(adaptor,"token CLASS_DESCRIPTOR"); 771 RewriteRuleSubtreeStream stream_access_list=new RewriteRuleSubtreeStream(adaptor,"rule access_list"); 772 773 try { 774 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:459:3: ( CLASS_DIRECTIVE access_list CLASS_DESCRIPTOR -> CLASS_DESCRIPTOR access_list ) 775 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:459:5: CLASS_DIRECTIVE access_list CLASS_DESCRIPTOR 776 { 777 CLASS_DIRECTIVE9=(Token)match(input,CLASS_DIRECTIVE,FOLLOW_CLASS_DIRECTIVE_in_class_spec1216); 778 stream_CLASS_DIRECTIVE.add(CLASS_DIRECTIVE9); 779 780 pushFollow(FOLLOW_access_list_in_class_spec1218); 781 access_list10=access_list(); 782 state._fsp--; 783 784 stream_access_list.add(access_list10.getTree()); 785 CLASS_DESCRIPTOR11=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_class_spec1220); 786 stream_CLASS_DESCRIPTOR.add(CLASS_DESCRIPTOR11); 787 788 retval.className = (CLASS_DESCRIPTOR11!=null?CLASS_DESCRIPTOR11.getText():null); 789 // AST REWRITE 790 // elements: CLASS_DESCRIPTOR, access_list 791 // token labels: 792 // rule labels: retval 793 // token list labels: 794 // rule list labels: 795 // wildcard labels: 796 retval.tree = root_0; 797 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 798 799 root_0 = (CommonTree)adaptor.nil(); 800 // 459:89: -> CLASS_DESCRIPTOR access_list 801 { 802 adaptor.addChild(root_0, stream_CLASS_DESCRIPTOR.nextNode()); 803 adaptor.addChild(root_0, stream_access_list.nextTree()); 804 } 805 806 807 retval.tree = root_0; 808 809 } 810 811 retval.stop = input.LT(-1); 812 813 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 814 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 815 816 } 817 catch (RecognitionException re) { 818 reportError(re); 819 recover(input,re); 820 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 821 } 822 finally { 823 // do for sure before leaving 824 } 825 return retval; 826 } 827 // $ANTLR end "class_spec" 828 829 830 public static class super_spec_return extends ParserRuleReturnScope { 831 CommonTree tree; 832 @Override 833 public CommonTree getTree() { return tree; } 834 }; 835 836 837 // $ANTLR start "super_spec" 838 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:461:1: super_spec : SUPER_DIRECTIVE CLASS_DESCRIPTOR -> ^( I_SUPER[$start, \"I_SUPER\"] CLASS_DESCRIPTOR ) ; 839 public final smaliParser.super_spec_return super_spec() throws RecognitionException { 840 smaliParser.super_spec_return retval = new smaliParser.super_spec_return(); 841 retval.start = input.LT(1); 842 843 CommonTree root_0 = null; 844 845 Token SUPER_DIRECTIVE12=null; 846 Token CLASS_DESCRIPTOR13=null; 847 848 CommonTree SUPER_DIRECTIVE12_tree=null; 849 CommonTree CLASS_DESCRIPTOR13_tree=null; 850 RewriteRuleTokenStream stream_SUPER_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token SUPER_DIRECTIVE"); 851 RewriteRuleTokenStream stream_CLASS_DESCRIPTOR=new RewriteRuleTokenStream(adaptor,"token CLASS_DESCRIPTOR"); 852 853 try { 854 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:462:3: ( SUPER_DIRECTIVE CLASS_DESCRIPTOR -> ^( I_SUPER[$start, \"I_SUPER\"] CLASS_DESCRIPTOR ) ) 855 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:462:5: SUPER_DIRECTIVE CLASS_DESCRIPTOR 856 { 857 SUPER_DIRECTIVE12=(Token)match(input,SUPER_DIRECTIVE,FOLLOW_SUPER_DIRECTIVE_in_super_spec1238); 858 stream_SUPER_DIRECTIVE.add(SUPER_DIRECTIVE12); 859 860 CLASS_DESCRIPTOR13=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_super_spec1240); 861 stream_CLASS_DESCRIPTOR.add(CLASS_DESCRIPTOR13); 862 863 // AST REWRITE 864 // elements: CLASS_DESCRIPTOR 865 // token labels: 866 // rule labels: retval 867 // token list labels: 868 // rule list labels: 869 // wildcard labels: 870 retval.tree = root_0; 871 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 872 873 root_0 = (CommonTree)adaptor.nil(); 874 // 462:38: -> ^( I_SUPER[$start, \"I_SUPER\"] CLASS_DESCRIPTOR ) 875 { 876 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:462:41: ^( I_SUPER[$start, \"I_SUPER\"] CLASS_DESCRIPTOR ) 877 { 878 CommonTree root_1 = (CommonTree)adaptor.nil(); 879 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_SUPER, (retval.start), "I_SUPER"), root_1); 880 adaptor.addChild(root_1, stream_CLASS_DESCRIPTOR.nextNode()); 881 adaptor.addChild(root_0, root_1); 882 } 883 884 } 885 886 887 retval.tree = root_0; 888 889 } 890 891 retval.stop = input.LT(-1); 892 893 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 894 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 895 896 } 897 catch (RecognitionException re) { 898 reportError(re); 899 recover(input,re); 900 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 901 } 902 finally { 903 // do for sure before leaving 904 } 905 return retval; 906 } 907 // $ANTLR end "super_spec" 908 909 910 public static class implements_spec_return extends ParserRuleReturnScope { 911 CommonTree tree; 912 @Override 913 public CommonTree getTree() { return tree; } 914 }; 915 916 917 // $ANTLR start "implements_spec" 918 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:464:1: implements_spec : IMPLEMENTS_DIRECTIVE CLASS_DESCRIPTOR -> ^( I_IMPLEMENTS[$start, \"I_IMPLEMENTS\"] CLASS_DESCRIPTOR ) ; 919 public final smaliParser.implements_spec_return implements_spec() throws RecognitionException { 920 smaliParser.implements_spec_return retval = new smaliParser.implements_spec_return(); 921 retval.start = input.LT(1); 922 923 CommonTree root_0 = null; 924 925 Token IMPLEMENTS_DIRECTIVE14=null; 926 Token CLASS_DESCRIPTOR15=null; 927 928 CommonTree IMPLEMENTS_DIRECTIVE14_tree=null; 929 CommonTree CLASS_DESCRIPTOR15_tree=null; 930 RewriteRuleTokenStream stream_IMPLEMENTS_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token IMPLEMENTS_DIRECTIVE"); 931 RewriteRuleTokenStream stream_CLASS_DESCRIPTOR=new RewriteRuleTokenStream(adaptor,"token CLASS_DESCRIPTOR"); 932 933 try { 934 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:465:3: ( IMPLEMENTS_DIRECTIVE CLASS_DESCRIPTOR -> ^( I_IMPLEMENTS[$start, \"I_IMPLEMENTS\"] CLASS_DESCRIPTOR ) ) 935 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:465:5: IMPLEMENTS_DIRECTIVE CLASS_DESCRIPTOR 936 { 937 IMPLEMENTS_DIRECTIVE14=(Token)match(input,IMPLEMENTS_DIRECTIVE,FOLLOW_IMPLEMENTS_DIRECTIVE_in_implements_spec1259); 938 stream_IMPLEMENTS_DIRECTIVE.add(IMPLEMENTS_DIRECTIVE14); 939 940 CLASS_DESCRIPTOR15=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_implements_spec1261); 941 stream_CLASS_DESCRIPTOR.add(CLASS_DESCRIPTOR15); 942 943 // AST REWRITE 944 // elements: CLASS_DESCRIPTOR 945 // token labels: 946 // rule labels: retval 947 // token list labels: 948 // rule list labels: 949 // wildcard labels: 950 retval.tree = root_0; 951 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 952 953 root_0 = (CommonTree)adaptor.nil(); 954 // 465:43: -> ^( I_IMPLEMENTS[$start, \"I_IMPLEMENTS\"] CLASS_DESCRIPTOR ) 955 { 956 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:465:46: ^( I_IMPLEMENTS[$start, \"I_IMPLEMENTS\"] CLASS_DESCRIPTOR ) 957 { 958 CommonTree root_1 = (CommonTree)adaptor.nil(); 959 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_IMPLEMENTS, (retval.start), "I_IMPLEMENTS"), root_1); 960 adaptor.addChild(root_1, stream_CLASS_DESCRIPTOR.nextNode()); 961 adaptor.addChild(root_0, root_1); 962 } 963 964 } 965 966 967 retval.tree = root_0; 968 969 } 970 971 retval.stop = input.LT(-1); 972 973 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 974 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 975 976 } 977 catch (RecognitionException re) { 978 reportError(re); 979 recover(input,re); 980 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 981 } 982 finally { 983 // do for sure before leaving 984 } 985 return retval; 986 } 987 // $ANTLR end "implements_spec" 988 989 990 public static class source_spec_return extends ParserRuleReturnScope { 991 CommonTree tree; 992 @Override 993 public CommonTree getTree() { return tree; } 994 }; 995 996 997 // $ANTLR start "source_spec" 998 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:467:1: source_spec : SOURCE_DIRECTIVE STRING_LITERAL -> ^( I_SOURCE[$start, \"I_SOURCE\"] STRING_LITERAL ) ; 999 public final smaliParser.source_spec_return source_spec() throws RecognitionException { 1000 smaliParser.source_spec_return retval = new smaliParser.source_spec_return(); 1001 retval.start = input.LT(1); 1002 1003 CommonTree root_0 = null; 1004 1005 Token SOURCE_DIRECTIVE16=null; 1006 Token STRING_LITERAL17=null; 1007 1008 CommonTree SOURCE_DIRECTIVE16_tree=null; 1009 CommonTree STRING_LITERAL17_tree=null; 1010 RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL"); 1011 RewriteRuleTokenStream stream_SOURCE_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token SOURCE_DIRECTIVE"); 1012 1013 try { 1014 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:468:3: ( SOURCE_DIRECTIVE STRING_LITERAL -> ^( I_SOURCE[$start, \"I_SOURCE\"] STRING_LITERAL ) ) 1015 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:468:5: SOURCE_DIRECTIVE STRING_LITERAL 1016 { 1017 SOURCE_DIRECTIVE16=(Token)match(input,SOURCE_DIRECTIVE,FOLLOW_SOURCE_DIRECTIVE_in_source_spec1280); 1018 stream_SOURCE_DIRECTIVE.add(SOURCE_DIRECTIVE16); 1019 1020 STRING_LITERAL17=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_source_spec1282); 1021 stream_STRING_LITERAL.add(STRING_LITERAL17); 1022 1023 // AST REWRITE 1024 // elements: STRING_LITERAL 1025 // token labels: 1026 // rule labels: retval 1027 // token list labels: 1028 // rule list labels: 1029 // wildcard labels: 1030 retval.tree = root_0; 1031 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 1032 1033 root_0 = (CommonTree)adaptor.nil(); 1034 // 468:37: -> ^( I_SOURCE[$start, \"I_SOURCE\"] STRING_LITERAL ) 1035 { 1036 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:468:40: ^( I_SOURCE[$start, \"I_SOURCE\"] STRING_LITERAL ) 1037 { 1038 CommonTree root_1 = (CommonTree)adaptor.nil(); 1039 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_SOURCE, (retval.start), "I_SOURCE"), root_1); 1040 adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode()); 1041 adaptor.addChild(root_0, root_1); 1042 } 1043 1044 } 1045 1046 1047 retval.tree = root_0; 1048 1049 } 1050 1051 retval.stop = input.LT(-1); 1052 1053 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 1054 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 1055 1056 } 1057 catch (RecognitionException re) { 1058 reportError(re); 1059 recover(input,re); 1060 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 1061 } 1062 finally { 1063 // do for sure before leaving 1064 } 1065 return retval; 1066 } 1067 // $ANTLR end "source_spec" 1068 1069 1070 public static class access_list_return extends ParserRuleReturnScope { 1071 CommonTree tree; 1072 @Override 1073 public CommonTree getTree() { return tree; } 1074 }; 1075 1076 1077 // $ANTLR start "access_list" 1078 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:470:1: access_list : ( ACCESS_SPEC )* -> ^( I_ACCESS_LIST[$start,\"I_ACCESS_LIST\"] ( ACCESS_SPEC )* ) ; 1079 public final smaliParser.access_list_return access_list() throws RecognitionException { 1080 smaliParser.access_list_return retval = new smaliParser.access_list_return(); 1081 retval.start = input.LT(1); 1082 1083 CommonTree root_0 = null; 1084 1085 Token ACCESS_SPEC18=null; 1086 1087 CommonTree ACCESS_SPEC18_tree=null; 1088 RewriteRuleTokenStream stream_ACCESS_SPEC=new RewriteRuleTokenStream(adaptor,"token ACCESS_SPEC"); 1089 1090 try { 1091 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:471:3: ( ( ACCESS_SPEC )* -> ^( I_ACCESS_LIST[$start,\"I_ACCESS_LIST\"] ( ACCESS_SPEC )* ) ) 1092 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:471:5: ( ACCESS_SPEC )* 1093 { 1094 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:471:5: ( ACCESS_SPEC )* 1095 loop2: 1096 while (true) { 1097 int alt2=2; 1098 int LA2_0 = input.LA(1); 1099 if ( (LA2_0==ACCESS_SPEC) ) { 1100 int LA2_2 = input.LA(2); 1101 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_FORMAT51l||LA2_2==MEMBER_NAME||(LA2_2 >= NEGATIVE_INTEGER_LITERAL && LA2_2 <= NULL_LITERAL)||LA2_2==PARAM_LIST_OR_ID_START||(LA2_2 >= POSITIVE_INTEGER_LITERAL && LA2_2 <= PRIMITIVE_TYPE)||LA2_2==REGISTER||LA2_2==SIMPLE_NAME||(LA2_2 >= VERIFICATION_ERROR_TYPE && LA2_2 <= VOID_TYPE)) ) { 1102 alt2=1; 1103 } 1104 1105 } 1106 1107 switch (alt2) { 1108 case 1 : 1109 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:471:5: ACCESS_SPEC 1110 { 1111 ACCESS_SPEC18=(Token)match(input,ACCESS_SPEC,FOLLOW_ACCESS_SPEC_in_access_list1301); 1112 stream_ACCESS_SPEC.add(ACCESS_SPEC18); 1113 1114 } 1115 break; 1116 1117 default : 1118 break loop2; 1119 } 1120 } 1121 1122 // AST REWRITE 1123 // elements: ACCESS_SPEC 1124 // token labels: 1125 // rule labels: retval 1126 // token list labels: 1127 // rule list labels: 1128 // wildcard labels: 1129 retval.tree = root_0; 1130 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 1131 1132 root_0 = (CommonTree)adaptor.nil(); 1133 // 471:18: -> ^( I_ACCESS_LIST[$start,\"I_ACCESS_LIST\"] ( ACCESS_SPEC )* ) 1134 { 1135 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:471:21: ^( I_ACCESS_LIST[$start,\"I_ACCESS_LIST\"] ( ACCESS_SPEC )* ) 1136 { 1137 CommonTree root_1 = (CommonTree)adaptor.nil(); 1138 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ACCESS_LIST, (retval.start), "I_ACCESS_LIST"), root_1); 1139 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:471:61: ( ACCESS_SPEC )* 1140 while ( stream_ACCESS_SPEC.hasNext() ) { 1141 adaptor.addChild(root_1, stream_ACCESS_SPEC.nextNode()); 1142 } 1143 stream_ACCESS_SPEC.reset(); 1144 1145 adaptor.addChild(root_0, root_1); 1146 } 1147 1148 } 1149 1150 1151 retval.tree = root_0; 1152 1153 } 1154 1155 retval.stop = input.LT(-1); 1156 1157 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 1158 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 1159 1160 } 1161 catch (RecognitionException re) { 1162 reportError(re); 1163 recover(input,re); 1164 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 1165 } 1166 finally { 1167 // do for sure before leaving 1168 } 1169 return retval; 1170 } 1171 // $ANTLR end "access_list" 1172 1173 1174 public static class field_return extends ParserRuleReturnScope { 1175 CommonTree tree; 1176 @Override 1177 public CommonTree getTree() { return tree; } 1178 }; 1179 1180 1181 // $ANTLR start "field" 1182 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:478: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 ) ) ) ) ; 1183 public final smaliParser.field_return field() throws RecognitionException { 1184 smaliParser.field_return retval = new smaliParser.field_return(); 1185 retval.start = input.LT(1); 1186 1187 CommonTree root_0 = null; 1188 1189 Token FIELD_DIRECTIVE19=null; 1190 Token COLON22=null; 1191 Token EQUAL24=null; 1192 Token END_FIELD_DIRECTIVE27=null; 1193 ParserRuleReturnScope access_list20 =null; 1194 ParserRuleReturnScope member_name21 =null; 1195 ParserRuleReturnScope nonvoid_type_descriptor23 =null; 1196 ParserRuleReturnScope literal25 =null; 1197 ParserRuleReturnScope annotation26 =null; 1198 1199 CommonTree FIELD_DIRECTIVE19_tree=null; 1200 CommonTree COLON22_tree=null; 1201 CommonTree EQUAL24_tree=null; 1202 CommonTree END_FIELD_DIRECTIVE27_tree=null; 1203 RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON"); 1204 RewriteRuleTokenStream stream_FIELD_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token FIELD_DIRECTIVE"); 1205 RewriteRuleTokenStream stream_EQUAL=new RewriteRuleTokenStream(adaptor,"token EQUAL"); 1206 RewriteRuleTokenStream stream_END_FIELD_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_FIELD_DIRECTIVE"); 1207 RewriteRuleSubtreeStream stream_annotation=new RewriteRuleSubtreeStream(adaptor,"rule annotation"); 1208 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 1209 RewriteRuleSubtreeStream stream_access_list=new RewriteRuleSubtreeStream(adaptor,"rule access_list"); 1210 RewriteRuleSubtreeStream stream_member_name=new RewriteRuleSubtreeStream(adaptor,"rule member_name"); 1211 RewriteRuleSubtreeStream stream_literal=new RewriteRuleSubtreeStream(adaptor,"rule literal"); 1212 1213 List<CommonTree> annotations = new ArrayList<CommonTree>(); 1214 try { 1215 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:480: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 ) ) ) ) ) 1216 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:480: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 ) ) ) ) 1217 { 1218 FIELD_DIRECTIVE19=(Token)match(input,FIELD_DIRECTIVE,FOLLOW_FIELD_DIRECTIVE_in_field1332); 1219 stream_FIELD_DIRECTIVE.add(FIELD_DIRECTIVE19); 1220 1221 pushFollow(FOLLOW_access_list_in_field1334); 1222 access_list20=access_list(); 1223 state._fsp--; 1224 1225 stream_access_list.add(access_list20.getTree()); 1226 pushFollow(FOLLOW_member_name_in_field1336); 1227 member_name21=member_name(); 1228 state._fsp--; 1229 1230 stream_member_name.add(member_name21.getTree()); 1231 COLON22=(Token)match(input,COLON,FOLLOW_COLON_in_field1338); 1232 stream_COLON.add(COLON22); 1233 1234 pushFollow(FOLLOW_nonvoid_type_descriptor_in_field1340); 1235 nonvoid_type_descriptor23=nonvoid_type_descriptor(); 1236 state._fsp--; 1237 1238 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor23.getTree()); 1239 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:480:75: ( EQUAL literal )? 1240 int alt3=2; 1241 int LA3_0 = input.LA(1); 1242 if ( (LA3_0==EQUAL) ) { 1243 alt3=1; 1244 } 1245 switch (alt3) { 1246 case 1 : 1247 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:480:76: EQUAL literal 1248 { 1249 EQUAL24=(Token)match(input,EQUAL,FOLLOW_EQUAL_in_field1343); 1250 stream_EQUAL.add(EQUAL24); 1251 1252 pushFollow(FOLLOW_literal_in_field1345); 1253 literal25=literal(); 1254 state._fsp--; 1255 1256 stream_literal.add(literal25.getTree()); 1257 } 1258 break; 1259 1260 } 1261 1262 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:481: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 ) ) ) ) 1263 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:481: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 ) ) ) 1264 { 1265 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:481:7: ({...}? annotation )* 1266 loop4: 1267 while (true) { 1268 int alt4=2; 1269 int LA4_0 = input.LA(1); 1270 if ( (LA4_0==ANNOTATION_DIRECTIVE) ) { 1271 int LA4_9 = input.LA(2); 1272 if ( ((input.LA(1) == ANNOTATION_DIRECTIVE)) ) { 1273 alt4=1; 1274 } 1275 1276 } 1277 1278 switch (alt4) { 1279 case 1 : 1280 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:481:8: {...}? annotation 1281 { 1282 if ( !((input.LA(1) == ANNOTATION_DIRECTIVE)) ) { 1283 throw new FailedPredicateException(input, "field", "input.LA(1) == ANNOTATION_DIRECTIVE"); 1284 } 1285 pushFollow(FOLLOW_annotation_in_field1358); 1286 annotation26=annotation(); 1287 state._fsp--; 1288 1289 stream_annotation.add(annotation26.getTree()); 1290 annotations.add((annotation26!=null?((CommonTree)annotation26.getTree()):null)); 1291 } 1292 break; 1293 1294 default : 1295 break loop4; 1296 } 1297 } 1298 1299 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:482: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 ) ) ) 1300 int alt5=2; 1301 int LA5_0 = input.LA(1); 1302 if ( (LA5_0==END_FIELD_DIRECTIVE) ) { 1303 alt5=1; 1304 } 1305 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) ) { 1306 alt5=2; 1307 } 1308 1309 else { 1310 NoViableAltException nvae = 1311 new NoViableAltException("", 5, 0, input); 1312 throw nvae; 1313 } 1314 1315 switch (alt5) { 1316 case 1 : 1317 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:482:9: END_FIELD_DIRECTIVE 1318 { 1319 END_FIELD_DIRECTIVE27=(Token)match(input,END_FIELD_DIRECTIVE,FOLLOW_END_FIELD_DIRECTIVE_in_field1372); 1320 stream_END_FIELD_DIRECTIVE.add(END_FIELD_DIRECTIVE27); 1321 1322 // AST REWRITE 1323 // elements: literal, member_name, access_list, annotation, nonvoid_type_descriptor 1324 // token labels: 1325 // rule labels: retval 1326 // token list labels: 1327 // rule list labels: 1328 // wildcard labels: 1329 retval.tree = root_0; 1330 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 1331 1332 root_0 = (CommonTree)adaptor.nil(); 1333 // 483:9: -> ^( 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 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:483:12: ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ( annotation )* ) ) 1336 { 1337 CommonTree root_1 = (CommonTree)adaptor.nil(); 1338 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELD, (retval.start), "I_FIELD"), root_1); 1339 adaptor.addChild(root_1, stream_member_name.nextTree()); 1340 adaptor.addChild(root_1, stream_access_list.nextTree()); 1341 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:483:65: ^( I_FIELD_TYPE nonvoid_type_descriptor ) 1342 { 1343 CommonTree root_2 = (CommonTree)adaptor.nil(); 1344 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELD_TYPE, "I_FIELD_TYPE"), root_2); 1345 adaptor.addChild(root_2, stream_nonvoid_type_descriptor.nextTree()); 1346 adaptor.addChild(root_1, root_2); 1347 } 1348 1349 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:483:105: ( ^( I_FIELD_INITIAL_VALUE literal ) )? 1350 if ( stream_literal.hasNext() ) { 1351 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:483:105: ^( I_FIELD_INITIAL_VALUE literal ) 1352 { 1353 CommonTree root_2 = (CommonTree)adaptor.nil(); 1354 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELD_INITIAL_VALUE, "I_FIELD_INITIAL_VALUE"), root_2); 1355 adaptor.addChild(root_2, stream_literal.nextTree()); 1356 adaptor.addChild(root_1, root_2); 1357 } 1358 1359 } 1360 stream_literal.reset(); 1361 1362 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:483:139: ^( I_ANNOTATIONS ( annotation )* ) 1363 { 1364 CommonTree root_2 = (CommonTree)adaptor.nil(); 1365 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ANNOTATIONS, "I_ANNOTATIONS"), root_2); 1366 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:483:155: ( annotation )* 1367 while ( stream_annotation.hasNext() ) { 1368 adaptor.addChild(root_2, stream_annotation.nextTree()); 1369 } 1370 stream_annotation.reset(); 1371 1372 adaptor.addChild(root_1, root_2); 1373 } 1374 1375 adaptor.addChild(root_0, root_1); 1376 } 1377 1378 } 1379 1380 1381 retval.tree = root_0; 1382 1383 } 1384 break; 1385 case 2 : 1386 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:484:21: 1387 { 1388 smali_file_stack.peek().classAnnotations.addAll(annotations); 1389 // AST REWRITE 1390 // elements: nonvoid_type_descriptor, member_name, literal, access_list 1391 // token labels: 1392 // rule labels: retval 1393 // token list labels: 1394 // rule list labels: 1395 // wildcard labels: 1396 retval.tree = root_0; 1397 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 1398 1399 root_0 = (CommonTree)adaptor.nil(); 1400 // 485:9: -> ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ) ) 1401 { 1402 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:485:12: ^( I_FIELD[$start, \"I_FIELD\"] member_name access_list ^( I_FIELD_TYPE nonvoid_type_descriptor ) ( ^( I_FIELD_INITIAL_VALUE literal ) )? ^( I_ANNOTATIONS ) ) 1403 { 1404 CommonTree root_1 = (CommonTree)adaptor.nil(); 1405 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELD, (retval.start), "I_FIELD"), root_1); 1406 adaptor.addChild(root_1, stream_member_name.nextTree()); 1407 adaptor.addChild(root_1, stream_access_list.nextTree()); 1408 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:485:65: ^( I_FIELD_TYPE nonvoid_type_descriptor ) 1409 { 1410 CommonTree root_2 = (CommonTree)adaptor.nil(); 1411 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELD_TYPE, "I_FIELD_TYPE"), root_2); 1412 adaptor.addChild(root_2, stream_nonvoid_type_descriptor.nextTree()); 1413 adaptor.addChild(root_1, root_2); 1414 } 1415 1416 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:485:105: ( ^( I_FIELD_INITIAL_VALUE literal ) )? 1417 if ( stream_literal.hasNext() ) { 1418 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:485:105: ^( I_FIELD_INITIAL_VALUE literal ) 1419 { 1420 CommonTree root_2 = (CommonTree)adaptor.nil(); 1421 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_FIELD_INITIAL_VALUE, "I_FIELD_INITIAL_VALUE"), root_2); 1422 adaptor.addChild(root_2, stream_literal.nextTree()); 1423 adaptor.addChild(root_1, root_2); 1424 } 1425 1426 } 1427 stream_literal.reset(); 1428 1429 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:485:139: ^( I_ANNOTATIONS ) 1430 { 1431 CommonTree root_2 = (CommonTree)adaptor.nil(); 1432 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ANNOTATIONS, "I_ANNOTATIONS"), root_2); 1433 adaptor.addChild(root_1, root_2); 1434 } 1435 1436 adaptor.addChild(root_0, root_1); 1437 } 1438 1439 } 1440 1441 1442 retval.tree = root_0; 1443 1444 } 1445 break; 1446 1447 } 1448 1449 } 1450 1451 } 1452 1453 retval.stop = input.LT(-1); 1454 1455 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 1456 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 1457 1458 } 1459 catch (RecognitionException re) { 1460 reportError(re); 1461 recover(input,re); 1462 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 1463 } 1464 finally { 1465 // do for sure before leaving 1466 } 1467 return retval; 1468 } 1469 // $ANTLR end "field" 1470 1471 1472 public static class method_return extends ParserRuleReturnScope { 1473 CommonTree tree; 1474 @Override 1475 public CommonTree getTree() { return tree; } 1476 }; 1477 1478 1479 // $ANTLR start "method" 1480 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:489: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 ) ; 1481 public final smaliParser.method_return method() throws RecognitionException { 1482 smaliParser.method_return retval = new smaliParser.method_return(); 1483 retval.start = input.LT(1); 1484 1485 CommonTree root_0 = null; 1486 1487 Token METHOD_DIRECTIVE28=null; 1488 Token END_METHOD_DIRECTIVE33=null; 1489 ParserRuleReturnScope access_list29 =null; 1490 ParserRuleReturnScope member_name30 =null; 1491 ParserRuleReturnScope method_prototype31 =null; 1492 ParserRuleReturnScope statements_and_directives32 =null; 1493 1494 CommonTree METHOD_DIRECTIVE28_tree=null; 1495 CommonTree END_METHOD_DIRECTIVE33_tree=null; 1496 RewriteRuleTokenStream stream_END_METHOD_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_METHOD_DIRECTIVE"); 1497 RewriteRuleTokenStream stream_METHOD_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token METHOD_DIRECTIVE"); 1498 RewriteRuleSubtreeStream stream_access_list=new RewriteRuleSubtreeStream(adaptor,"rule access_list"); 1499 RewriteRuleSubtreeStream stream_method_prototype=new RewriteRuleSubtreeStream(adaptor,"rule method_prototype"); 1500 RewriteRuleSubtreeStream stream_statements_and_directives=new RewriteRuleSubtreeStream(adaptor,"rule statements_and_directives"); 1501 RewriteRuleSubtreeStream stream_member_name=new RewriteRuleSubtreeStream(adaptor,"rule member_name"); 1502 1503 try { 1504 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:490: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 ) ) 1505 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:490:5: METHOD_DIRECTIVE access_list member_name method_prototype statements_and_directives END_METHOD_DIRECTIVE 1506 { 1507 METHOD_DIRECTIVE28=(Token)match(input,METHOD_DIRECTIVE,FOLLOW_METHOD_DIRECTIVE_in_method1483); 1508 stream_METHOD_DIRECTIVE.add(METHOD_DIRECTIVE28); 1509 1510 pushFollow(FOLLOW_access_list_in_method1485); 1511 access_list29=access_list(); 1512 state._fsp--; 1513 1514 stream_access_list.add(access_list29.getTree()); 1515 pushFollow(FOLLOW_member_name_in_method1487); 1516 member_name30=member_name(); 1517 state._fsp--; 1518 1519 stream_member_name.add(member_name30.getTree()); 1520 pushFollow(FOLLOW_method_prototype_in_method1489); 1521 method_prototype31=method_prototype(); 1522 state._fsp--; 1523 1524 stream_method_prototype.add(method_prototype31.getTree()); 1525 pushFollow(FOLLOW_statements_and_directives_in_method1491); 1526 statements_and_directives32=statements_and_directives(); 1527 state._fsp--; 1528 1529 stream_statements_and_directives.add(statements_and_directives32.getTree()); 1530 END_METHOD_DIRECTIVE33=(Token)match(input,END_METHOD_DIRECTIVE,FOLLOW_END_METHOD_DIRECTIVE_in_method1497); 1531 stream_END_METHOD_DIRECTIVE.add(END_METHOD_DIRECTIVE33); 1532 1533 // AST REWRITE 1534 // elements: member_name, statements_and_directives, access_list, method_prototype 1535 // token labels: 1536 // rule labels: retval 1537 // token list labels: 1538 // rule list labels: 1539 // wildcard labels: 1540 retval.tree = root_0; 1541 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 1542 1543 root_0 = (CommonTree)adaptor.nil(); 1544 // 492:5: -> ^( I_METHOD[$start, \"I_METHOD\"] member_name method_prototype access_list statements_and_directives ) 1545 { 1546 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:492:8: ^( I_METHOD[$start, \"I_METHOD\"] member_name method_prototype access_list statements_and_directives ) 1547 { 1548 CommonTree root_1 = (CommonTree)adaptor.nil(); 1549 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_METHOD, (retval.start), "I_METHOD"), root_1); 1550 adaptor.addChild(root_1, stream_member_name.nextTree()); 1551 adaptor.addChild(root_1, stream_method_prototype.nextTree()); 1552 adaptor.addChild(root_1, stream_access_list.nextTree()); 1553 adaptor.addChild(root_1, stream_statements_and_directives.nextTree()); 1554 adaptor.addChild(root_0, root_1); 1555 } 1556 1557 } 1558 1559 1560 retval.tree = root_0; 1561 1562 } 1563 1564 retval.stop = input.LT(-1); 1565 1566 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 1567 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 1568 1569 } 1570 catch (RecognitionException re) { 1571 reportError(re); 1572 recover(input,re); 1573 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 1574 } 1575 finally { 1576 // do for sure before leaving 1577 } 1578 return retval; 1579 } 1580 // $ANTLR end "method" 1581 1582 1583 protected static class statements_and_directives_scope { 1584 boolean hasRegistersDirective; 1585 List<CommonTree> methodAnnotations; 1586 } 1587 protected Stack<statements_and_directives_scope> statements_and_directives_stack = new Stack<statements_and_directives_scope>(); 1588 1589 public static class statements_and_directives_return extends ParserRuleReturnScope { 1590 CommonTree tree; 1591 @Override 1592 public CommonTree getTree() { return tree; } 1593 }; 1594 1595 1596 // $ANTLR start "statements_and_directives" 1597 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:494: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 )* ) ; 1598 public final smaliParser.statements_and_directives_return statements_and_directives() throws RecognitionException { 1599 statements_and_directives_stack.push(new statements_and_directives_scope()); 1600 smaliParser.statements_and_directives_return retval = new smaliParser.statements_and_directives_return(); 1601 retval.start = input.LT(1); 1602 1603 CommonTree root_0 = null; 1604 1605 ParserRuleReturnScope ordered_method_item34 =null; 1606 ParserRuleReturnScope registers_directive35 =null; 1607 ParserRuleReturnScope catch_directive36 =null; 1608 ParserRuleReturnScope catchall_directive37 =null; 1609 ParserRuleReturnScope parameter_directive38 =null; 1610 ParserRuleReturnScope annotation39 =null; 1611 1612 RewriteRuleSubtreeStream stream_catchall_directive=new RewriteRuleSubtreeStream(adaptor,"rule catchall_directive"); 1613 RewriteRuleSubtreeStream stream_annotation=new RewriteRuleSubtreeStream(adaptor,"rule annotation"); 1614 RewriteRuleSubtreeStream stream_ordered_method_item=new RewriteRuleSubtreeStream(adaptor,"rule ordered_method_item"); 1615 RewriteRuleSubtreeStream stream_catch_directive=new RewriteRuleSubtreeStream(adaptor,"rule catch_directive"); 1616 RewriteRuleSubtreeStream stream_registers_directive=new RewriteRuleSubtreeStream(adaptor,"rule registers_directive"); 1617 RewriteRuleSubtreeStream stream_parameter_directive=new RewriteRuleSubtreeStream(adaptor,"rule parameter_directive"); 1618 1619 try { 1620 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:500: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 )* ) ) 1621 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:500:5: ( ordered_method_item | registers_directive | catch_directive | catchall_directive | parameter_directive | annotation )* 1622 { 1623 1624 statements_and_directives_stack.peek().hasRegistersDirective = false; 1625 statements_and_directives_stack.peek().methodAnnotations = new ArrayList<CommonTree>(); 1626 1627 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:504:5: ( ordered_method_item | registers_directive | catch_directive | catchall_directive | parameter_directive | annotation )* 1628 loop6: 1629 while (true) { 1630 int alt6=7; 1631 switch ( input.LA(1) ) { 1632 case ARRAY_DATA_DIRECTIVE: 1633 case COLON: 1634 case END_LOCAL_DIRECTIVE: 1635 case EPILOGUE_DIRECTIVE: 1636 case INSTRUCTION_FORMAT10t: 1637 case INSTRUCTION_FORMAT10x: 1638 case INSTRUCTION_FORMAT10x_ODEX: 1639 case INSTRUCTION_FORMAT11n: 1640 case INSTRUCTION_FORMAT11x: 1641 case INSTRUCTION_FORMAT12x: 1642 case INSTRUCTION_FORMAT12x_OR_ID: 1643 case INSTRUCTION_FORMAT20bc: 1644 case INSTRUCTION_FORMAT20t: 1645 case INSTRUCTION_FORMAT21c_FIELD: 1646 case INSTRUCTION_FORMAT21c_FIELD_ODEX: 1647 case INSTRUCTION_FORMAT21c_STRING: 1648 case INSTRUCTION_FORMAT21c_TYPE: 1649 case INSTRUCTION_FORMAT21ih: 1650 case INSTRUCTION_FORMAT21lh: 1651 case INSTRUCTION_FORMAT21s: 1652 case INSTRUCTION_FORMAT21t: 1653 case INSTRUCTION_FORMAT22b: 1654 case INSTRUCTION_FORMAT22c_FIELD: 1655 case INSTRUCTION_FORMAT22c_FIELD_ODEX: 1656 case INSTRUCTION_FORMAT22c_TYPE: 1657 case INSTRUCTION_FORMAT22cs_FIELD: 1658 case INSTRUCTION_FORMAT22s: 1659 case INSTRUCTION_FORMAT22s_OR_ID: 1660 case INSTRUCTION_FORMAT22t: 1661 case INSTRUCTION_FORMAT22x: 1662 case INSTRUCTION_FORMAT23x: 1663 case INSTRUCTION_FORMAT30t: 1664 case INSTRUCTION_FORMAT31c: 1665 case INSTRUCTION_FORMAT31i: 1666 case INSTRUCTION_FORMAT31i_OR_ID: 1667 case INSTRUCTION_FORMAT31t: 1668 case INSTRUCTION_FORMAT32x: 1669 case INSTRUCTION_FORMAT35c_METHOD: 1670 case INSTRUCTION_FORMAT35c_METHOD_ODEX: 1671 case INSTRUCTION_FORMAT35c_TYPE: 1672 case INSTRUCTION_FORMAT35mi_METHOD: 1673 case INSTRUCTION_FORMAT35ms_METHOD: 1674 case INSTRUCTION_FORMAT3rc_METHOD: 1675 case INSTRUCTION_FORMAT3rc_METHOD_ODEX: 1676 case INSTRUCTION_FORMAT3rc_TYPE: 1677 case INSTRUCTION_FORMAT3rmi_METHOD: 1678 case INSTRUCTION_FORMAT3rms_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 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:504:7: ordered_method_item 1721 { 1722 pushFollow(FOLLOW_ordered_method_item_in_statements_and_directives1542); 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 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:505:7: registers_directive 1731 { 1732 pushFollow(FOLLOW_registers_directive_in_statements_and_directives1550); 1733 registers_directive35=registers_directive(); 1734 state._fsp--; 1735 1736 stream_registers_directive.add(registers_directive35.getTree()); 1737 } 1738 break; 1739 case 3 : 1740 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:506:7: catch_directive 1741 { 1742 pushFollow(FOLLOW_catch_directive_in_statements_and_directives1558); 1743 catch_directive36=catch_directive(); 1744 state._fsp--; 1745 1746 stream_catch_directive.add(catch_directive36.getTree()); 1747 } 1748 break; 1749 case 4 : 1750 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:507:7: catchall_directive 1751 { 1752 pushFollow(FOLLOW_catchall_directive_in_statements_and_directives1566); 1753 catchall_directive37=catchall_directive(); 1754 state._fsp--; 1755 1756 stream_catchall_directive.add(catchall_directive37.getTree()); 1757 } 1758 break; 1759 case 5 : 1760 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:508:7: parameter_directive 1761 { 1762 pushFollow(FOLLOW_parameter_directive_in_statements_and_directives1574); 1763 parameter_directive38=parameter_directive(); 1764 state._fsp--; 1765 1766 stream_parameter_directive.add(parameter_directive38.getTree()); 1767 } 1768 break; 1769 case 6 : 1770 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:509:7: annotation 1771 { 1772 pushFollow(FOLLOW_annotation_in_statements_and_directives1582); 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: catchall_directive, registers_directive, parameter_directive, catch_directive, ordered_method_item 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 // 511:5: -> ( registers_directive )? ^( I_ORDERED_METHOD_ITEMS ( ordered_method_item )* ) ^( I_CATCHES ( catch_directive )* ( catchall_directive )* ) ^( I_PARAMETERS ( parameter_directive )* ) 1798 { 1799 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:511: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 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:512: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 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:512: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 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:513: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 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:513: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 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:513: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 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:514: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 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:514: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 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:518: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 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:519: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_FORMAT51l: 1952 case PACKED_SWITCH_DIRECTIVE: 1953 case SPARSE_SWITCH_DIRECTIVE: 1954 { 1955 alt7=2; 1956 } 1957 break; 1958 case END_LOCAL_DIRECTIVE: 1959 case EPILOGUE_DIRECTIVE: 1960 case LINE_DIRECTIVE: 1961 case LOCAL_DIRECTIVE: 1962 case PROLOGUE_DIRECTIVE: 1963 case RESTART_LOCAL_DIRECTIVE: 1964 case SOURCE_DIRECTIVE: 1965 { 1966 alt7=3; 1967 } 1968 break; 1969 default: 1970 NoViableAltException nvae = 1971 new NoViableAltException("", 7, 0, input); 1972 throw nvae; 1973 } 1974 switch (alt7) { 1975 case 1 : 1976 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:519:5: label 1977 { 1978 root_0 = (CommonTree)adaptor.nil(); 1979 1980 1981 pushFollow(FOLLOW_label_in_ordered_method_item1667); 1982 label40=label(); 1983 state._fsp--; 1984 1985 adaptor.addChild(root_0, label40.getTree()); 1986 1987 } 1988 break; 1989 case 2 : 1990 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:520:5: instruction 1991 { 1992 root_0 = (CommonTree)adaptor.nil(); 1993 1994 1995 pushFollow(FOLLOW_instruction_in_ordered_method_item1673); 1996 instruction41=instruction(); 1997 state._fsp--; 1998 1999 adaptor.addChild(root_0, instruction41.getTree()); 2000 2001 } 2002 break; 2003 case 3 : 2004 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:521:5: debug_directive 2005 { 2006 root_0 = (CommonTree)adaptor.nil(); 2007 2008 2009 pushFollow(FOLLOW_debug_directive_in_ordered_method_item1679); 2010 debug_directive42=debug_directive(); 2011 state._fsp--; 2012 2013 adaptor.addChild(root_0, debug_directive42.getTree()); 2014 2015 } 2016 break; 2017 2018 } 2019 retval.stop = input.LT(-1); 2020 2021 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 2022 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 2023 2024 } 2025 catch (RecognitionException re) { 2026 reportError(re); 2027 recover(input,re); 2028 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 2029 } 2030 finally { 2031 // do for sure before leaving 2032 } 2033 return retval; 2034 } 2035 // $ANTLR end "ordered_method_item" 2036 2037 2038 public static class registers_directive_return extends ParserRuleReturnScope { 2039 CommonTree tree; 2040 @Override 2041 public CommonTree getTree() { return tree; } 2042 }; 2043 2044 2045 // $ANTLR start "registers_directive" 2046 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:523: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) ) ; 2047 public final smaliParser.registers_directive_return registers_directive() throws RecognitionException { 2048 smaliParser.registers_directive_return retval = new smaliParser.registers_directive_return(); 2049 retval.start = input.LT(1); 2050 2051 CommonTree root_0 = null; 2052 2053 Token directive=null; 2054 ParserRuleReturnScope regCount =null; 2055 ParserRuleReturnScope regCount2 =null; 2056 2057 CommonTree directive_tree=null; 2058 RewriteRuleTokenStream stream_REGISTERS_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token REGISTERS_DIRECTIVE"); 2059 RewriteRuleTokenStream stream_LOCALS_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token LOCALS_DIRECTIVE"); 2060 RewriteRuleSubtreeStream stream_integral_literal=new RewriteRuleSubtreeStream(adaptor,"rule integral_literal"); 2061 2062 try { 2063 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:524: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) ) ) 2064 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:524: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) ) 2065 { 2066 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:524: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 int alt8=2; 2068 int LA8_0 = input.LA(1); 2069 if ( (LA8_0==REGISTERS_DIRECTIVE) ) { 2070 alt8=1; 2071 } 2072 else if ( (LA8_0==LOCALS_DIRECTIVE) ) { 2073 alt8=2; 2074 } 2075 2076 else { 2077 NoViableAltException nvae = 2078 new NoViableAltException("", 8, 0, input); 2079 throw nvae; 2080 } 2081 2082 switch (alt8) { 2083 case 1 : 2084 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:525:7: directive= REGISTERS_DIRECTIVE regCount= integral_literal 2085 { 2086 directive=(Token)match(input,REGISTERS_DIRECTIVE,FOLLOW_REGISTERS_DIRECTIVE_in_registers_directive1699); 2087 stream_REGISTERS_DIRECTIVE.add(directive); 2088 2089 pushFollow(FOLLOW_integral_literal_in_registers_directive1703); 2090 regCount=integral_literal(); 2091 state._fsp--; 2092 2093 stream_integral_literal.add(regCount.getTree()); 2094 // AST REWRITE 2095 // elements: regCount 2096 // token labels: 2097 // rule labels: retval, regCount 2098 // token list labels: 2099 // rule list labels: 2100 // wildcard labels: 2101 retval.tree = root_0; 2102 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2103 RewriteRuleSubtreeStream stream_regCount=new RewriteRuleSubtreeStream(adaptor,"rule regCount",regCount!=null?regCount.getTree():null); 2104 2105 root_0 = (CommonTree)adaptor.nil(); 2106 // 525:63: -> ^( I_REGISTERS[$REGISTERS_DIRECTIVE, \"I_REGISTERS\"] $regCount) 2107 { 2108 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:525:66: ^( I_REGISTERS[$REGISTERS_DIRECTIVE, \"I_REGISTERS\"] $regCount) 2109 { 2110 CommonTree root_1 = (CommonTree)adaptor.nil(); 2111 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_REGISTERS, directive, "I_REGISTERS"), root_1); 2112 adaptor.addChild(root_1, stream_regCount.nextTree()); 2113 adaptor.addChild(root_0, root_1); 2114 } 2115 2116 } 2117 2118 2119 retval.tree = root_0; 2120 2121 } 2122 break; 2123 case 2 : 2124 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:526:7: directive= LOCALS_DIRECTIVE regCount2= integral_literal 2125 { 2126 directive=(Token)match(input,LOCALS_DIRECTIVE,FOLLOW_LOCALS_DIRECTIVE_in_registers_directive1723); 2127 stream_LOCALS_DIRECTIVE.add(directive); 2128 2129 pushFollow(FOLLOW_integral_literal_in_registers_directive1727); 2130 regCount2=integral_literal(); 2131 state._fsp--; 2132 2133 stream_integral_literal.add(regCount2.getTree()); 2134 // AST REWRITE 2135 // elements: regCount2 2136 // token labels: 2137 // rule labels: retval, regCount2 2138 // token list labels: 2139 // rule list labels: 2140 // wildcard labels: 2141 retval.tree = root_0; 2142 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2143 RewriteRuleSubtreeStream stream_regCount2=new RewriteRuleSubtreeStream(adaptor,"rule regCount2",regCount2!=null?regCount2.getTree():null); 2144 2145 root_0 = (CommonTree)adaptor.nil(); 2146 // 526:61: -> ^( I_LOCALS[$LOCALS_DIRECTIVE, \"I_LOCALS\"] $regCount2) 2147 { 2148 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:526:64: ^( I_LOCALS[$LOCALS_DIRECTIVE, \"I_LOCALS\"] $regCount2) 2149 { 2150 CommonTree root_1 = (CommonTree)adaptor.nil(); 2151 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_LOCALS, directive, "I_LOCALS"), root_1); 2152 adaptor.addChild(root_1, stream_regCount2.nextTree()); 2153 adaptor.addChild(root_0, root_1); 2154 } 2155 2156 } 2157 2158 2159 retval.tree = root_0; 2160 2161 } 2162 break; 2163 2164 } 2165 2166 2167 if (statements_and_directives_stack.peek().hasRegistersDirective) { 2168 throw new SemanticException(input, directive, "There can only be a single .registers or .locals directive in a method"); 2169 } 2170 statements_and_directives_stack.peek().hasRegistersDirective =true; 2171 2172 } 2173 2174 retval.stop = input.LT(-1); 2175 2176 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 2177 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 2178 2179 } 2180 catch (RecognitionException re) { 2181 reportError(re); 2182 recover(input,re); 2183 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 2184 } 2185 finally { 2186 // do for sure before leaving 2187 } 2188 return retval; 2189 } 2190 // $ANTLR end "registers_directive" 2191 2192 2193 public static class param_list_or_id_return extends ParserRuleReturnScope { 2194 CommonTree tree; 2195 @Override 2196 public CommonTree getTree() { return tree; } 2197 }; 2198 2199 2200 // $ANTLR start "param_list_or_id" 2201 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:535:1: param_list_or_id : PARAM_LIST_OR_ID_START ( PRIMITIVE_TYPE )+ PARAM_LIST_OR_ID_END ; 2202 public final smaliParser.param_list_or_id_return param_list_or_id() throws RecognitionException { 2203 smaliParser.param_list_or_id_return retval = new smaliParser.param_list_or_id_return(); 2204 retval.start = input.LT(1); 2205 2206 CommonTree root_0 = null; 2207 2208 Token PARAM_LIST_OR_ID_START43=null; 2209 Token PRIMITIVE_TYPE44=null; 2210 Token PARAM_LIST_OR_ID_END45=null; 2211 2212 CommonTree PARAM_LIST_OR_ID_START43_tree=null; 2213 CommonTree PRIMITIVE_TYPE44_tree=null; 2214 CommonTree PARAM_LIST_OR_ID_END45_tree=null; 2215 2216 try { 2217 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:536:3: ( PARAM_LIST_OR_ID_START ( PRIMITIVE_TYPE )+ PARAM_LIST_OR_ID_END ) 2218 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:536:5: PARAM_LIST_OR_ID_START ( PRIMITIVE_TYPE )+ PARAM_LIST_OR_ID_END 2219 { 2220 root_0 = (CommonTree)adaptor.nil(); 2221 2222 2223 PARAM_LIST_OR_ID_START43=(Token)match(input,PARAM_LIST_OR_ID_START,FOLLOW_PARAM_LIST_OR_ID_START_in_param_list_or_id1759); 2224 PARAM_LIST_OR_ID_START43_tree = (CommonTree)adaptor.create(PARAM_LIST_OR_ID_START43); 2225 adaptor.addChild(root_0, PARAM_LIST_OR_ID_START43_tree); 2226 2227 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:536:28: ( PRIMITIVE_TYPE )+ 2228 int cnt9=0; 2229 loop9: 2230 while (true) { 2231 int alt9=2; 2232 int LA9_0 = input.LA(1); 2233 if ( (LA9_0==PRIMITIVE_TYPE) ) { 2234 alt9=1; 2235 } 2236 2237 switch (alt9) { 2238 case 1 : 2239 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:536:28: PRIMITIVE_TYPE 2240 { 2241 PRIMITIVE_TYPE44=(Token)match(input,PRIMITIVE_TYPE,FOLLOW_PRIMITIVE_TYPE_in_param_list_or_id1761); 2242 PRIMITIVE_TYPE44_tree = (CommonTree)adaptor.create(PRIMITIVE_TYPE44); 2243 adaptor.addChild(root_0, PRIMITIVE_TYPE44_tree); 2244 2245 } 2246 break; 2247 2248 default : 2249 if ( cnt9 >= 1 ) break loop9; 2250 EarlyExitException eee = new EarlyExitException(9, input); 2251 throw eee; 2252 } 2253 cnt9++; 2254 } 2255 2256 PARAM_LIST_OR_ID_END45=(Token)match(input,PARAM_LIST_OR_ID_END,FOLLOW_PARAM_LIST_OR_ID_END_in_param_list_or_id1764); 2257 PARAM_LIST_OR_ID_END45_tree = (CommonTree)adaptor.create(PARAM_LIST_OR_ID_END45); 2258 adaptor.addChild(root_0, PARAM_LIST_OR_ID_END45_tree); 2259 2260 } 2261 2262 retval.stop = input.LT(-1); 2263 2264 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 2265 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 2266 2267 } 2268 catch (RecognitionException re) { 2269 reportError(re); 2270 recover(input,re); 2271 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 2272 } 2273 finally { 2274 // do for sure before leaving 2275 } 2276 return retval; 2277 } 2278 // $ANTLR end "param_list_or_id" 2279 2280 2281 public static class simple_name_return extends ParserRuleReturnScope { 2282 CommonTree tree; 2283 @Override 2284 public CommonTree getTree() { return tree; } 2285 }; 2286 2287 2288 // $ANTLR start "simple_name" 2289 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:540: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_FORMAT51l -> SIMPLE_NAME[$INSTRUCTION_FORMAT51l] ); 2290 public final smaliParser.simple_name_return simple_name() throws RecognitionException { 2291 smaliParser.simple_name_return retval = new smaliParser.simple_name_return(); 2292 retval.start = input.LT(1); 2293 2294 CommonTree root_0 = null; 2295 2296 Token SIMPLE_NAME46=null; 2297 Token ACCESS_SPEC47=null; 2298 Token VERIFICATION_ERROR_TYPE48=null; 2299 Token POSITIVE_INTEGER_LITERAL49=null; 2300 Token NEGATIVE_INTEGER_LITERAL50=null; 2301 Token FLOAT_LITERAL_OR_ID51=null; 2302 Token DOUBLE_LITERAL_OR_ID52=null; 2303 Token BOOL_LITERAL53=null; 2304 Token NULL_LITERAL54=null; 2305 Token REGISTER55=null; 2306 Token PRIMITIVE_TYPE57=null; 2307 Token VOID_TYPE58=null; 2308 Token ANNOTATION_VISIBILITY59=null; 2309 Token INSTRUCTION_FORMAT10t60=null; 2310 Token INSTRUCTION_FORMAT10x61=null; 2311 Token INSTRUCTION_FORMAT10x_ODEX62=null; 2312 Token INSTRUCTION_FORMAT11x63=null; 2313 Token INSTRUCTION_FORMAT12x_OR_ID64=null; 2314 Token INSTRUCTION_FORMAT21c_FIELD65=null; 2315 Token INSTRUCTION_FORMAT21c_FIELD_ODEX66=null; 2316 Token INSTRUCTION_FORMAT21c_STRING67=null; 2317 Token INSTRUCTION_FORMAT21c_TYPE68=null; 2318 Token INSTRUCTION_FORMAT21t69=null; 2319 Token INSTRUCTION_FORMAT22c_FIELD70=null; 2320 Token INSTRUCTION_FORMAT22c_FIELD_ODEX71=null; 2321 Token INSTRUCTION_FORMAT22c_TYPE72=null; 2322 Token INSTRUCTION_FORMAT22cs_FIELD73=null; 2323 Token INSTRUCTION_FORMAT22s_OR_ID74=null; 2324 Token INSTRUCTION_FORMAT22t75=null; 2325 Token INSTRUCTION_FORMAT23x76=null; 2326 Token INSTRUCTION_FORMAT31i_OR_ID77=null; 2327 Token INSTRUCTION_FORMAT31t78=null; 2328 Token INSTRUCTION_FORMAT35c_METHOD79=null; 2329 Token INSTRUCTION_FORMAT35c_METHOD_ODEX80=null; 2330 Token INSTRUCTION_FORMAT35c_TYPE81=null; 2331 Token INSTRUCTION_FORMAT35mi_METHOD82=null; 2332 Token INSTRUCTION_FORMAT35ms_METHOD83=null; 2333 Token INSTRUCTION_FORMAT51l84=null; 2334 ParserRuleReturnScope param_list_or_id56 =null; 2335 2336 CommonTree SIMPLE_NAME46_tree=null; 2337 CommonTree ACCESS_SPEC47_tree=null; 2338 CommonTree VERIFICATION_ERROR_TYPE48_tree=null; 2339 CommonTree POSITIVE_INTEGER_LITERAL49_tree=null; 2340 CommonTree NEGATIVE_INTEGER_LITERAL50_tree=null; 2341 CommonTree FLOAT_LITERAL_OR_ID51_tree=null; 2342 CommonTree DOUBLE_LITERAL_OR_ID52_tree=null; 2343 CommonTree BOOL_LITERAL53_tree=null; 2344 CommonTree NULL_LITERAL54_tree=null; 2345 CommonTree REGISTER55_tree=null; 2346 CommonTree PRIMITIVE_TYPE57_tree=null; 2347 CommonTree VOID_TYPE58_tree=null; 2348 CommonTree ANNOTATION_VISIBILITY59_tree=null; 2349 CommonTree INSTRUCTION_FORMAT10t60_tree=null; 2350 CommonTree INSTRUCTION_FORMAT10x61_tree=null; 2351 CommonTree INSTRUCTION_FORMAT10x_ODEX62_tree=null; 2352 CommonTree INSTRUCTION_FORMAT11x63_tree=null; 2353 CommonTree INSTRUCTION_FORMAT12x_OR_ID64_tree=null; 2354 CommonTree INSTRUCTION_FORMAT21c_FIELD65_tree=null; 2355 CommonTree INSTRUCTION_FORMAT21c_FIELD_ODEX66_tree=null; 2356 CommonTree INSTRUCTION_FORMAT21c_STRING67_tree=null; 2357 CommonTree INSTRUCTION_FORMAT21c_TYPE68_tree=null; 2358 CommonTree INSTRUCTION_FORMAT21t69_tree=null; 2359 CommonTree INSTRUCTION_FORMAT22c_FIELD70_tree=null; 2360 CommonTree INSTRUCTION_FORMAT22c_FIELD_ODEX71_tree=null; 2361 CommonTree INSTRUCTION_FORMAT22c_TYPE72_tree=null; 2362 CommonTree INSTRUCTION_FORMAT22cs_FIELD73_tree=null; 2363 CommonTree INSTRUCTION_FORMAT22s_OR_ID74_tree=null; 2364 CommonTree INSTRUCTION_FORMAT22t75_tree=null; 2365 CommonTree INSTRUCTION_FORMAT23x76_tree=null; 2366 CommonTree INSTRUCTION_FORMAT31i_OR_ID77_tree=null; 2367 CommonTree INSTRUCTION_FORMAT31t78_tree=null; 2368 CommonTree INSTRUCTION_FORMAT35c_METHOD79_tree=null; 2369 CommonTree INSTRUCTION_FORMAT35c_METHOD_ODEX80_tree=null; 2370 CommonTree INSTRUCTION_FORMAT35c_TYPE81_tree=null; 2371 CommonTree INSTRUCTION_FORMAT35mi_METHOD82_tree=null; 2372 CommonTree INSTRUCTION_FORMAT35ms_METHOD83_tree=null; 2373 CommonTree INSTRUCTION_FORMAT51l84_tree=null; 2374 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_TYPE"); 2375 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35c_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35c_METHOD"); 2376 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT11x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT11x"); 2377 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21t"); 2378 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35c_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35c_TYPE"); 2379 RewriteRuleTokenStream stream_ANNOTATION_VISIBILITY=new RewriteRuleTokenStream(adaptor,"token ANNOTATION_VISIBILITY"); 2380 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT31i_OR_ID=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT31i_OR_ID"); 2381 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22s_OR_ID=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22s_OR_ID"); 2382 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT51l=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT51l"); 2383 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT23x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT23x"); 2384 RewriteRuleTokenStream stream_NULL_LITERAL=new RewriteRuleTokenStream(adaptor,"token NULL_LITERAL"); 2385 RewriteRuleTokenStream stream_BOOL_LITERAL=new RewriteRuleTokenStream(adaptor,"token BOOL_LITERAL"); 2386 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_FIELD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_FIELD"); 2387 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35c_METHOD_ODEX=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35c_METHOD_ODEX"); 2388 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_FIELD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_FIELD"); 2389 RewriteRuleTokenStream stream_ACCESS_SPEC=new RewriteRuleTokenStream(adaptor,"token ACCESS_SPEC"); 2390 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_STRING=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_STRING"); 2391 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT12x_OR_ID=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT12x_OR_ID"); 2392 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35ms_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35ms_METHOD"); 2393 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35mi_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35mi_METHOD"); 2394 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22cs_FIELD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22cs_FIELD"); 2395 RewriteRuleTokenStream stream_VOID_TYPE=new RewriteRuleTokenStream(adaptor,"token VOID_TYPE"); 2396 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT10x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT10x"); 2397 RewriteRuleTokenStream stream_FLOAT_LITERAL_OR_ID=new RewriteRuleTokenStream(adaptor,"token FLOAT_LITERAL_OR_ID"); 2398 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22t"); 2399 RewriteRuleTokenStream stream_PRIMITIVE_TYPE=new RewriteRuleTokenStream(adaptor,"token PRIMITIVE_TYPE"); 2400 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT10x_ODEX=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT10x_ODEX"); 2401 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT31t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT31t"); 2402 RewriteRuleTokenStream stream_DOUBLE_LITERAL_OR_ID=new RewriteRuleTokenStream(adaptor,"token DOUBLE_LITERAL_OR_ID"); 2403 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_FIELD_ODEX=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_FIELD_ODEX"); 2404 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT10t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT10t"); 2405 RewriteRuleTokenStream stream_NEGATIVE_INTEGER_LITERAL=new RewriteRuleTokenStream(adaptor,"token NEGATIVE_INTEGER_LITERAL"); 2406 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 2407 RewriteRuleTokenStream stream_VERIFICATION_ERROR_TYPE=new RewriteRuleTokenStream(adaptor,"token VERIFICATION_ERROR_TYPE"); 2408 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_TYPE"); 2409 RewriteRuleTokenStream stream_POSITIVE_INTEGER_LITERAL=new RewriteRuleTokenStream(adaptor,"token POSITIVE_INTEGER_LITERAL"); 2410 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_FIELD_ODEX=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_FIELD_ODEX"); 2411 RewriteRuleSubtreeStream stream_param_list_or_id=new RewriteRuleSubtreeStream(adaptor,"rule param_list_or_id"); 2412 2413 try { 2414 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:541: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_FORMAT51l -> SIMPLE_NAME[$INSTRUCTION_FORMAT51l] ) 2415 int alt10=39; 2416 switch ( input.LA(1) ) { 2417 case SIMPLE_NAME: 2418 { 2419 alt10=1; 2420 } 2421 break; 2422 case ACCESS_SPEC: 2423 { 2424 alt10=2; 2425 } 2426 break; 2427 case VERIFICATION_ERROR_TYPE: 2428 { 2429 alt10=3; 2430 } 2431 break; 2432 case POSITIVE_INTEGER_LITERAL: 2433 { 2434 alt10=4; 2435 } 2436 break; 2437 case NEGATIVE_INTEGER_LITERAL: 2438 { 2439 alt10=5; 2440 } 2441 break; 2442 case FLOAT_LITERAL_OR_ID: 2443 { 2444 alt10=6; 2445 } 2446 break; 2447 case DOUBLE_LITERAL_OR_ID: 2448 { 2449 alt10=7; 2450 } 2451 break; 2452 case BOOL_LITERAL: 2453 { 2454 alt10=8; 2455 } 2456 break; 2457 case NULL_LITERAL: 2458 { 2459 alt10=9; 2460 } 2461 break; 2462 case REGISTER: 2463 { 2464 alt10=10; 2465 } 2466 break; 2467 case PARAM_LIST_OR_ID_START: 2468 { 2469 alt10=11; 2470 } 2471 break; 2472 case PRIMITIVE_TYPE: 2473 { 2474 alt10=12; 2475 } 2476 break; 2477 case VOID_TYPE: 2478 { 2479 alt10=13; 2480 } 2481 break; 2482 case ANNOTATION_VISIBILITY: 2483 { 2484 alt10=14; 2485 } 2486 break; 2487 case INSTRUCTION_FORMAT10t: 2488 { 2489 alt10=15; 2490 } 2491 break; 2492 case INSTRUCTION_FORMAT10x: 2493 { 2494 alt10=16; 2495 } 2496 break; 2497 case INSTRUCTION_FORMAT10x_ODEX: 2498 { 2499 alt10=17; 2500 } 2501 break; 2502 case INSTRUCTION_FORMAT11x: 2503 { 2504 alt10=18; 2505 } 2506 break; 2507 case INSTRUCTION_FORMAT12x_OR_ID: 2508 { 2509 alt10=19; 2510 } 2511 break; 2512 case INSTRUCTION_FORMAT21c_FIELD: 2513 { 2514 alt10=20; 2515 } 2516 break; 2517 case INSTRUCTION_FORMAT21c_FIELD_ODEX: 2518 { 2519 alt10=21; 2520 } 2521 break; 2522 case INSTRUCTION_FORMAT21c_STRING: 2523 { 2524 alt10=22; 2525 } 2526 break; 2527 case INSTRUCTION_FORMAT21c_TYPE: 2528 { 2529 alt10=23; 2530 } 2531 break; 2532 case INSTRUCTION_FORMAT21t: 2533 { 2534 alt10=24; 2535 } 2536 break; 2537 case INSTRUCTION_FORMAT22c_FIELD: 2538 { 2539 alt10=25; 2540 } 2541 break; 2542 case INSTRUCTION_FORMAT22c_FIELD_ODEX: 2543 { 2544 alt10=26; 2545 } 2546 break; 2547 case INSTRUCTION_FORMAT22c_TYPE: 2548 { 2549 alt10=27; 2550 } 2551 break; 2552 case INSTRUCTION_FORMAT22cs_FIELD: 2553 { 2554 alt10=28; 2555 } 2556 break; 2557 case INSTRUCTION_FORMAT22s_OR_ID: 2558 { 2559 alt10=29; 2560 } 2561 break; 2562 case INSTRUCTION_FORMAT22t: 2563 { 2564 alt10=30; 2565 } 2566 break; 2567 case INSTRUCTION_FORMAT23x: 2568 { 2569 alt10=31; 2570 } 2571 break; 2572 case INSTRUCTION_FORMAT31i_OR_ID: 2573 { 2574 alt10=32; 2575 } 2576 break; 2577 case INSTRUCTION_FORMAT31t: 2578 { 2579 alt10=33; 2580 } 2581 break; 2582 case INSTRUCTION_FORMAT35c_METHOD: 2583 { 2584 alt10=34; 2585 } 2586 break; 2587 case INSTRUCTION_FORMAT35c_METHOD_ODEX: 2588 { 2589 alt10=35; 2590 } 2591 break; 2592 case INSTRUCTION_FORMAT35c_TYPE: 2593 { 2594 alt10=36; 2595 } 2596 break; 2597 case INSTRUCTION_FORMAT35mi_METHOD: 2598 { 2599 alt10=37; 2600 } 2601 break; 2602 case INSTRUCTION_FORMAT35ms_METHOD: 2603 { 2604 alt10=38; 2605 } 2606 break; 2607 case INSTRUCTION_FORMAT51l: 2608 { 2609 alt10=39; 2610 } 2611 break; 2612 default: 2613 NoViableAltException nvae = 2614 new NoViableAltException("", 10, 0, input); 2615 throw nvae; 2616 } 2617 switch (alt10) { 2618 case 1 : 2619 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:541:5: SIMPLE_NAME 2620 { 2621 root_0 = (CommonTree)adaptor.nil(); 2622 2623 2624 SIMPLE_NAME46=(Token)match(input,SIMPLE_NAME,FOLLOW_SIMPLE_NAME_in_simple_name1776); 2625 SIMPLE_NAME46_tree = (CommonTree)adaptor.create(SIMPLE_NAME46); 2626 adaptor.addChild(root_0, SIMPLE_NAME46_tree); 2627 2628 } 2629 break; 2630 case 2 : 2631 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:542:5: ACCESS_SPEC 2632 { 2633 ACCESS_SPEC47=(Token)match(input,ACCESS_SPEC,FOLLOW_ACCESS_SPEC_in_simple_name1782); 2634 stream_ACCESS_SPEC.add(ACCESS_SPEC47); 2635 2636 // AST REWRITE 2637 // elements: 2638 // token labels: 2639 // rule labels: retval 2640 // token list labels: 2641 // rule list labels: 2642 // wildcard labels: 2643 retval.tree = root_0; 2644 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2645 2646 root_0 = (CommonTree)adaptor.nil(); 2647 // 542:17: -> SIMPLE_NAME[$ACCESS_SPEC] 2648 { 2649 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, ACCESS_SPEC47)); 2650 } 2651 2652 2653 retval.tree = root_0; 2654 2655 } 2656 break; 2657 case 3 : 2658 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:543:5: VERIFICATION_ERROR_TYPE 2659 { 2660 VERIFICATION_ERROR_TYPE48=(Token)match(input,VERIFICATION_ERROR_TYPE,FOLLOW_VERIFICATION_ERROR_TYPE_in_simple_name1793); 2661 stream_VERIFICATION_ERROR_TYPE.add(VERIFICATION_ERROR_TYPE48); 2662 2663 // AST REWRITE 2664 // elements: 2665 // token labels: 2666 // rule labels: retval 2667 // token list labels: 2668 // rule list labels: 2669 // wildcard labels: 2670 retval.tree = root_0; 2671 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2672 2673 root_0 = (CommonTree)adaptor.nil(); 2674 // 543:29: -> SIMPLE_NAME[$VERIFICATION_ERROR_TYPE] 2675 { 2676 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, VERIFICATION_ERROR_TYPE48)); 2677 } 2678 2679 2680 retval.tree = root_0; 2681 2682 } 2683 break; 2684 case 4 : 2685 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:544:5: POSITIVE_INTEGER_LITERAL 2686 { 2687 POSITIVE_INTEGER_LITERAL49=(Token)match(input,POSITIVE_INTEGER_LITERAL,FOLLOW_POSITIVE_INTEGER_LITERAL_in_simple_name1804); 2688 stream_POSITIVE_INTEGER_LITERAL.add(POSITIVE_INTEGER_LITERAL49); 2689 2690 // AST REWRITE 2691 // elements: 2692 // token labels: 2693 // rule labels: retval 2694 // token list labels: 2695 // rule list labels: 2696 // wildcard labels: 2697 retval.tree = root_0; 2698 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2699 2700 root_0 = (CommonTree)adaptor.nil(); 2701 // 544:30: -> SIMPLE_NAME[$POSITIVE_INTEGER_LITERAL] 2702 { 2703 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, POSITIVE_INTEGER_LITERAL49)); 2704 } 2705 2706 2707 retval.tree = root_0; 2708 2709 } 2710 break; 2711 case 5 : 2712 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:545:5: NEGATIVE_INTEGER_LITERAL 2713 { 2714 NEGATIVE_INTEGER_LITERAL50=(Token)match(input,NEGATIVE_INTEGER_LITERAL,FOLLOW_NEGATIVE_INTEGER_LITERAL_in_simple_name1815); 2715 stream_NEGATIVE_INTEGER_LITERAL.add(NEGATIVE_INTEGER_LITERAL50); 2716 2717 // AST REWRITE 2718 // elements: 2719 // token labels: 2720 // rule labels: retval 2721 // token list labels: 2722 // rule list labels: 2723 // wildcard labels: 2724 retval.tree = root_0; 2725 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2726 2727 root_0 = (CommonTree)adaptor.nil(); 2728 // 545:30: -> SIMPLE_NAME[$NEGATIVE_INTEGER_LITERAL] 2729 { 2730 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, NEGATIVE_INTEGER_LITERAL50)); 2731 } 2732 2733 2734 retval.tree = root_0; 2735 2736 } 2737 break; 2738 case 6 : 2739 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:546:5: FLOAT_LITERAL_OR_ID 2740 { 2741 FLOAT_LITERAL_OR_ID51=(Token)match(input,FLOAT_LITERAL_OR_ID,FOLLOW_FLOAT_LITERAL_OR_ID_in_simple_name1826); 2742 stream_FLOAT_LITERAL_OR_ID.add(FLOAT_LITERAL_OR_ID51); 2743 2744 // AST REWRITE 2745 // elements: 2746 // token labels: 2747 // rule labels: retval 2748 // token list labels: 2749 // rule list labels: 2750 // wildcard labels: 2751 retval.tree = root_0; 2752 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2753 2754 root_0 = (CommonTree)adaptor.nil(); 2755 // 546:25: -> SIMPLE_NAME[$FLOAT_LITERAL_OR_ID] 2756 { 2757 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, FLOAT_LITERAL_OR_ID51)); 2758 } 2759 2760 2761 retval.tree = root_0; 2762 2763 } 2764 break; 2765 case 7 : 2766 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:547:5: DOUBLE_LITERAL_OR_ID 2767 { 2768 DOUBLE_LITERAL_OR_ID52=(Token)match(input,DOUBLE_LITERAL_OR_ID,FOLLOW_DOUBLE_LITERAL_OR_ID_in_simple_name1837); 2769 stream_DOUBLE_LITERAL_OR_ID.add(DOUBLE_LITERAL_OR_ID52); 2770 2771 // AST REWRITE 2772 // elements: 2773 // token labels: 2774 // rule labels: retval 2775 // token list labels: 2776 // rule list labels: 2777 // wildcard labels: 2778 retval.tree = root_0; 2779 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2780 2781 root_0 = (CommonTree)adaptor.nil(); 2782 // 547:26: -> SIMPLE_NAME[$DOUBLE_LITERAL_OR_ID] 2783 { 2784 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, DOUBLE_LITERAL_OR_ID52)); 2785 } 2786 2787 2788 retval.tree = root_0; 2789 2790 } 2791 break; 2792 case 8 : 2793 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:548:5: BOOL_LITERAL 2794 { 2795 BOOL_LITERAL53=(Token)match(input,BOOL_LITERAL,FOLLOW_BOOL_LITERAL_in_simple_name1848); 2796 stream_BOOL_LITERAL.add(BOOL_LITERAL53); 2797 2798 // AST REWRITE 2799 // elements: 2800 // token labels: 2801 // rule labels: retval 2802 // token list labels: 2803 // rule list labels: 2804 // wildcard labels: 2805 retval.tree = root_0; 2806 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2807 2808 root_0 = (CommonTree)adaptor.nil(); 2809 // 548:18: -> SIMPLE_NAME[$BOOL_LITERAL] 2810 { 2811 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, BOOL_LITERAL53)); 2812 } 2813 2814 2815 retval.tree = root_0; 2816 2817 } 2818 break; 2819 case 9 : 2820 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:549:5: NULL_LITERAL 2821 { 2822 NULL_LITERAL54=(Token)match(input,NULL_LITERAL,FOLLOW_NULL_LITERAL_in_simple_name1859); 2823 stream_NULL_LITERAL.add(NULL_LITERAL54); 2824 2825 // AST REWRITE 2826 // elements: 2827 // token labels: 2828 // rule labels: retval 2829 // token list labels: 2830 // rule list labels: 2831 // wildcard labels: 2832 retval.tree = root_0; 2833 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2834 2835 root_0 = (CommonTree)adaptor.nil(); 2836 // 549:18: -> SIMPLE_NAME[$NULL_LITERAL] 2837 { 2838 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, NULL_LITERAL54)); 2839 } 2840 2841 2842 retval.tree = root_0; 2843 2844 } 2845 break; 2846 case 10 : 2847 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:550:5: REGISTER 2848 { 2849 REGISTER55=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_simple_name1870); 2850 stream_REGISTER.add(REGISTER55); 2851 2852 // AST REWRITE 2853 // elements: 2854 // token labels: 2855 // rule labels: retval 2856 // token list labels: 2857 // rule list labels: 2858 // wildcard labels: 2859 retval.tree = root_0; 2860 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2861 2862 root_0 = (CommonTree)adaptor.nil(); 2863 // 550:14: -> SIMPLE_NAME[$REGISTER] 2864 { 2865 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, REGISTER55)); 2866 } 2867 2868 2869 retval.tree = root_0; 2870 2871 } 2872 break; 2873 case 11 : 2874 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:551:5: param_list_or_id 2875 { 2876 pushFollow(FOLLOW_param_list_or_id_in_simple_name1881); 2877 param_list_or_id56=param_list_or_id(); 2878 state._fsp--; 2879 2880 stream_param_list_or_id.add(param_list_or_id56.getTree()); 2881 // AST REWRITE 2882 // elements: 2883 // token labels: 2884 // rule labels: retval 2885 // token list labels: 2886 // rule list labels: 2887 // wildcard labels: 2888 retval.tree = root_0; 2889 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2890 2891 root_0 = (CommonTree)adaptor.nil(); 2892 // 551:22: -> 2893 { 2894 adaptor.addChild(root_0, adaptor.create(SIMPLE_NAME, (param_list_or_id56!=null?input.toString(param_list_or_id56.start,param_list_or_id56.stop):null)) ); 2895 } 2896 2897 2898 retval.tree = root_0; 2899 2900 } 2901 break; 2902 case 12 : 2903 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:552:5: PRIMITIVE_TYPE 2904 { 2905 PRIMITIVE_TYPE57=(Token)match(input,PRIMITIVE_TYPE,FOLLOW_PRIMITIVE_TYPE_in_simple_name1891); 2906 stream_PRIMITIVE_TYPE.add(PRIMITIVE_TYPE57); 2907 2908 // AST REWRITE 2909 // elements: 2910 // token labels: 2911 // rule labels: retval 2912 // token list labels: 2913 // rule list labels: 2914 // wildcard labels: 2915 retval.tree = root_0; 2916 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2917 2918 root_0 = (CommonTree)adaptor.nil(); 2919 // 552:20: -> SIMPLE_NAME[$PRIMITIVE_TYPE] 2920 { 2921 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, PRIMITIVE_TYPE57)); 2922 } 2923 2924 2925 retval.tree = root_0; 2926 2927 } 2928 break; 2929 case 13 : 2930 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:553:5: VOID_TYPE 2931 { 2932 VOID_TYPE58=(Token)match(input,VOID_TYPE,FOLLOW_VOID_TYPE_in_simple_name1902); 2933 stream_VOID_TYPE.add(VOID_TYPE58); 2934 2935 // AST REWRITE 2936 // elements: 2937 // token labels: 2938 // rule labels: retval 2939 // token list labels: 2940 // rule list labels: 2941 // wildcard labels: 2942 retval.tree = root_0; 2943 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2944 2945 root_0 = (CommonTree)adaptor.nil(); 2946 // 553:15: -> SIMPLE_NAME[$VOID_TYPE] 2947 { 2948 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, VOID_TYPE58)); 2949 } 2950 2951 2952 retval.tree = root_0; 2953 2954 } 2955 break; 2956 case 14 : 2957 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:554:5: ANNOTATION_VISIBILITY 2958 { 2959 ANNOTATION_VISIBILITY59=(Token)match(input,ANNOTATION_VISIBILITY,FOLLOW_ANNOTATION_VISIBILITY_in_simple_name1913); 2960 stream_ANNOTATION_VISIBILITY.add(ANNOTATION_VISIBILITY59); 2961 2962 // AST REWRITE 2963 // elements: 2964 // token labels: 2965 // rule labels: retval 2966 // token list labels: 2967 // rule list labels: 2968 // wildcard labels: 2969 retval.tree = root_0; 2970 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2971 2972 root_0 = (CommonTree)adaptor.nil(); 2973 // 554:27: -> SIMPLE_NAME[$ANNOTATION_VISIBILITY] 2974 { 2975 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, ANNOTATION_VISIBILITY59)); 2976 } 2977 2978 2979 retval.tree = root_0; 2980 2981 } 2982 break; 2983 case 15 : 2984 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:555:5: INSTRUCTION_FORMAT10t 2985 { 2986 INSTRUCTION_FORMAT10t60=(Token)match(input,INSTRUCTION_FORMAT10t,FOLLOW_INSTRUCTION_FORMAT10t_in_simple_name1924); 2987 stream_INSTRUCTION_FORMAT10t.add(INSTRUCTION_FORMAT10t60); 2988 2989 // AST REWRITE 2990 // elements: 2991 // token labels: 2992 // rule labels: retval 2993 // token list labels: 2994 // rule list labels: 2995 // wildcard labels: 2996 retval.tree = root_0; 2997 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 2998 2999 root_0 = (CommonTree)adaptor.nil(); 3000 // 555:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT10t] 3001 { 3002 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT10t60)); 3003 } 3004 3005 3006 retval.tree = root_0; 3007 3008 } 3009 break; 3010 case 16 : 3011 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:556:5: INSTRUCTION_FORMAT10x 3012 { 3013 INSTRUCTION_FORMAT10x61=(Token)match(input,INSTRUCTION_FORMAT10x,FOLLOW_INSTRUCTION_FORMAT10x_in_simple_name1935); 3014 stream_INSTRUCTION_FORMAT10x.add(INSTRUCTION_FORMAT10x61); 3015 3016 // AST REWRITE 3017 // elements: 3018 // token labels: 3019 // rule labels: retval 3020 // token list labels: 3021 // rule list labels: 3022 // wildcard labels: 3023 retval.tree = root_0; 3024 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3025 3026 root_0 = (CommonTree)adaptor.nil(); 3027 // 556:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT10x] 3028 { 3029 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT10x61)); 3030 } 3031 3032 3033 retval.tree = root_0; 3034 3035 } 3036 break; 3037 case 17 : 3038 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:557:5: INSTRUCTION_FORMAT10x_ODEX 3039 { 3040 INSTRUCTION_FORMAT10x_ODEX62=(Token)match(input,INSTRUCTION_FORMAT10x_ODEX,FOLLOW_INSTRUCTION_FORMAT10x_ODEX_in_simple_name1946); 3041 stream_INSTRUCTION_FORMAT10x_ODEX.add(INSTRUCTION_FORMAT10x_ODEX62); 3042 3043 // AST REWRITE 3044 // elements: 3045 // token labels: 3046 // rule labels: retval 3047 // token list labels: 3048 // rule list labels: 3049 // wildcard labels: 3050 retval.tree = root_0; 3051 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3052 3053 root_0 = (CommonTree)adaptor.nil(); 3054 // 557:32: -> SIMPLE_NAME[$INSTRUCTION_FORMAT10x_ODEX] 3055 { 3056 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT10x_ODEX62)); 3057 } 3058 3059 3060 retval.tree = root_0; 3061 3062 } 3063 break; 3064 case 18 : 3065 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:558:5: INSTRUCTION_FORMAT11x 3066 { 3067 INSTRUCTION_FORMAT11x63=(Token)match(input,INSTRUCTION_FORMAT11x,FOLLOW_INSTRUCTION_FORMAT11x_in_simple_name1957); 3068 stream_INSTRUCTION_FORMAT11x.add(INSTRUCTION_FORMAT11x63); 3069 3070 // AST REWRITE 3071 // elements: 3072 // token labels: 3073 // rule labels: retval 3074 // token list labels: 3075 // rule list labels: 3076 // wildcard labels: 3077 retval.tree = root_0; 3078 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3079 3080 root_0 = (CommonTree)adaptor.nil(); 3081 // 558:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT11x] 3082 { 3083 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT11x63)); 3084 } 3085 3086 3087 retval.tree = root_0; 3088 3089 } 3090 break; 3091 case 19 : 3092 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:559:5: INSTRUCTION_FORMAT12x_OR_ID 3093 { 3094 INSTRUCTION_FORMAT12x_OR_ID64=(Token)match(input,INSTRUCTION_FORMAT12x_OR_ID,FOLLOW_INSTRUCTION_FORMAT12x_OR_ID_in_simple_name1968); 3095 stream_INSTRUCTION_FORMAT12x_OR_ID.add(INSTRUCTION_FORMAT12x_OR_ID64); 3096 3097 // AST REWRITE 3098 // elements: 3099 // token labels: 3100 // rule labels: retval 3101 // token list labels: 3102 // rule list labels: 3103 // wildcard labels: 3104 retval.tree = root_0; 3105 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3106 3107 root_0 = (CommonTree)adaptor.nil(); 3108 // 559:33: -> SIMPLE_NAME[$INSTRUCTION_FORMAT12x_OR_ID] 3109 { 3110 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT12x_OR_ID64)); 3111 } 3112 3113 3114 retval.tree = root_0; 3115 3116 } 3117 break; 3118 case 20 : 3119 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:560:5: INSTRUCTION_FORMAT21c_FIELD 3120 { 3121 INSTRUCTION_FORMAT21c_FIELD65=(Token)match(input,INSTRUCTION_FORMAT21c_FIELD,FOLLOW_INSTRUCTION_FORMAT21c_FIELD_in_simple_name1979); 3122 stream_INSTRUCTION_FORMAT21c_FIELD.add(INSTRUCTION_FORMAT21c_FIELD65); 3123 3124 // AST REWRITE 3125 // elements: 3126 // token labels: 3127 // rule labels: retval 3128 // token list labels: 3129 // rule list labels: 3130 // wildcard labels: 3131 retval.tree = root_0; 3132 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3133 3134 root_0 = (CommonTree)adaptor.nil(); 3135 // 560:33: -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_FIELD] 3136 { 3137 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT21c_FIELD65)); 3138 } 3139 3140 3141 retval.tree = root_0; 3142 3143 } 3144 break; 3145 case 21 : 3146 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:561:5: INSTRUCTION_FORMAT21c_FIELD_ODEX 3147 { 3148 INSTRUCTION_FORMAT21c_FIELD_ODEX66=(Token)match(input,INSTRUCTION_FORMAT21c_FIELD_ODEX,FOLLOW_INSTRUCTION_FORMAT21c_FIELD_ODEX_in_simple_name1990); 3149 stream_INSTRUCTION_FORMAT21c_FIELD_ODEX.add(INSTRUCTION_FORMAT21c_FIELD_ODEX66); 3150 3151 // AST REWRITE 3152 // elements: 3153 // token labels: 3154 // rule labels: retval 3155 // token list labels: 3156 // rule list labels: 3157 // wildcard labels: 3158 retval.tree = root_0; 3159 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3160 3161 root_0 = (CommonTree)adaptor.nil(); 3162 // 561:38: -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_FIELD_ODEX] 3163 { 3164 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT21c_FIELD_ODEX66)); 3165 } 3166 3167 3168 retval.tree = root_0; 3169 3170 } 3171 break; 3172 case 22 : 3173 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:562:5: INSTRUCTION_FORMAT21c_STRING 3174 { 3175 INSTRUCTION_FORMAT21c_STRING67=(Token)match(input,INSTRUCTION_FORMAT21c_STRING,FOLLOW_INSTRUCTION_FORMAT21c_STRING_in_simple_name2001); 3176 stream_INSTRUCTION_FORMAT21c_STRING.add(INSTRUCTION_FORMAT21c_STRING67); 3177 3178 // AST REWRITE 3179 // elements: 3180 // token labels: 3181 // rule labels: retval 3182 // token list labels: 3183 // rule list labels: 3184 // wildcard labels: 3185 retval.tree = root_0; 3186 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3187 3188 root_0 = (CommonTree)adaptor.nil(); 3189 // 562:34: -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_STRING] 3190 { 3191 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT21c_STRING67)); 3192 } 3193 3194 3195 retval.tree = root_0; 3196 3197 } 3198 break; 3199 case 23 : 3200 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:563:5: INSTRUCTION_FORMAT21c_TYPE 3201 { 3202 INSTRUCTION_FORMAT21c_TYPE68=(Token)match(input,INSTRUCTION_FORMAT21c_TYPE,FOLLOW_INSTRUCTION_FORMAT21c_TYPE_in_simple_name2012); 3203 stream_INSTRUCTION_FORMAT21c_TYPE.add(INSTRUCTION_FORMAT21c_TYPE68); 3204 3205 // AST REWRITE 3206 // elements: 3207 // token labels: 3208 // rule labels: retval 3209 // token list labels: 3210 // rule list labels: 3211 // wildcard labels: 3212 retval.tree = root_0; 3213 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3214 3215 root_0 = (CommonTree)adaptor.nil(); 3216 // 563:32: -> SIMPLE_NAME[$INSTRUCTION_FORMAT21c_TYPE] 3217 { 3218 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT21c_TYPE68)); 3219 } 3220 3221 3222 retval.tree = root_0; 3223 3224 } 3225 break; 3226 case 24 : 3227 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:564:5: INSTRUCTION_FORMAT21t 3228 { 3229 INSTRUCTION_FORMAT21t69=(Token)match(input,INSTRUCTION_FORMAT21t,FOLLOW_INSTRUCTION_FORMAT21t_in_simple_name2023); 3230 stream_INSTRUCTION_FORMAT21t.add(INSTRUCTION_FORMAT21t69); 3231 3232 // AST REWRITE 3233 // elements: 3234 // token labels: 3235 // rule labels: retval 3236 // token list labels: 3237 // rule list labels: 3238 // wildcard labels: 3239 retval.tree = root_0; 3240 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3241 3242 root_0 = (CommonTree)adaptor.nil(); 3243 // 564:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT21t] 3244 { 3245 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT21t69)); 3246 } 3247 3248 3249 retval.tree = root_0; 3250 3251 } 3252 break; 3253 case 25 : 3254 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:565:5: INSTRUCTION_FORMAT22c_FIELD 3255 { 3256 INSTRUCTION_FORMAT22c_FIELD70=(Token)match(input,INSTRUCTION_FORMAT22c_FIELD,FOLLOW_INSTRUCTION_FORMAT22c_FIELD_in_simple_name2034); 3257 stream_INSTRUCTION_FORMAT22c_FIELD.add(INSTRUCTION_FORMAT22c_FIELD70); 3258 3259 // AST REWRITE 3260 // elements: 3261 // token labels: 3262 // rule labels: retval 3263 // token list labels: 3264 // rule list labels: 3265 // wildcard labels: 3266 retval.tree = root_0; 3267 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3268 3269 root_0 = (CommonTree)adaptor.nil(); 3270 // 565:33: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_FIELD] 3271 { 3272 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22c_FIELD70)); 3273 } 3274 3275 3276 retval.tree = root_0; 3277 3278 } 3279 break; 3280 case 26 : 3281 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:566:5: INSTRUCTION_FORMAT22c_FIELD_ODEX 3282 { 3283 INSTRUCTION_FORMAT22c_FIELD_ODEX71=(Token)match(input,INSTRUCTION_FORMAT22c_FIELD_ODEX,FOLLOW_INSTRUCTION_FORMAT22c_FIELD_ODEX_in_simple_name2045); 3284 stream_INSTRUCTION_FORMAT22c_FIELD_ODEX.add(INSTRUCTION_FORMAT22c_FIELD_ODEX71); 3285 3286 // AST REWRITE 3287 // elements: 3288 // token labels: 3289 // rule labels: retval 3290 // token list labels: 3291 // rule list labels: 3292 // wildcard labels: 3293 retval.tree = root_0; 3294 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3295 3296 root_0 = (CommonTree)adaptor.nil(); 3297 // 566:38: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_FIELD_ODEX] 3298 { 3299 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22c_FIELD_ODEX71)); 3300 } 3301 3302 3303 retval.tree = root_0; 3304 3305 } 3306 break; 3307 case 27 : 3308 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:567:5: INSTRUCTION_FORMAT22c_TYPE 3309 { 3310 INSTRUCTION_FORMAT22c_TYPE72=(Token)match(input,INSTRUCTION_FORMAT22c_TYPE,FOLLOW_INSTRUCTION_FORMAT22c_TYPE_in_simple_name2056); 3311 stream_INSTRUCTION_FORMAT22c_TYPE.add(INSTRUCTION_FORMAT22c_TYPE72); 3312 3313 // AST REWRITE 3314 // elements: 3315 // token labels: 3316 // rule labels: retval 3317 // token list labels: 3318 // rule list labels: 3319 // wildcard labels: 3320 retval.tree = root_0; 3321 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3322 3323 root_0 = (CommonTree)adaptor.nil(); 3324 // 567:32: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22c_TYPE] 3325 { 3326 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22c_TYPE72)); 3327 } 3328 3329 3330 retval.tree = root_0; 3331 3332 } 3333 break; 3334 case 28 : 3335 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:568:5: INSTRUCTION_FORMAT22cs_FIELD 3336 { 3337 INSTRUCTION_FORMAT22cs_FIELD73=(Token)match(input,INSTRUCTION_FORMAT22cs_FIELD,FOLLOW_INSTRUCTION_FORMAT22cs_FIELD_in_simple_name2067); 3338 stream_INSTRUCTION_FORMAT22cs_FIELD.add(INSTRUCTION_FORMAT22cs_FIELD73); 3339 3340 // AST REWRITE 3341 // elements: 3342 // token labels: 3343 // rule labels: retval 3344 // token list labels: 3345 // rule list labels: 3346 // wildcard labels: 3347 retval.tree = root_0; 3348 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3349 3350 root_0 = (CommonTree)adaptor.nil(); 3351 // 568:34: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22cs_FIELD] 3352 { 3353 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22cs_FIELD73)); 3354 } 3355 3356 3357 retval.tree = root_0; 3358 3359 } 3360 break; 3361 case 29 : 3362 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:569:5: INSTRUCTION_FORMAT22s_OR_ID 3363 { 3364 INSTRUCTION_FORMAT22s_OR_ID74=(Token)match(input,INSTRUCTION_FORMAT22s_OR_ID,FOLLOW_INSTRUCTION_FORMAT22s_OR_ID_in_simple_name2078); 3365 stream_INSTRUCTION_FORMAT22s_OR_ID.add(INSTRUCTION_FORMAT22s_OR_ID74); 3366 3367 // AST REWRITE 3368 // elements: 3369 // token labels: 3370 // rule labels: retval 3371 // token list labels: 3372 // rule list labels: 3373 // wildcard labels: 3374 retval.tree = root_0; 3375 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3376 3377 root_0 = (CommonTree)adaptor.nil(); 3378 // 569:33: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22s_OR_ID] 3379 { 3380 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22s_OR_ID74)); 3381 } 3382 3383 3384 retval.tree = root_0; 3385 3386 } 3387 break; 3388 case 30 : 3389 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:570:5: INSTRUCTION_FORMAT22t 3390 { 3391 INSTRUCTION_FORMAT22t75=(Token)match(input,INSTRUCTION_FORMAT22t,FOLLOW_INSTRUCTION_FORMAT22t_in_simple_name2089); 3392 stream_INSTRUCTION_FORMAT22t.add(INSTRUCTION_FORMAT22t75); 3393 3394 // AST REWRITE 3395 // elements: 3396 // token labels: 3397 // rule labels: retval 3398 // token list labels: 3399 // rule list labels: 3400 // wildcard labels: 3401 retval.tree = root_0; 3402 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3403 3404 root_0 = (CommonTree)adaptor.nil(); 3405 // 570:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT22t] 3406 { 3407 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT22t75)); 3408 } 3409 3410 3411 retval.tree = root_0; 3412 3413 } 3414 break; 3415 case 31 : 3416 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:571:5: INSTRUCTION_FORMAT23x 3417 { 3418 INSTRUCTION_FORMAT23x76=(Token)match(input,INSTRUCTION_FORMAT23x,FOLLOW_INSTRUCTION_FORMAT23x_in_simple_name2100); 3419 stream_INSTRUCTION_FORMAT23x.add(INSTRUCTION_FORMAT23x76); 3420 3421 // AST REWRITE 3422 // elements: 3423 // token labels: 3424 // rule labels: retval 3425 // token list labels: 3426 // rule list labels: 3427 // wildcard labels: 3428 retval.tree = root_0; 3429 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3430 3431 root_0 = (CommonTree)adaptor.nil(); 3432 // 571:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT23x] 3433 { 3434 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT23x76)); 3435 } 3436 3437 3438 retval.tree = root_0; 3439 3440 } 3441 break; 3442 case 32 : 3443 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:572:5: INSTRUCTION_FORMAT31i_OR_ID 3444 { 3445 INSTRUCTION_FORMAT31i_OR_ID77=(Token)match(input,INSTRUCTION_FORMAT31i_OR_ID,FOLLOW_INSTRUCTION_FORMAT31i_OR_ID_in_simple_name2111); 3446 stream_INSTRUCTION_FORMAT31i_OR_ID.add(INSTRUCTION_FORMAT31i_OR_ID77); 3447 3448 // AST REWRITE 3449 // elements: 3450 // token labels: 3451 // rule labels: retval 3452 // token list labels: 3453 // rule list labels: 3454 // wildcard labels: 3455 retval.tree = root_0; 3456 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3457 3458 root_0 = (CommonTree)adaptor.nil(); 3459 // 572:33: -> SIMPLE_NAME[$INSTRUCTION_FORMAT31i_OR_ID] 3460 { 3461 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT31i_OR_ID77)); 3462 } 3463 3464 3465 retval.tree = root_0; 3466 3467 } 3468 break; 3469 case 33 : 3470 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:573:5: INSTRUCTION_FORMAT31t 3471 { 3472 INSTRUCTION_FORMAT31t78=(Token)match(input,INSTRUCTION_FORMAT31t,FOLLOW_INSTRUCTION_FORMAT31t_in_simple_name2122); 3473 stream_INSTRUCTION_FORMAT31t.add(INSTRUCTION_FORMAT31t78); 3474 3475 // AST REWRITE 3476 // elements: 3477 // token labels: 3478 // rule labels: retval 3479 // token list labels: 3480 // rule list labels: 3481 // wildcard labels: 3482 retval.tree = root_0; 3483 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3484 3485 root_0 = (CommonTree)adaptor.nil(); 3486 // 573:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT31t] 3487 { 3488 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT31t78)); 3489 } 3490 3491 3492 retval.tree = root_0; 3493 3494 } 3495 break; 3496 case 34 : 3497 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:574:5: INSTRUCTION_FORMAT35c_METHOD 3498 { 3499 INSTRUCTION_FORMAT35c_METHOD79=(Token)match(input,INSTRUCTION_FORMAT35c_METHOD,FOLLOW_INSTRUCTION_FORMAT35c_METHOD_in_simple_name2133); 3500 stream_INSTRUCTION_FORMAT35c_METHOD.add(INSTRUCTION_FORMAT35c_METHOD79); 3501 3502 // AST REWRITE 3503 // elements: 3504 // token labels: 3505 // rule labels: retval 3506 // token list labels: 3507 // rule list labels: 3508 // wildcard labels: 3509 retval.tree = root_0; 3510 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3511 3512 root_0 = (CommonTree)adaptor.nil(); 3513 // 574:34: -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_METHOD] 3514 { 3515 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT35c_METHOD79)); 3516 } 3517 3518 3519 retval.tree = root_0; 3520 3521 } 3522 break; 3523 case 35 : 3524 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:575:5: INSTRUCTION_FORMAT35c_METHOD_ODEX 3525 { 3526 INSTRUCTION_FORMAT35c_METHOD_ODEX80=(Token)match(input,INSTRUCTION_FORMAT35c_METHOD_ODEX,FOLLOW_INSTRUCTION_FORMAT35c_METHOD_ODEX_in_simple_name2144); 3527 stream_INSTRUCTION_FORMAT35c_METHOD_ODEX.add(INSTRUCTION_FORMAT35c_METHOD_ODEX80); 3528 3529 // AST REWRITE 3530 // elements: 3531 // token labels: 3532 // rule labels: retval 3533 // token list labels: 3534 // rule list labels: 3535 // wildcard labels: 3536 retval.tree = root_0; 3537 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3538 3539 root_0 = (CommonTree)adaptor.nil(); 3540 // 575:39: -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_METHOD_ODEX] 3541 { 3542 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT35c_METHOD_ODEX80)); 3543 } 3544 3545 3546 retval.tree = root_0; 3547 3548 } 3549 break; 3550 case 36 : 3551 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:576:5: INSTRUCTION_FORMAT35c_TYPE 3552 { 3553 INSTRUCTION_FORMAT35c_TYPE81=(Token)match(input,INSTRUCTION_FORMAT35c_TYPE,FOLLOW_INSTRUCTION_FORMAT35c_TYPE_in_simple_name2155); 3554 stream_INSTRUCTION_FORMAT35c_TYPE.add(INSTRUCTION_FORMAT35c_TYPE81); 3555 3556 // AST REWRITE 3557 // elements: 3558 // token labels: 3559 // rule labels: retval 3560 // token list labels: 3561 // rule list labels: 3562 // wildcard labels: 3563 retval.tree = root_0; 3564 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3565 3566 root_0 = (CommonTree)adaptor.nil(); 3567 // 576:32: -> SIMPLE_NAME[$INSTRUCTION_FORMAT35c_TYPE] 3568 { 3569 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT35c_TYPE81)); 3570 } 3571 3572 3573 retval.tree = root_0; 3574 3575 } 3576 break; 3577 case 37 : 3578 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:577:5: INSTRUCTION_FORMAT35mi_METHOD 3579 { 3580 INSTRUCTION_FORMAT35mi_METHOD82=(Token)match(input,INSTRUCTION_FORMAT35mi_METHOD,FOLLOW_INSTRUCTION_FORMAT35mi_METHOD_in_simple_name2166); 3581 stream_INSTRUCTION_FORMAT35mi_METHOD.add(INSTRUCTION_FORMAT35mi_METHOD82); 3582 3583 // AST REWRITE 3584 // elements: 3585 // token labels: 3586 // rule labels: retval 3587 // token list labels: 3588 // rule list labels: 3589 // wildcard labels: 3590 retval.tree = root_0; 3591 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3592 3593 root_0 = (CommonTree)adaptor.nil(); 3594 // 577:35: -> SIMPLE_NAME[$INSTRUCTION_FORMAT35mi_METHOD] 3595 { 3596 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT35mi_METHOD82)); 3597 } 3598 3599 3600 retval.tree = root_0; 3601 3602 } 3603 break; 3604 case 38 : 3605 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:578:5: INSTRUCTION_FORMAT35ms_METHOD 3606 { 3607 INSTRUCTION_FORMAT35ms_METHOD83=(Token)match(input,INSTRUCTION_FORMAT35ms_METHOD,FOLLOW_INSTRUCTION_FORMAT35ms_METHOD_in_simple_name2177); 3608 stream_INSTRUCTION_FORMAT35ms_METHOD.add(INSTRUCTION_FORMAT35ms_METHOD83); 3609 3610 // AST REWRITE 3611 // elements: 3612 // token labels: 3613 // rule labels: retval 3614 // token list labels: 3615 // rule list labels: 3616 // wildcard labels: 3617 retval.tree = root_0; 3618 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3619 3620 root_0 = (CommonTree)adaptor.nil(); 3621 // 578:35: -> SIMPLE_NAME[$INSTRUCTION_FORMAT35ms_METHOD] 3622 { 3623 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT35ms_METHOD83)); 3624 } 3625 3626 3627 retval.tree = root_0; 3628 3629 } 3630 break; 3631 case 39 : 3632 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:579:5: INSTRUCTION_FORMAT51l 3633 { 3634 INSTRUCTION_FORMAT51l84=(Token)match(input,INSTRUCTION_FORMAT51l,FOLLOW_INSTRUCTION_FORMAT51l_in_simple_name2188); 3635 stream_INSTRUCTION_FORMAT51l.add(INSTRUCTION_FORMAT51l84); 3636 3637 // AST REWRITE 3638 // elements: 3639 // token labels: 3640 // rule labels: retval 3641 // token list labels: 3642 // rule list labels: 3643 // wildcard labels: 3644 retval.tree = root_0; 3645 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3646 3647 root_0 = (CommonTree)adaptor.nil(); 3648 // 579:27: -> SIMPLE_NAME[$INSTRUCTION_FORMAT51l] 3649 { 3650 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, INSTRUCTION_FORMAT51l84)); 3651 } 3652 3653 3654 retval.tree = root_0; 3655 3656 } 3657 break; 3658 3659 } 3660 retval.stop = input.LT(-1); 3661 3662 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 3663 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 3664 3665 } 3666 catch (RecognitionException re) { 3667 reportError(re); 3668 recover(input,re); 3669 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 3670 } 3671 finally { 3672 // do for sure before leaving 3673 } 3674 return retval; 3675 } 3676 // $ANTLR end "simple_name" 3677 3678 3679 public static class member_name_return extends ParserRuleReturnScope { 3680 CommonTree tree; 3681 @Override 3682 public CommonTree getTree() { return tree; } 3683 }; 3684 3685 3686 // $ANTLR start "member_name" 3687 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:581:1: member_name : ( simple_name | MEMBER_NAME -> SIMPLE_NAME[$MEMBER_NAME] ); 3688 public final smaliParser.member_name_return member_name() throws RecognitionException { 3689 smaliParser.member_name_return retval = new smaliParser.member_name_return(); 3690 retval.start = input.LT(1); 3691 3692 CommonTree root_0 = null; 3693 3694 Token MEMBER_NAME86=null; 3695 ParserRuleReturnScope simple_name85 =null; 3696 3697 CommonTree MEMBER_NAME86_tree=null; 3698 RewriteRuleTokenStream stream_MEMBER_NAME=new RewriteRuleTokenStream(adaptor,"token MEMBER_NAME"); 3699 3700 try { 3701 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:582:3: ( simple_name | MEMBER_NAME -> SIMPLE_NAME[$MEMBER_NAME] ) 3702 int alt11=2; 3703 int LA11_0 = input.LA(1); 3704 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_FORMAT51l||(LA11_0 >= NEGATIVE_INTEGER_LITERAL && LA11_0 <= NULL_LITERAL)||LA11_0==PARAM_LIST_OR_ID_START||(LA11_0 >= POSITIVE_INTEGER_LITERAL && LA11_0 <= PRIMITIVE_TYPE)||LA11_0==REGISTER||LA11_0==SIMPLE_NAME||(LA11_0 >= VERIFICATION_ERROR_TYPE && LA11_0 <= VOID_TYPE)) ) { 3705 alt11=1; 3706 } 3707 else if ( (LA11_0==MEMBER_NAME) ) { 3708 alt11=2; 3709 } 3710 3711 else { 3712 NoViableAltException nvae = 3713 new NoViableAltException("", 11, 0, input); 3714 throw nvae; 3715 } 3716 3717 switch (alt11) { 3718 case 1 : 3719 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:582:5: simple_name 3720 { 3721 root_0 = (CommonTree)adaptor.nil(); 3722 3723 3724 pushFollow(FOLLOW_simple_name_in_member_name2203); 3725 simple_name85=simple_name(); 3726 state._fsp--; 3727 3728 adaptor.addChild(root_0, simple_name85.getTree()); 3729 3730 } 3731 break; 3732 case 2 : 3733 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:583:5: MEMBER_NAME 3734 { 3735 MEMBER_NAME86=(Token)match(input,MEMBER_NAME,FOLLOW_MEMBER_NAME_in_member_name2209); 3736 stream_MEMBER_NAME.add(MEMBER_NAME86); 3737 3738 // AST REWRITE 3739 // elements: 3740 // token labels: 3741 // rule labels: retval 3742 // token list labels: 3743 // rule list labels: 3744 // wildcard labels: 3745 retval.tree = root_0; 3746 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3747 3748 root_0 = (CommonTree)adaptor.nil(); 3749 // 583:17: -> SIMPLE_NAME[$MEMBER_NAME] 3750 { 3751 adaptor.addChild(root_0, (CommonTree)adaptor.create(SIMPLE_NAME, MEMBER_NAME86)); 3752 } 3753 3754 3755 retval.tree = root_0; 3756 3757 } 3758 break; 3759 3760 } 3761 retval.stop = input.LT(-1); 3762 3763 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 3764 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 3765 3766 } 3767 catch (RecognitionException re) { 3768 reportError(re); 3769 recover(input,re); 3770 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 3771 } 3772 finally { 3773 // do for sure before leaving 3774 } 3775 return retval; 3776 } 3777 // $ANTLR end "member_name" 3778 3779 3780 public static class method_prototype_return extends ParserRuleReturnScope { 3781 CommonTree tree; 3782 @Override 3783 public CommonTree getTree() { return tree; } 3784 }; 3785 3786 3787 // $ANTLR start "method_prototype" 3788 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:585: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 )? ) ; 3789 public final smaliParser.method_prototype_return method_prototype() throws RecognitionException { 3790 smaliParser.method_prototype_return retval = new smaliParser.method_prototype_return(); 3791 retval.start = input.LT(1); 3792 3793 CommonTree root_0 = null; 3794 3795 Token OPEN_PAREN87=null; 3796 Token CLOSE_PAREN89=null; 3797 ParserRuleReturnScope param_list88 =null; 3798 ParserRuleReturnScope type_descriptor90 =null; 3799 3800 CommonTree OPEN_PAREN87_tree=null; 3801 CommonTree CLOSE_PAREN89_tree=null; 3802 RewriteRuleTokenStream stream_OPEN_PAREN=new RewriteRuleTokenStream(adaptor,"token OPEN_PAREN"); 3803 RewriteRuleTokenStream stream_CLOSE_PAREN=new RewriteRuleTokenStream(adaptor,"token CLOSE_PAREN"); 3804 RewriteRuleSubtreeStream stream_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule type_descriptor"); 3805 RewriteRuleSubtreeStream stream_param_list=new RewriteRuleSubtreeStream(adaptor,"rule param_list"); 3806 3807 try { 3808 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:586:3: ( OPEN_PAREN param_list CLOSE_PAREN type_descriptor -> ^( I_METHOD_PROTOTYPE[$start, \"I_METHOD_PROTOTYPE\"] ^( I_METHOD_RETURN_TYPE type_descriptor ) ( param_list )? ) ) 3809 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:586:5: OPEN_PAREN param_list CLOSE_PAREN type_descriptor 3810 { 3811 OPEN_PAREN87=(Token)match(input,OPEN_PAREN,FOLLOW_OPEN_PAREN_in_method_prototype2224); 3812 stream_OPEN_PAREN.add(OPEN_PAREN87); 3813 3814 pushFollow(FOLLOW_param_list_in_method_prototype2226); 3815 param_list88=param_list(); 3816 state._fsp--; 3817 3818 stream_param_list.add(param_list88.getTree()); 3819 CLOSE_PAREN89=(Token)match(input,CLOSE_PAREN,FOLLOW_CLOSE_PAREN_in_method_prototype2228); 3820 stream_CLOSE_PAREN.add(CLOSE_PAREN89); 3821 3822 pushFollow(FOLLOW_type_descriptor_in_method_prototype2230); 3823 type_descriptor90=type_descriptor(); 3824 state._fsp--; 3825 3826 stream_type_descriptor.add(type_descriptor90.getTree()); 3827 // AST REWRITE 3828 // elements: param_list, type_descriptor 3829 // token labels: 3830 // rule labels: retval 3831 // token list labels: 3832 // rule list labels: 3833 // wildcard labels: 3834 retval.tree = root_0; 3835 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3836 3837 root_0 = (CommonTree)adaptor.nil(); 3838 // 587:5: -> ^( I_METHOD_PROTOTYPE[$start, \"I_METHOD_PROTOTYPE\"] ^( I_METHOD_RETURN_TYPE type_descriptor ) ( param_list )? ) 3839 { 3840 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:587:8: ^( I_METHOD_PROTOTYPE[$start, \"I_METHOD_PROTOTYPE\"] ^( I_METHOD_RETURN_TYPE type_descriptor ) ( param_list )? ) 3841 { 3842 CommonTree root_1 = (CommonTree)adaptor.nil(); 3843 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_METHOD_PROTOTYPE, (retval.start), "I_METHOD_PROTOTYPE"), root_1); 3844 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:587:59: ^( I_METHOD_RETURN_TYPE type_descriptor ) 3845 { 3846 CommonTree root_2 = (CommonTree)adaptor.nil(); 3847 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_METHOD_RETURN_TYPE, "I_METHOD_RETURN_TYPE"), root_2); 3848 adaptor.addChild(root_2, stream_type_descriptor.nextTree()); 3849 adaptor.addChild(root_1, root_2); 3850 } 3851 3852 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:587:99: ( param_list )? 3853 if ( stream_param_list.hasNext() ) { 3854 adaptor.addChild(root_1, stream_param_list.nextTree()); 3855 } 3856 stream_param_list.reset(); 3857 3858 adaptor.addChild(root_0, root_1); 3859 } 3860 3861 } 3862 3863 3864 retval.tree = root_0; 3865 3866 } 3867 3868 retval.stop = input.LT(-1); 3869 3870 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 3871 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 3872 3873 } 3874 catch (RecognitionException re) { 3875 reportError(re); 3876 recover(input,re); 3877 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 3878 } 3879 finally { 3880 // do for sure before leaving 3881 } 3882 return retval; 3883 } 3884 // $ANTLR end "method_prototype" 3885 3886 3887 public static class param_list_return extends ParserRuleReturnScope { 3888 CommonTree tree; 3889 @Override 3890 public CommonTree getTree() { return tree; } 3891 }; 3892 3893 3894 // $ANTLR start "param_list" 3895 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:589:1: param_list : ( PARAM_LIST_START ( nonvoid_type_descriptor )* PARAM_LIST_END -> ( nonvoid_type_descriptor )* | PARAM_LIST_OR_ID_START ( PRIMITIVE_TYPE )* PARAM_LIST_OR_ID_END -> ( PRIMITIVE_TYPE )* | ( nonvoid_type_descriptor )* ); 3896 public final smaliParser.param_list_return param_list() throws RecognitionException { 3897 smaliParser.param_list_return retval = new smaliParser.param_list_return(); 3898 retval.start = input.LT(1); 3899 3900 CommonTree root_0 = null; 3901 3902 Token PARAM_LIST_START91=null; 3903 Token PARAM_LIST_END93=null; 3904 Token PARAM_LIST_OR_ID_START94=null; 3905 Token PRIMITIVE_TYPE95=null; 3906 Token PARAM_LIST_OR_ID_END96=null; 3907 ParserRuleReturnScope nonvoid_type_descriptor92 =null; 3908 ParserRuleReturnScope nonvoid_type_descriptor97 =null; 3909 3910 CommonTree PARAM_LIST_START91_tree=null; 3911 CommonTree PARAM_LIST_END93_tree=null; 3912 CommonTree PARAM_LIST_OR_ID_START94_tree=null; 3913 CommonTree PRIMITIVE_TYPE95_tree=null; 3914 CommonTree PARAM_LIST_OR_ID_END96_tree=null; 3915 RewriteRuleTokenStream stream_PARAM_LIST_OR_ID_START=new RewriteRuleTokenStream(adaptor,"token PARAM_LIST_OR_ID_START"); 3916 RewriteRuleTokenStream stream_PARAM_LIST_OR_ID_END=new RewriteRuleTokenStream(adaptor,"token PARAM_LIST_OR_ID_END"); 3917 RewriteRuleTokenStream stream_PARAM_LIST_START=new RewriteRuleTokenStream(adaptor,"token PARAM_LIST_START"); 3918 RewriteRuleTokenStream stream_PARAM_LIST_END=new RewriteRuleTokenStream(adaptor,"token PARAM_LIST_END"); 3919 RewriteRuleTokenStream stream_PRIMITIVE_TYPE=new RewriteRuleTokenStream(adaptor,"token PRIMITIVE_TYPE"); 3920 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 3921 3922 try { 3923 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:590:3: ( PARAM_LIST_START ( nonvoid_type_descriptor )* PARAM_LIST_END -> ( nonvoid_type_descriptor )* | PARAM_LIST_OR_ID_START ( PRIMITIVE_TYPE )* PARAM_LIST_OR_ID_END -> ( PRIMITIVE_TYPE )* | ( nonvoid_type_descriptor )* ) 3924 int alt15=3; 3925 switch ( input.LA(1) ) { 3926 case PARAM_LIST_START: 3927 { 3928 alt15=1; 3929 } 3930 break; 3931 case PARAM_LIST_OR_ID_START: 3932 { 3933 alt15=2; 3934 } 3935 break; 3936 case ARRAY_DESCRIPTOR: 3937 case CLASS_DESCRIPTOR: 3938 case CLOSE_PAREN: 3939 case PRIMITIVE_TYPE: 3940 { 3941 alt15=3; 3942 } 3943 break; 3944 default: 3945 NoViableAltException nvae = 3946 new NoViableAltException("", 15, 0, input); 3947 throw nvae; 3948 } 3949 switch (alt15) { 3950 case 1 : 3951 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:590:5: PARAM_LIST_START ( nonvoid_type_descriptor )* PARAM_LIST_END 3952 { 3953 PARAM_LIST_START91=(Token)match(input,PARAM_LIST_START,FOLLOW_PARAM_LIST_START_in_param_list2260); 3954 stream_PARAM_LIST_START.add(PARAM_LIST_START91); 3955 3956 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:590:22: ( nonvoid_type_descriptor )* 3957 loop12: 3958 while (true) { 3959 int alt12=2; 3960 int LA12_0 = input.LA(1); 3961 if ( (LA12_0==ARRAY_DESCRIPTOR||LA12_0==CLASS_DESCRIPTOR||LA12_0==PRIMITIVE_TYPE) ) { 3962 alt12=1; 3963 } 3964 3965 switch (alt12) { 3966 case 1 : 3967 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:590:22: nonvoid_type_descriptor 3968 { 3969 pushFollow(FOLLOW_nonvoid_type_descriptor_in_param_list2262); 3970 nonvoid_type_descriptor92=nonvoid_type_descriptor(); 3971 state._fsp--; 3972 3973 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor92.getTree()); 3974 } 3975 break; 3976 3977 default : 3978 break loop12; 3979 } 3980 } 3981 3982 PARAM_LIST_END93=(Token)match(input,PARAM_LIST_END,FOLLOW_PARAM_LIST_END_in_param_list2265); 3983 stream_PARAM_LIST_END.add(PARAM_LIST_END93); 3984 3985 // AST REWRITE 3986 // elements: nonvoid_type_descriptor 3987 // token labels: 3988 // rule labels: retval 3989 // token list labels: 3990 // rule list labels: 3991 // wildcard labels: 3992 retval.tree = root_0; 3993 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 3994 3995 root_0 = (CommonTree)adaptor.nil(); 3996 // 590:62: -> ( nonvoid_type_descriptor )* 3997 { 3998 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:590:65: ( nonvoid_type_descriptor )* 3999 while ( stream_nonvoid_type_descriptor.hasNext() ) { 4000 adaptor.addChild(root_0, stream_nonvoid_type_descriptor.nextTree()); 4001 } 4002 stream_nonvoid_type_descriptor.reset(); 4003 4004 } 4005 4006 4007 retval.tree = root_0; 4008 4009 } 4010 break; 4011 case 2 : 4012 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:591:5: PARAM_LIST_OR_ID_START ( PRIMITIVE_TYPE )* PARAM_LIST_OR_ID_END 4013 { 4014 PARAM_LIST_OR_ID_START94=(Token)match(input,PARAM_LIST_OR_ID_START,FOLLOW_PARAM_LIST_OR_ID_START_in_param_list2276); 4015 stream_PARAM_LIST_OR_ID_START.add(PARAM_LIST_OR_ID_START94); 4016 4017 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:591:28: ( PRIMITIVE_TYPE )* 4018 loop13: 4019 while (true) { 4020 int alt13=2; 4021 int LA13_0 = input.LA(1); 4022 if ( (LA13_0==PRIMITIVE_TYPE) ) { 4023 alt13=1; 4024 } 4025 4026 switch (alt13) { 4027 case 1 : 4028 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:591:28: PRIMITIVE_TYPE 4029 { 4030 PRIMITIVE_TYPE95=(Token)match(input,PRIMITIVE_TYPE,FOLLOW_PRIMITIVE_TYPE_in_param_list2278); 4031 stream_PRIMITIVE_TYPE.add(PRIMITIVE_TYPE95); 4032 4033 } 4034 break; 4035 4036 default : 4037 break loop13; 4038 } 4039 } 4040 4041 PARAM_LIST_OR_ID_END96=(Token)match(input,PARAM_LIST_OR_ID_END,FOLLOW_PARAM_LIST_OR_ID_END_in_param_list2281); 4042 stream_PARAM_LIST_OR_ID_END.add(PARAM_LIST_OR_ID_END96); 4043 4044 // AST REWRITE 4045 // elements: PRIMITIVE_TYPE 4046 // token labels: 4047 // rule labels: retval 4048 // token list labels: 4049 // rule list labels: 4050 // wildcard labels: 4051 retval.tree = root_0; 4052 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 4053 4054 root_0 = (CommonTree)adaptor.nil(); 4055 // 591:65: -> ( PRIMITIVE_TYPE )* 4056 { 4057 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:591:68: ( PRIMITIVE_TYPE )* 4058 while ( stream_PRIMITIVE_TYPE.hasNext() ) { 4059 adaptor.addChild(root_0, stream_PRIMITIVE_TYPE.nextNode()); 4060 } 4061 stream_PRIMITIVE_TYPE.reset(); 4062 4063 } 4064 4065 4066 retval.tree = root_0; 4067 4068 } 4069 break; 4070 case 3 : 4071 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:592:5: ( nonvoid_type_descriptor )* 4072 { 4073 root_0 = (CommonTree)adaptor.nil(); 4074 4075 4076 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:592:5: ( nonvoid_type_descriptor )* 4077 loop14: 4078 while (true) { 4079 int alt14=2; 4080 int LA14_0 = input.LA(1); 4081 if ( (LA14_0==ARRAY_DESCRIPTOR||LA14_0==CLASS_DESCRIPTOR||LA14_0==PRIMITIVE_TYPE) ) { 4082 alt14=1; 4083 } 4084 4085 switch (alt14) { 4086 case 1 : 4087 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:592:5: nonvoid_type_descriptor 4088 { 4089 pushFollow(FOLLOW_nonvoid_type_descriptor_in_param_list2292); 4090 nonvoid_type_descriptor97=nonvoid_type_descriptor(); 4091 state._fsp--; 4092 4093 adaptor.addChild(root_0, nonvoid_type_descriptor97.getTree()); 4094 4095 } 4096 break; 4097 4098 default : 4099 break loop14; 4100 } 4101 } 4102 4103 } 4104 break; 4105 4106 } 4107 retval.stop = input.LT(-1); 4108 4109 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 4110 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 4111 4112 } 4113 catch (RecognitionException re) { 4114 reportError(re); 4115 recover(input,re); 4116 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 4117 } 4118 finally { 4119 // do for sure before leaving 4120 } 4121 return retval; 4122 } 4123 // $ANTLR end "param_list" 4124 4125 4126 public static class type_descriptor_return extends ParserRuleReturnScope { 4127 CommonTree tree; 4128 @Override 4129 public CommonTree getTree() { return tree; } 4130 }; 4131 4132 4133 // $ANTLR start "type_descriptor" 4134 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:594:1: type_descriptor : ( VOID_TYPE | PRIMITIVE_TYPE | CLASS_DESCRIPTOR | ARRAY_DESCRIPTOR ); 4135 public final smaliParser.type_descriptor_return type_descriptor() throws RecognitionException { 4136 smaliParser.type_descriptor_return retval = new smaliParser.type_descriptor_return(); 4137 retval.start = input.LT(1); 4138 4139 CommonTree root_0 = null; 4140 4141 Token set98=null; 4142 4143 CommonTree set98_tree=null; 4144 4145 try { 4146 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:595:3: ( VOID_TYPE | PRIMITIVE_TYPE | CLASS_DESCRIPTOR | ARRAY_DESCRIPTOR ) 4147 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g: 4148 { 4149 root_0 = (CommonTree)adaptor.nil(); 4150 4151 4152 set98=input.LT(1); 4153 if ( input.LA(1)==ARRAY_DESCRIPTOR||input.LA(1)==CLASS_DESCRIPTOR||input.LA(1)==PRIMITIVE_TYPE||input.LA(1)==VOID_TYPE ) { 4154 input.consume(); 4155 adaptor.addChild(root_0, (CommonTree)adaptor.create(set98)); 4156 state.errorRecovery=false; 4157 } 4158 else { 4159 MismatchedSetException mse = new MismatchedSetException(null,input); 4160 throw mse; 4161 } 4162 } 4163 4164 retval.stop = input.LT(-1); 4165 4166 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 4167 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 4168 4169 } 4170 catch (RecognitionException re) { 4171 reportError(re); 4172 recover(input,re); 4173 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 4174 } 4175 finally { 4176 // do for sure before leaving 4177 } 4178 return retval; 4179 } 4180 // $ANTLR end "type_descriptor" 4181 4182 4183 public static class nonvoid_type_descriptor_return extends ParserRuleReturnScope { 4184 CommonTree tree; 4185 @Override 4186 public CommonTree getTree() { return tree; } 4187 }; 4188 4189 4190 // $ANTLR start "nonvoid_type_descriptor" 4191 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:600:1: nonvoid_type_descriptor : ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR | ARRAY_DESCRIPTOR ); 4192 public final smaliParser.nonvoid_type_descriptor_return nonvoid_type_descriptor() throws RecognitionException { 4193 smaliParser.nonvoid_type_descriptor_return retval = new smaliParser.nonvoid_type_descriptor_return(); 4194 retval.start = input.LT(1); 4195 4196 CommonTree root_0 = null; 4197 4198 Token set99=null; 4199 4200 CommonTree set99_tree=null; 4201 4202 try { 4203 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:601:3: ( PRIMITIVE_TYPE | CLASS_DESCRIPTOR | ARRAY_DESCRIPTOR ) 4204 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g: 4205 { 4206 root_0 = (CommonTree)adaptor.nil(); 4207 4208 4209 set99=input.LT(1); 4210 if ( input.LA(1)==ARRAY_DESCRIPTOR||input.LA(1)==CLASS_DESCRIPTOR||input.LA(1)==PRIMITIVE_TYPE ) { 4211 input.consume(); 4212 adaptor.addChild(root_0, (CommonTree)adaptor.create(set99)); 4213 state.errorRecovery=false; 4214 } 4215 else { 4216 MismatchedSetException mse = new MismatchedSetException(null,input); 4217 throw mse; 4218 } 4219 } 4220 4221 retval.stop = input.LT(-1); 4222 4223 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 4224 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 4225 4226 } 4227 catch (RecognitionException re) { 4228 reportError(re); 4229 recover(input,re); 4230 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 4231 } 4232 finally { 4233 // do for sure before leaving 4234 } 4235 return retval; 4236 } 4237 // $ANTLR end "nonvoid_type_descriptor" 4238 4239 4240 public static class reference_type_descriptor_return extends ParserRuleReturnScope { 4241 CommonTree tree; 4242 @Override 4243 public CommonTree getTree() { return tree; } 4244 }; 4245 4246 4247 // $ANTLR start "reference_type_descriptor" 4248 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:605:1: reference_type_descriptor : ( CLASS_DESCRIPTOR | ARRAY_DESCRIPTOR ); 4249 public final smaliParser.reference_type_descriptor_return reference_type_descriptor() throws RecognitionException { 4250 smaliParser.reference_type_descriptor_return retval = new smaliParser.reference_type_descriptor_return(); 4251 retval.start = input.LT(1); 4252 4253 CommonTree root_0 = null; 4254 4255 Token set100=null; 4256 4257 CommonTree set100_tree=null; 4258 4259 try { 4260 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:606:3: ( CLASS_DESCRIPTOR | ARRAY_DESCRIPTOR ) 4261 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g: 4262 { 4263 root_0 = (CommonTree)adaptor.nil(); 4264 4265 4266 set100=input.LT(1); 4267 if ( input.LA(1)==ARRAY_DESCRIPTOR||input.LA(1)==CLASS_DESCRIPTOR ) { 4268 input.consume(); 4269 adaptor.addChild(root_0, (CommonTree)adaptor.create(set100)); 4270 state.errorRecovery=false; 4271 } 4272 else { 4273 MismatchedSetException mse = new MismatchedSetException(null,input); 4274 throw mse; 4275 } 4276 } 4277 4278 retval.stop = input.LT(-1); 4279 4280 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 4281 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 4282 4283 } 4284 catch (RecognitionException re) { 4285 reportError(re); 4286 recover(input,re); 4287 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 4288 } 4289 finally { 4290 // do for sure before leaving 4291 } 4292 return retval; 4293 } 4294 // $ANTLR end "reference_type_descriptor" 4295 4296 4297 public static class integer_literal_return extends ParserRuleReturnScope { 4298 CommonTree tree; 4299 @Override 4300 public CommonTree getTree() { return tree; } 4301 }; 4302 4303 4304 // $ANTLR start "integer_literal" 4305 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:609:1: integer_literal : ( POSITIVE_INTEGER_LITERAL -> INTEGER_LITERAL[$POSITIVE_INTEGER_LITERAL] | NEGATIVE_INTEGER_LITERAL -> INTEGER_LITERAL[$NEGATIVE_INTEGER_LITERAL] ); 4306 public final smaliParser.integer_literal_return integer_literal() throws RecognitionException { 4307 smaliParser.integer_literal_return retval = new smaliParser.integer_literal_return(); 4308 retval.start = input.LT(1); 4309 4310 CommonTree root_0 = null; 4311 4312 Token POSITIVE_INTEGER_LITERAL101=null; 4313 Token NEGATIVE_INTEGER_LITERAL102=null; 4314 4315 CommonTree POSITIVE_INTEGER_LITERAL101_tree=null; 4316 CommonTree NEGATIVE_INTEGER_LITERAL102_tree=null; 4317 RewriteRuleTokenStream stream_NEGATIVE_INTEGER_LITERAL=new RewriteRuleTokenStream(adaptor,"token NEGATIVE_INTEGER_LITERAL"); 4318 RewriteRuleTokenStream stream_POSITIVE_INTEGER_LITERAL=new RewriteRuleTokenStream(adaptor,"token POSITIVE_INTEGER_LITERAL"); 4319 4320 try { 4321 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:610:3: ( POSITIVE_INTEGER_LITERAL -> INTEGER_LITERAL[$POSITIVE_INTEGER_LITERAL] | NEGATIVE_INTEGER_LITERAL -> INTEGER_LITERAL[$NEGATIVE_INTEGER_LITERAL] ) 4322 int alt16=2; 4323 int LA16_0 = input.LA(1); 4324 if ( (LA16_0==POSITIVE_INTEGER_LITERAL) ) { 4325 alt16=1; 4326 } 4327 else if ( (LA16_0==NEGATIVE_INTEGER_LITERAL) ) { 4328 alt16=2; 4329 } 4330 4331 else { 4332 NoViableAltException nvae = 4333 new NoViableAltException("", 16, 0, input); 4334 throw nvae; 4335 } 4336 4337 switch (alt16) { 4338 case 1 : 4339 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:610:5: POSITIVE_INTEGER_LITERAL 4340 { 4341 POSITIVE_INTEGER_LITERAL101=(Token)match(input,POSITIVE_INTEGER_LITERAL,FOLLOW_POSITIVE_INTEGER_LITERAL_in_integer_literal2369); 4342 stream_POSITIVE_INTEGER_LITERAL.add(POSITIVE_INTEGER_LITERAL101); 4343 4344 // AST REWRITE 4345 // elements: 4346 // token labels: 4347 // rule labels: retval 4348 // token list labels: 4349 // rule list labels: 4350 // wildcard labels: 4351 retval.tree = root_0; 4352 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 4353 4354 root_0 = (CommonTree)adaptor.nil(); 4355 // 610:30: -> INTEGER_LITERAL[$POSITIVE_INTEGER_LITERAL] 4356 { 4357 adaptor.addChild(root_0, (CommonTree)adaptor.create(INTEGER_LITERAL, POSITIVE_INTEGER_LITERAL101)); 4358 } 4359 4360 4361 retval.tree = root_0; 4362 4363 } 4364 break; 4365 case 2 : 4366 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:611:5: NEGATIVE_INTEGER_LITERAL 4367 { 4368 NEGATIVE_INTEGER_LITERAL102=(Token)match(input,NEGATIVE_INTEGER_LITERAL,FOLLOW_NEGATIVE_INTEGER_LITERAL_in_integer_literal2380); 4369 stream_NEGATIVE_INTEGER_LITERAL.add(NEGATIVE_INTEGER_LITERAL102); 4370 4371 // AST REWRITE 4372 // elements: 4373 // token labels: 4374 // rule labels: retval 4375 // token list labels: 4376 // rule list labels: 4377 // wildcard labels: 4378 retval.tree = root_0; 4379 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 4380 4381 root_0 = (CommonTree)adaptor.nil(); 4382 // 611:30: -> INTEGER_LITERAL[$NEGATIVE_INTEGER_LITERAL] 4383 { 4384 adaptor.addChild(root_0, (CommonTree)adaptor.create(INTEGER_LITERAL, NEGATIVE_INTEGER_LITERAL102)); 4385 } 4386 4387 4388 retval.tree = root_0; 4389 4390 } 4391 break; 4392 4393 } 4394 retval.stop = input.LT(-1); 4395 4396 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 4397 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 4398 4399 } 4400 catch (RecognitionException re) { 4401 reportError(re); 4402 recover(input,re); 4403 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 4404 } 4405 finally { 4406 // do for sure before leaving 4407 } 4408 return retval; 4409 } 4410 // $ANTLR end "integer_literal" 4411 4412 4413 public static class float_literal_return extends ParserRuleReturnScope { 4414 CommonTree tree; 4415 @Override 4416 public CommonTree getTree() { return tree; } 4417 }; 4418 4419 4420 // $ANTLR start "float_literal" 4421 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:613:1: float_literal : ( FLOAT_LITERAL_OR_ID -> FLOAT_LITERAL[$FLOAT_LITERAL_OR_ID] | FLOAT_LITERAL ); 4422 public final smaliParser.float_literal_return float_literal() throws RecognitionException { 4423 smaliParser.float_literal_return retval = new smaliParser.float_literal_return(); 4424 retval.start = input.LT(1); 4425 4426 CommonTree root_0 = null; 4427 4428 Token FLOAT_LITERAL_OR_ID103=null; 4429 Token FLOAT_LITERAL104=null; 4430 4431 CommonTree FLOAT_LITERAL_OR_ID103_tree=null; 4432 CommonTree FLOAT_LITERAL104_tree=null; 4433 RewriteRuleTokenStream stream_FLOAT_LITERAL_OR_ID=new RewriteRuleTokenStream(adaptor,"token FLOAT_LITERAL_OR_ID"); 4434 4435 try { 4436 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:614:3: ( FLOAT_LITERAL_OR_ID -> FLOAT_LITERAL[$FLOAT_LITERAL_OR_ID] | FLOAT_LITERAL ) 4437 int alt17=2; 4438 int LA17_0 = input.LA(1); 4439 if ( (LA17_0==FLOAT_LITERAL_OR_ID) ) { 4440 alt17=1; 4441 } 4442 else if ( (LA17_0==FLOAT_LITERAL) ) { 4443 alt17=2; 4444 } 4445 4446 else { 4447 NoViableAltException nvae = 4448 new NoViableAltException("", 17, 0, input); 4449 throw nvae; 4450 } 4451 4452 switch (alt17) { 4453 case 1 : 4454 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:614:5: FLOAT_LITERAL_OR_ID 4455 { 4456 FLOAT_LITERAL_OR_ID103=(Token)match(input,FLOAT_LITERAL_OR_ID,FOLLOW_FLOAT_LITERAL_OR_ID_in_float_literal2395); 4457 stream_FLOAT_LITERAL_OR_ID.add(FLOAT_LITERAL_OR_ID103); 4458 4459 // AST REWRITE 4460 // elements: 4461 // token labels: 4462 // rule labels: retval 4463 // token list labels: 4464 // rule list labels: 4465 // wildcard labels: 4466 retval.tree = root_0; 4467 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 4468 4469 root_0 = (CommonTree)adaptor.nil(); 4470 // 614:25: -> FLOAT_LITERAL[$FLOAT_LITERAL_OR_ID] 4471 { 4472 adaptor.addChild(root_0, (CommonTree)adaptor.create(FLOAT_LITERAL, FLOAT_LITERAL_OR_ID103)); 4473 } 4474 4475 4476 retval.tree = root_0; 4477 4478 } 4479 break; 4480 case 2 : 4481 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:615:5: FLOAT_LITERAL 4482 { 4483 root_0 = (CommonTree)adaptor.nil(); 4484 4485 4486 FLOAT_LITERAL104=(Token)match(input,FLOAT_LITERAL,FOLLOW_FLOAT_LITERAL_in_float_literal2406); 4487 FLOAT_LITERAL104_tree = (CommonTree)adaptor.create(FLOAT_LITERAL104); 4488 adaptor.addChild(root_0, FLOAT_LITERAL104_tree); 4489 4490 } 4491 break; 4492 4493 } 4494 retval.stop = input.LT(-1); 4495 4496 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 4497 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 4498 4499 } 4500 catch (RecognitionException re) { 4501 reportError(re); 4502 recover(input,re); 4503 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 4504 } 4505 finally { 4506 // do for sure before leaving 4507 } 4508 return retval; 4509 } 4510 // $ANTLR end "float_literal" 4511 4512 4513 public static class double_literal_return extends ParserRuleReturnScope { 4514 CommonTree tree; 4515 @Override 4516 public CommonTree getTree() { return tree; } 4517 }; 4518 4519 4520 // $ANTLR start "double_literal" 4521 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:617:1: double_literal : ( DOUBLE_LITERAL_OR_ID -> DOUBLE_LITERAL[$DOUBLE_LITERAL_OR_ID] | DOUBLE_LITERAL ); 4522 public final smaliParser.double_literal_return double_literal() throws RecognitionException { 4523 smaliParser.double_literal_return retval = new smaliParser.double_literal_return(); 4524 retval.start = input.LT(1); 4525 4526 CommonTree root_0 = null; 4527 4528 Token DOUBLE_LITERAL_OR_ID105=null; 4529 Token DOUBLE_LITERAL106=null; 4530 4531 CommonTree DOUBLE_LITERAL_OR_ID105_tree=null; 4532 CommonTree DOUBLE_LITERAL106_tree=null; 4533 RewriteRuleTokenStream stream_DOUBLE_LITERAL_OR_ID=new RewriteRuleTokenStream(adaptor,"token DOUBLE_LITERAL_OR_ID"); 4534 4535 try { 4536 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:618:3: ( DOUBLE_LITERAL_OR_ID -> DOUBLE_LITERAL[$DOUBLE_LITERAL_OR_ID] | DOUBLE_LITERAL ) 4537 int alt18=2; 4538 int LA18_0 = input.LA(1); 4539 if ( (LA18_0==DOUBLE_LITERAL_OR_ID) ) { 4540 alt18=1; 4541 } 4542 else if ( (LA18_0==DOUBLE_LITERAL) ) { 4543 alt18=2; 4544 } 4545 4546 else { 4547 NoViableAltException nvae = 4548 new NoViableAltException("", 18, 0, input); 4549 throw nvae; 4550 } 4551 4552 switch (alt18) { 4553 case 1 : 4554 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:618:5: DOUBLE_LITERAL_OR_ID 4555 { 4556 DOUBLE_LITERAL_OR_ID105=(Token)match(input,DOUBLE_LITERAL_OR_ID,FOLLOW_DOUBLE_LITERAL_OR_ID_in_double_literal2416); 4557 stream_DOUBLE_LITERAL_OR_ID.add(DOUBLE_LITERAL_OR_ID105); 4558 4559 // AST REWRITE 4560 // elements: 4561 // token labels: 4562 // rule labels: retval 4563 // token list labels: 4564 // rule list labels: 4565 // wildcard labels: 4566 retval.tree = root_0; 4567 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 4568 4569 root_0 = (CommonTree)adaptor.nil(); 4570 // 618:26: -> DOUBLE_LITERAL[$DOUBLE_LITERAL_OR_ID] 4571 { 4572 adaptor.addChild(root_0, (CommonTree)adaptor.create(DOUBLE_LITERAL, DOUBLE_LITERAL_OR_ID105)); 4573 } 4574 4575 4576 retval.tree = root_0; 4577 4578 } 4579 break; 4580 case 2 : 4581 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:619:5: DOUBLE_LITERAL 4582 { 4583 root_0 = (CommonTree)adaptor.nil(); 4584 4585 4586 DOUBLE_LITERAL106=(Token)match(input,DOUBLE_LITERAL,FOLLOW_DOUBLE_LITERAL_in_double_literal2427); 4587 DOUBLE_LITERAL106_tree = (CommonTree)adaptor.create(DOUBLE_LITERAL106); 4588 adaptor.addChild(root_0, DOUBLE_LITERAL106_tree); 4589 4590 } 4591 break; 4592 4593 } 4594 retval.stop = input.LT(-1); 4595 4596 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 4597 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 4598 4599 } 4600 catch (RecognitionException re) { 4601 reportError(re); 4602 recover(input,re); 4603 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 4604 } 4605 finally { 4606 // do for sure before leaving 4607 } 4608 return retval; 4609 } 4610 // $ANTLR end "double_literal" 4611 4612 4613 public static class literal_return extends ParserRuleReturnScope { 4614 CommonTree tree; 4615 @Override 4616 public CommonTree getTree() { return tree; } 4617 }; 4618 4619 4620 // $ANTLR start "literal" 4621 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:621: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 ); 4622 public final smaliParser.literal_return literal() throws RecognitionException { 4623 smaliParser.literal_return retval = new smaliParser.literal_return(); 4624 retval.start = input.LT(1); 4625 4626 CommonTree root_0 = null; 4627 4628 Token LONG_LITERAL107=null; 4629 Token SHORT_LITERAL109=null; 4630 Token BYTE_LITERAL110=null; 4631 Token CHAR_LITERAL113=null; 4632 Token STRING_LITERAL114=null; 4633 Token BOOL_LITERAL115=null; 4634 Token NULL_LITERAL116=null; 4635 ParserRuleReturnScope integer_literal108 =null; 4636 ParserRuleReturnScope float_literal111 =null; 4637 ParserRuleReturnScope double_literal112 =null; 4638 ParserRuleReturnScope array_literal117 =null; 4639 ParserRuleReturnScope subannotation118 =null; 4640 ParserRuleReturnScope type_field_method_literal119 =null; 4641 ParserRuleReturnScope enum_literal120 =null; 4642 4643 CommonTree LONG_LITERAL107_tree=null; 4644 CommonTree SHORT_LITERAL109_tree=null; 4645 CommonTree BYTE_LITERAL110_tree=null; 4646 CommonTree CHAR_LITERAL113_tree=null; 4647 CommonTree STRING_LITERAL114_tree=null; 4648 CommonTree BOOL_LITERAL115_tree=null; 4649 CommonTree NULL_LITERAL116_tree=null; 4650 4651 try { 4652 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:622: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 ) 4653 int alt19=14; 4654 switch ( input.LA(1) ) { 4655 case LONG_LITERAL: 4656 { 4657 alt19=1; 4658 } 4659 break; 4660 case POSITIVE_INTEGER_LITERAL: 4661 { 4662 int LA19_2 = input.LA(2); 4663 if ( (LA19_2==EOF||(LA19_2 >= ACCESS_SPEC && LA19_2 <= ANNOTATION_VISIBILITY)||LA19_2==BOOL_LITERAL||(LA19_2 >= CLASS_DIRECTIVE && LA19_2 <= CLOSE_BRACE)||LA19_2==COMMA||(LA19_2 >= DOUBLE_LITERAL_OR_ID && LA19_2 <= END_ANNOTATION_DIRECTIVE)||LA19_2==END_FIELD_DIRECTIVE||LA19_2==END_SUBANNOTATION_DIRECTIVE||LA19_2==FIELD_DIRECTIVE||(LA19_2 >= FLOAT_LITERAL_OR_ID && LA19_2 <= IMPLEMENTS_DIRECTIVE)||(LA19_2 >= INSTRUCTION_FORMAT10t && LA19_2 <= INSTRUCTION_FORMAT10x_ODEX)||LA19_2==INSTRUCTION_FORMAT11x||LA19_2==INSTRUCTION_FORMAT12x_OR_ID||(LA19_2 >= INSTRUCTION_FORMAT21c_FIELD && LA19_2 <= INSTRUCTION_FORMAT21c_TYPE)||LA19_2==INSTRUCTION_FORMAT21t||(LA19_2 >= INSTRUCTION_FORMAT22c_FIELD && LA19_2 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA19_2 >= INSTRUCTION_FORMAT22s_OR_ID && LA19_2 <= INSTRUCTION_FORMAT22t)||LA19_2==INSTRUCTION_FORMAT23x||(LA19_2 >= INSTRUCTION_FORMAT31i_OR_ID && LA19_2 <= INSTRUCTION_FORMAT31t)||(LA19_2 >= INSTRUCTION_FORMAT35c_METHOD && LA19_2 <= INSTRUCTION_FORMAT35ms_METHOD)||LA19_2==INSTRUCTION_FORMAT51l||(LA19_2 >= METHOD_DIRECTIVE && LA19_2 <= NULL_LITERAL)||LA19_2==PARAM_LIST_OR_ID_START||(LA19_2 >= POSITIVE_INTEGER_LITERAL && LA19_2 <= PRIMITIVE_TYPE)||LA19_2==REGISTER||(LA19_2 >= SIMPLE_NAME && LA19_2 <= SOURCE_DIRECTIVE)||(LA19_2 >= SUPER_DIRECTIVE && LA19_2 <= VOID_TYPE)) ) { 4664 alt19=2; 4665 } 4666 else if ( (LA19_2==COLON||LA19_2==OPEN_PAREN) ) { 4667 alt19=13; 4668 } 4669 4670 else { 4671 int nvaeMark = input.mark(); 4672 try { 4673 input.consume(); 4674 NoViableAltException nvae = 4675 new NoViableAltException("", 19, 2, input); 4676 throw nvae; 4677 } finally { 4678 input.rewind(nvaeMark); 4679 } 4680 } 4681 4682 } 4683 break; 4684 case NEGATIVE_INTEGER_LITERAL: 4685 { 4686 int LA19_3 = input.LA(2); 4687 if ( (LA19_3==EOF||(LA19_3 >= ACCESS_SPEC && LA19_3 <= ANNOTATION_VISIBILITY)||LA19_3==BOOL_LITERAL||(LA19_3 >= CLASS_DIRECTIVE && LA19_3 <= CLOSE_BRACE)||LA19_3==COMMA||(LA19_3 >= DOUBLE_LITERAL_OR_ID && LA19_3 <= END_ANNOTATION_DIRECTIVE)||LA19_3==END_FIELD_DIRECTIVE||LA19_3==END_SUBANNOTATION_DIRECTIVE||LA19_3==FIELD_DIRECTIVE||(LA19_3 >= FLOAT_LITERAL_OR_ID && LA19_3 <= IMPLEMENTS_DIRECTIVE)||(LA19_3 >= INSTRUCTION_FORMAT10t && LA19_3 <= INSTRUCTION_FORMAT10x_ODEX)||LA19_3==INSTRUCTION_FORMAT11x||LA19_3==INSTRUCTION_FORMAT12x_OR_ID||(LA19_3 >= INSTRUCTION_FORMAT21c_FIELD && LA19_3 <= INSTRUCTION_FORMAT21c_TYPE)||LA19_3==INSTRUCTION_FORMAT21t||(LA19_3 >= INSTRUCTION_FORMAT22c_FIELD && LA19_3 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA19_3 >= INSTRUCTION_FORMAT22s_OR_ID && LA19_3 <= INSTRUCTION_FORMAT22t)||LA19_3==INSTRUCTION_FORMAT23x||(LA19_3 >= INSTRUCTION_FORMAT31i_OR_ID && LA19_3 <= INSTRUCTION_FORMAT31t)||(LA19_3 >= INSTRUCTION_FORMAT35c_METHOD && LA19_3 <= INSTRUCTION_FORMAT35ms_METHOD)||LA19_3==INSTRUCTION_FORMAT51l||(LA19_3 >= METHOD_DIRECTIVE && LA19_3 <= NULL_LITERAL)||LA19_3==PARAM_LIST_OR_ID_START||(LA19_3 >= POSITIVE_INTEGER_LITERAL && LA19_3 <= PRIMITIVE_TYPE)||LA19_3==REGISTER||(LA19_3 >= SIMPLE_NAME && LA19_3 <= SOURCE_DIRECTIVE)||(LA19_3 >= SUPER_DIRECTIVE && LA19_3 <= VOID_TYPE)) ) { 4688 alt19=2; 4689 } 4690 else if ( (LA19_3==COLON||LA19_3==OPEN_PAREN) ) { 4691 alt19=13; 4692 } 4693 4694 else { 4695 int nvaeMark = input.mark(); 4696 try { 4697 input.consume(); 4698 NoViableAltException nvae = 4699 new NoViableAltException("", 19, 3, input); 4700 throw nvae; 4701 } finally { 4702 input.rewind(nvaeMark); 4703 } 4704 } 4705 4706 } 4707 break; 4708 case SHORT_LITERAL: 4709 { 4710 alt19=3; 4711 } 4712 break; 4713 case BYTE_LITERAL: 4714 { 4715 alt19=4; 4716 } 4717 break; 4718 case FLOAT_LITERAL_OR_ID: 4719 { 4720 int LA19_6 = input.LA(2); 4721 if ( (LA19_6==EOF||(LA19_6 >= ACCESS_SPEC && LA19_6 <= ANNOTATION_VISIBILITY)||LA19_6==BOOL_LITERAL||(LA19_6 >= CLASS_DIRECTIVE && LA19_6 <= CLOSE_BRACE)||LA19_6==COMMA||(LA19_6 >= DOUBLE_LITERAL_OR_ID && LA19_6 <= END_ANNOTATION_DIRECTIVE)||LA19_6==END_FIELD_DIRECTIVE||LA19_6==END_SUBANNOTATION_DIRECTIVE||LA19_6==FIELD_DIRECTIVE||(LA19_6 >= FLOAT_LITERAL_OR_ID && LA19_6 <= IMPLEMENTS_DIRECTIVE)||(LA19_6 >= INSTRUCTION_FORMAT10t && LA19_6 <= INSTRUCTION_FORMAT10x_ODEX)||LA19_6==INSTRUCTION_FORMAT11x||LA19_6==INSTRUCTION_FORMAT12x_OR_ID||(LA19_6 >= INSTRUCTION_FORMAT21c_FIELD && LA19_6 <= INSTRUCTION_FORMAT21c_TYPE)||LA19_6==INSTRUCTION_FORMAT21t||(LA19_6 >= INSTRUCTION_FORMAT22c_FIELD && LA19_6 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA19_6 >= INSTRUCTION_FORMAT22s_OR_ID && LA19_6 <= INSTRUCTION_FORMAT22t)||LA19_6==INSTRUCTION_FORMAT23x||(LA19_6 >= INSTRUCTION_FORMAT31i_OR_ID && LA19_6 <= INSTRUCTION_FORMAT31t)||(LA19_6 >= INSTRUCTION_FORMAT35c_METHOD && LA19_6 <= INSTRUCTION_FORMAT35ms_METHOD)||LA19_6==INSTRUCTION_FORMAT51l||(LA19_6 >= METHOD_DIRECTIVE && LA19_6 <= NULL_LITERAL)||LA19_6==PARAM_LIST_OR_ID_START||(LA19_6 >= POSITIVE_INTEGER_LITERAL && LA19_6 <= PRIMITIVE_TYPE)||LA19_6==REGISTER||(LA19_6 >= SIMPLE_NAME && LA19_6 <= SOURCE_DIRECTIVE)||(LA19_6 >= SUPER_DIRECTIVE && LA19_6 <= VOID_TYPE)) ) { 4722 alt19=5; 4723 } 4724 else if ( (LA19_6==COLON||LA19_6==OPEN_PAREN) ) { 4725 alt19=13; 4726 } 4727 4728 else { 4729 int nvaeMark = input.mark(); 4730 try { 4731 input.consume(); 4732 NoViableAltException nvae = 4733 new NoViableAltException("", 19, 6, input); 4734 throw nvae; 4735 } finally { 4736 input.rewind(nvaeMark); 4737 } 4738 } 4739 4740 } 4741 break; 4742 case FLOAT_LITERAL: 4743 { 4744 alt19=5; 4745 } 4746 break; 4747 case DOUBLE_LITERAL_OR_ID: 4748 { 4749 int LA19_8 = input.LA(2); 4750 if ( (LA19_8==EOF||(LA19_8 >= ACCESS_SPEC && LA19_8 <= ANNOTATION_VISIBILITY)||LA19_8==BOOL_LITERAL||(LA19_8 >= CLASS_DIRECTIVE && LA19_8 <= CLOSE_BRACE)||LA19_8==COMMA||(LA19_8 >= DOUBLE_LITERAL_OR_ID && LA19_8 <= END_ANNOTATION_DIRECTIVE)||LA19_8==END_FIELD_DIRECTIVE||LA19_8==END_SUBANNOTATION_DIRECTIVE||LA19_8==FIELD_DIRECTIVE||(LA19_8 >= FLOAT_LITERAL_OR_ID && LA19_8 <= IMPLEMENTS_DIRECTIVE)||(LA19_8 >= INSTRUCTION_FORMAT10t && LA19_8 <= INSTRUCTION_FORMAT10x_ODEX)||LA19_8==INSTRUCTION_FORMAT11x||LA19_8==INSTRUCTION_FORMAT12x_OR_ID||(LA19_8 >= INSTRUCTION_FORMAT21c_FIELD && LA19_8 <= INSTRUCTION_FORMAT21c_TYPE)||LA19_8==INSTRUCTION_FORMAT21t||(LA19_8 >= INSTRUCTION_FORMAT22c_FIELD && LA19_8 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA19_8 >= INSTRUCTION_FORMAT22s_OR_ID && LA19_8 <= INSTRUCTION_FORMAT22t)||LA19_8==INSTRUCTION_FORMAT23x||(LA19_8 >= INSTRUCTION_FORMAT31i_OR_ID && LA19_8 <= INSTRUCTION_FORMAT31t)||(LA19_8 >= INSTRUCTION_FORMAT35c_METHOD && LA19_8 <= INSTRUCTION_FORMAT35ms_METHOD)||LA19_8==INSTRUCTION_FORMAT51l||(LA19_8 >= METHOD_DIRECTIVE && LA19_8 <= NULL_LITERAL)||LA19_8==PARAM_LIST_OR_ID_START||(LA19_8 >= POSITIVE_INTEGER_LITERAL && LA19_8 <= PRIMITIVE_TYPE)||LA19_8==REGISTER||(LA19_8 >= SIMPLE_NAME && LA19_8 <= SOURCE_DIRECTIVE)||(LA19_8 >= SUPER_DIRECTIVE && LA19_8 <= VOID_TYPE)) ) { 4751 alt19=6; 4752 } 4753 else if ( (LA19_8==COLON||LA19_8==OPEN_PAREN) ) { 4754 alt19=13; 4755 } 4756 4757 else { 4758 int nvaeMark = input.mark(); 4759 try { 4760 input.consume(); 4761 NoViableAltException nvae = 4762 new NoViableAltException("", 19, 8, input); 4763 throw nvae; 4764 } finally { 4765 input.rewind(nvaeMark); 4766 } 4767 } 4768 4769 } 4770 break; 4771 case DOUBLE_LITERAL: 4772 { 4773 alt19=6; 4774 } 4775 break; 4776 case CHAR_LITERAL: 4777 { 4778 alt19=7; 4779 } 4780 break; 4781 case STRING_LITERAL: 4782 { 4783 alt19=8; 4784 } 4785 break; 4786 case BOOL_LITERAL: 4787 { 4788 int LA19_12 = input.LA(2); 4789 if ( (LA19_12==EOF||(LA19_12 >= ACCESS_SPEC && LA19_12 <= ANNOTATION_VISIBILITY)||LA19_12==BOOL_LITERAL||(LA19_12 >= CLASS_DIRECTIVE && LA19_12 <= CLOSE_BRACE)||LA19_12==COMMA||(LA19_12 >= DOUBLE_LITERAL_OR_ID && LA19_12 <= END_ANNOTATION_DIRECTIVE)||LA19_12==END_FIELD_DIRECTIVE||LA19_12==END_SUBANNOTATION_DIRECTIVE||LA19_12==FIELD_DIRECTIVE||(LA19_12 >= FLOAT_LITERAL_OR_ID && LA19_12 <= IMPLEMENTS_DIRECTIVE)||(LA19_12 >= INSTRUCTION_FORMAT10t && LA19_12 <= INSTRUCTION_FORMAT10x_ODEX)||LA19_12==INSTRUCTION_FORMAT11x||LA19_12==INSTRUCTION_FORMAT12x_OR_ID||(LA19_12 >= INSTRUCTION_FORMAT21c_FIELD && LA19_12 <= INSTRUCTION_FORMAT21c_TYPE)||LA19_12==INSTRUCTION_FORMAT21t||(LA19_12 >= INSTRUCTION_FORMAT22c_FIELD && LA19_12 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA19_12 >= INSTRUCTION_FORMAT22s_OR_ID && LA19_12 <= INSTRUCTION_FORMAT22t)||LA19_12==INSTRUCTION_FORMAT23x||(LA19_12 >= INSTRUCTION_FORMAT31i_OR_ID && LA19_12 <= INSTRUCTION_FORMAT31t)||(LA19_12 >= INSTRUCTION_FORMAT35c_METHOD && LA19_12 <= INSTRUCTION_FORMAT35ms_METHOD)||LA19_12==INSTRUCTION_FORMAT51l||(LA19_12 >= METHOD_DIRECTIVE && LA19_12 <= NULL_LITERAL)||LA19_12==PARAM_LIST_OR_ID_START||(LA19_12 >= POSITIVE_INTEGER_LITERAL && LA19_12 <= PRIMITIVE_TYPE)||LA19_12==REGISTER||(LA19_12 >= SIMPLE_NAME && LA19_12 <= SOURCE_DIRECTIVE)||(LA19_12 >= SUPER_DIRECTIVE && LA19_12 <= VOID_TYPE)) ) { 4790 alt19=9; 4791 } 4792 else if ( (LA19_12==COLON||LA19_12==OPEN_PAREN) ) { 4793 alt19=13; 4794 } 4795 4796 else { 4797 int nvaeMark = input.mark(); 4798 try { 4799 input.consume(); 4800 NoViableAltException nvae = 4801 new NoViableAltException("", 19, 12, input); 4802 throw nvae; 4803 } finally { 4804 input.rewind(nvaeMark); 4805 } 4806 } 4807 4808 } 4809 break; 4810 case NULL_LITERAL: 4811 { 4812 int LA19_13 = input.LA(2); 4813 if ( (LA19_13==EOF||(LA19_13 >= ACCESS_SPEC && LA19_13 <= ANNOTATION_VISIBILITY)||LA19_13==BOOL_LITERAL||(LA19_13 >= CLASS_DIRECTIVE && LA19_13 <= CLOSE_BRACE)||LA19_13==COMMA||(LA19_13 >= DOUBLE_LITERAL_OR_ID && LA19_13 <= END_ANNOTATION_DIRECTIVE)||LA19_13==END_FIELD_DIRECTIVE||LA19_13==END_SUBANNOTATION_DIRECTIVE||LA19_13==FIELD_DIRECTIVE||(LA19_13 >= FLOAT_LITERAL_OR_ID && LA19_13 <= IMPLEMENTS_DIRECTIVE)||(LA19_13 >= INSTRUCTION_FORMAT10t && LA19_13 <= INSTRUCTION_FORMAT10x_ODEX)||LA19_13==INSTRUCTION_FORMAT11x||LA19_13==INSTRUCTION_FORMAT12x_OR_ID||(LA19_13 >= INSTRUCTION_FORMAT21c_FIELD && LA19_13 <= INSTRUCTION_FORMAT21c_TYPE)||LA19_13==INSTRUCTION_FORMAT21t||(LA19_13 >= INSTRUCTION_FORMAT22c_FIELD && LA19_13 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA19_13 >= INSTRUCTION_FORMAT22s_OR_ID && LA19_13 <= INSTRUCTION_FORMAT22t)||LA19_13==INSTRUCTION_FORMAT23x||(LA19_13 >= INSTRUCTION_FORMAT31i_OR_ID && LA19_13 <= INSTRUCTION_FORMAT31t)||(LA19_13 >= INSTRUCTION_FORMAT35c_METHOD && LA19_13 <= INSTRUCTION_FORMAT35ms_METHOD)||LA19_13==INSTRUCTION_FORMAT51l||(LA19_13 >= METHOD_DIRECTIVE && LA19_13 <= NULL_LITERAL)||LA19_13==PARAM_LIST_OR_ID_START||(LA19_13 >= POSITIVE_INTEGER_LITERAL && LA19_13 <= PRIMITIVE_TYPE)||LA19_13==REGISTER||(LA19_13 >= SIMPLE_NAME && LA19_13 <= SOURCE_DIRECTIVE)||(LA19_13 >= SUPER_DIRECTIVE && LA19_13 <= VOID_TYPE)) ) { 4814 alt19=10; 4815 } 4816 else if ( (LA19_13==COLON||LA19_13==OPEN_PAREN) ) { 4817 alt19=13; 4818 } 4819 4820 else { 4821 int nvaeMark = input.mark(); 4822 try { 4823 input.consume(); 4824 NoViableAltException nvae = 4825 new NoViableAltException("", 19, 13, input); 4826 throw nvae; 4827 } finally { 4828 input.rewind(nvaeMark); 4829 } 4830 } 4831 4832 } 4833 break; 4834 case OPEN_BRACE: 4835 { 4836 alt19=11; 4837 } 4838 break; 4839 case SUBANNOTATION_DIRECTIVE: 4840 { 4841 alt19=12; 4842 } 4843 break; 4844 case ACCESS_SPEC: 4845 case ANNOTATION_VISIBILITY: 4846 case ARRAY_DESCRIPTOR: 4847 case CLASS_DESCRIPTOR: 4848 case INSTRUCTION_FORMAT10t: 4849 case INSTRUCTION_FORMAT10x: 4850 case INSTRUCTION_FORMAT10x_ODEX: 4851 case INSTRUCTION_FORMAT11x: 4852 case INSTRUCTION_FORMAT12x_OR_ID: 4853 case INSTRUCTION_FORMAT21c_FIELD: 4854 case INSTRUCTION_FORMAT21c_FIELD_ODEX: 4855 case INSTRUCTION_FORMAT21c_STRING: 4856 case INSTRUCTION_FORMAT21c_TYPE: 4857 case INSTRUCTION_FORMAT21t: 4858 case INSTRUCTION_FORMAT22c_FIELD: 4859 case INSTRUCTION_FORMAT22c_FIELD_ODEX: 4860 case INSTRUCTION_FORMAT22c_TYPE: 4861 case INSTRUCTION_FORMAT22cs_FIELD: 4862 case INSTRUCTION_FORMAT22s_OR_ID: 4863 case INSTRUCTION_FORMAT22t: 4864 case INSTRUCTION_FORMAT23x: 4865 case INSTRUCTION_FORMAT31i_OR_ID: 4866 case INSTRUCTION_FORMAT31t: 4867 case INSTRUCTION_FORMAT35c_METHOD: 4868 case INSTRUCTION_FORMAT35c_METHOD_ODEX: 4869 case INSTRUCTION_FORMAT35c_TYPE: 4870 case INSTRUCTION_FORMAT35mi_METHOD: 4871 case INSTRUCTION_FORMAT35ms_METHOD: 4872 case INSTRUCTION_FORMAT51l: 4873 case MEMBER_NAME: 4874 case PARAM_LIST_OR_ID_START: 4875 case PRIMITIVE_TYPE: 4876 case REGISTER: 4877 case SIMPLE_NAME: 4878 case VERIFICATION_ERROR_TYPE: 4879 case VOID_TYPE: 4880 { 4881 alt19=13; 4882 } 4883 break; 4884 case ENUM_DIRECTIVE: 4885 { 4886 alt19=14; 4887 } 4888 break; 4889 default: 4890 NoViableAltException nvae = 4891 new NoViableAltException("", 19, 0, input); 4892 throw nvae; 4893 } 4894 switch (alt19) { 4895 case 1 : 4896 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:622:5: LONG_LITERAL 4897 { 4898 root_0 = (CommonTree)adaptor.nil(); 4899 4900 4901 LONG_LITERAL107=(Token)match(input,LONG_LITERAL,FOLLOW_LONG_LITERAL_in_literal2437); 4902 LONG_LITERAL107_tree = (CommonTree)adaptor.create(LONG_LITERAL107); 4903 adaptor.addChild(root_0, LONG_LITERAL107_tree); 4904 4905 } 4906 break; 4907 case 2 : 4908 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:623:5: integer_literal 4909 { 4910 root_0 = (CommonTree)adaptor.nil(); 4911 4912 4913 pushFollow(FOLLOW_integer_literal_in_literal2443); 4914 integer_literal108=integer_literal(); 4915 state._fsp--; 4916 4917 adaptor.addChild(root_0, integer_literal108.getTree()); 4918 4919 } 4920 break; 4921 case 3 : 4922 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:624:5: SHORT_LITERAL 4923 { 4924 root_0 = (CommonTree)adaptor.nil(); 4925 4926 4927 SHORT_LITERAL109=(Token)match(input,SHORT_LITERAL,FOLLOW_SHORT_LITERAL_in_literal2449); 4928 SHORT_LITERAL109_tree = (CommonTree)adaptor.create(SHORT_LITERAL109); 4929 adaptor.addChild(root_0, SHORT_LITERAL109_tree); 4930 4931 } 4932 break; 4933 case 4 : 4934 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:625:5: BYTE_LITERAL 4935 { 4936 root_0 = (CommonTree)adaptor.nil(); 4937 4938 4939 BYTE_LITERAL110=(Token)match(input,BYTE_LITERAL,FOLLOW_BYTE_LITERAL_in_literal2455); 4940 BYTE_LITERAL110_tree = (CommonTree)adaptor.create(BYTE_LITERAL110); 4941 adaptor.addChild(root_0, BYTE_LITERAL110_tree); 4942 4943 } 4944 break; 4945 case 5 : 4946 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:626:5: float_literal 4947 { 4948 root_0 = (CommonTree)adaptor.nil(); 4949 4950 4951 pushFollow(FOLLOW_float_literal_in_literal2461); 4952 float_literal111=float_literal(); 4953 state._fsp--; 4954 4955 adaptor.addChild(root_0, float_literal111.getTree()); 4956 4957 } 4958 break; 4959 case 6 : 4960 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:627:5: double_literal 4961 { 4962 root_0 = (CommonTree)adaptor.nil(); 4963 4964 4965 pushFollow(FOLLOW_double_literal_in_literal2467); 4966 double_literal112=double_literal(); 4967 state._fsp--; 4968 4969 adaptor.addChild(root_0, double_literal112.getTree()); 4970 4971 } 4972 break; 4973 case 7 : 4974 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:628:5: CHAR_LITERAL 4975 { 4976 root_0 = (CommonTree)adaptor.nil(); 4977 4978 4979 CHAR_LITERAL113=(Token)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_literal2473); 4980 CHAR_LITERAL113_tree = (CommonTree)adaptor.create(CHAR_LITERAL113); 4981 adaptor.addChild(root_0, CHAR_LITERAL113_tree); 4982 4983 } 4984 break; 4985 case 8 : 4986 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:629:5: STRING_LITERAL 4987 { 4988 root_0 = (CommonTree)adaptor.nil(); 4989 4990 4991 STRING_LITERAL114=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_literal2479); 4992 STRING_LITERAL114_tree = (CommonTree)adaptor.create(STRING_LITERAL114); 4993 adaptor.addChild(root_0, STRING_LITERAL114_tree); 4994 4995 } 4996 break; 4997 case 9 : 4998 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:630:5: BOOL_LITERAL 4999 { 5000 root_0 = (CommonTree)adaptor.nil(); 5001 5002 5003 BOOL_LITERAL115=(Token)match(input,BOOL_LITERAL,FOLLOW_BOOL_LITERAL_in_literal2485); 5004 BOOL_LITERAL115_tree = (CommonTree)adaptor.create(BOOL_LITERAL115); 5005 adaptor.addChild(root_0, BOOL_LITERAL115_tree); 5006 5007 } 5008 break; 5009 case 10 : 5010 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:631:5: NULL_LITERAL 5011 { 5012 root_0 = (CommonTree)adaptor.nil(); 5013 5014 5015 NULL_LITERAL116=(Token)match(input,NULL_LITERAL,FOLLOW_NULL_LITERAL_in_literal2491); 5016 NULL_LITERAL116_tree = (CommonTree)adaptor.create(NULL_LITERAL116); 5017 adaptor.addChild(root_0, NULL_LITERAL116_tree); 5018 5019 } 5020 break; 5021 case 11 : 5022 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:632:5: array_literal 5023 { 5024 root_0 = (CommonTree)adaptor.nil(); 5025 5026 5027 pushFollow(FOLLOW_array_literal_in_literal2497); 5028 array_literal117=array_literal(); 5029 state._fsp--; 5030 5031 adaptor.addChild(root_0, array_literal117.getTree()); 5032 5033 } 5034 break; 5035 case 12 : 5036 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:633:5: subannotation 5037 { 5038 root_0 = (CommonTree)adaptor.nil(); 5039 5040 5041 pushFollow(FOLLOW_subannotation_in_literal2503); 5042 subannotation118=subannotation(); 5043 state._fsp--; 5044 5045 adaptor.addChild(root_0, subannotation118.getTree()); 5046 5047 } 5048 break; 5049 case 13 : 5050 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:634:5: type_field_method_literal 5051 { 5052 root_0 = (CommonTree)adaptor.nil(); 5053 5054 5055 pushFollow(FOLLOW_type_field_method_literal_in_literal2509); 5056 type_field_method_literal119=type_field_method_literal(); 5057 state._fsp--; 5058 5059 adaptor.addChild(root_0, type_field_method_literal119.getTree()); 5060 5061 } 5062 break; 5063 case 14 : 5064 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:635:5: enum_literal 5065 { 5066 root_0 = (CommonTree)adaptor.nil(); 5067 5068 5069 pushFollow(FOLLOW_enum_literal_in_literal2515); 5070 enum_literal120=enum_literal(); 5071 state._fsp--; 5072 5073 adaptor.addChild(root_0, enum_literal120.getTree()); 5074 5075 } 5076 break; 5077 5078 } 5079 retval.stop = input.LT(-1); 5080 5081 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 5082 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 5083 5084 } 5085 catch (RecognitionException re) { 5086 reportError(re); 5087 recover(input,re); 5088 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 5089 } 5090 finally { 5091 // do for sure before leaving 5092 } 5093 return retval; 5094 } 5095 // $ANTLR end "literal" 5096 5097 5098 public static class parsed_integer_literal_return extends ParserRuleReturnScope { 5099 public int value; 5100 CommonTree tree; 5101 @Override 5102 public CommonTree getTree() { return tree; } 5103 }; 5104 5105 5106 // $ANTLR start "parsed_integer_literal" 5107 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:637:1: parsed_integer_literal returns [int value] : integer_literal ; 5108 public final smaliParser.parsed_integer_literal_return parsed_integer_literal() throws RecognitionException { 5109 smaliParser.parsed_integer_literal_return retval = new smaliParser.parsed_integer_literal_return(); 5110 retval.start = input.LT(1); 5111 5112 CommonTree root_0 = null; 5113 5114 ParserRuleReturnScope integer_literal121 =null; 5115 5116 5117 try { 5118 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:638:3: ( integer_literal ) 5119 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:638:5: integer_literal 5120 { 5121 root_0 = (CommonTree)adaptor.nil(); 5122 5123 5124 pushFollow(FOLLOW_integer_literal_in_parsed_integer_literal2528); 5125 integer_literal121=integer_literal(); 5126 state._fsp--; 5127 5128 adaptor.addChild(root_0, integer_literal121.getTree()); 5129 5130 retval.value = LiteralTools.parseInt((integer_literal121!=null?input.toString(integer_literal121.start,integer_literal121.stop):null)); 5131 } 5132 5133 retval.stop = input.LT(-1); 5134 5135 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 5136 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 5137 5138 } 5139 catch (RecognitionException re) { 5140 reportError(re); 5141 recover(input,re); 5142 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 5143 } 5144 finally { 5145 // do for sure before leaving 5146 } 5147 return retval; 5148 } 5149 // $ANTLR end "parsed_integer_literal" 5150 5151 5152 public static class integral_literal_return extends ParserRuleReturnScope { 5153 CommonTree tree; 5154 @Override 5155 public CommonTree getTree() { return tree; } 5156 }; 5157 5158 5159 // $ANTLR start "integral_literal" 5160 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:640:1: integral_literal : ( LONG_LITERAL | integer_literal | SHORT_LITERAL | CHAR_LITERAL | BYTE_LITERAL ); 5161 public final smaliParser.integral_literal_return integral_literal() throws RecognitionException { 5162 smaliParser.integral_literal_return retval = new smaliParser.integral_literal_return(); 5163 retval.start = input.LT(1); 5164 5165 CommonTree root_0 = null; 5166 5167 Token LONG_LITERAL122=null; 5168 Token SHORT_LITERAL124=null; 5169 Token CHAR_LITERAL125=null; 5170 Token BYTE_LITERAL126=null; 5171 ParserRuleReturnScope integer_literal123 =null; 5172 5173 CommonTree LONG_LITERAL122_tree=null; 5174 CommonTree SHORT_LITERAL124_tree=null; 5175 CommonTree CHAR_LITERAL125_tree=null; 5176 CommonTree BYTE_LITERAL126_tree=null; 5177 5178 try { 5179 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:641:3: ( LONG_LITERAL | integer_literal | SHORT_LITERAL | CHAR_LITERAL | BYTE_LITERAL ) 5180 int alt20=5; 5181 switch ( input.LA(1) ) { 5182 case LONG_LITERAL: 5183 { 5184 alt20=1; 5185 } 5186 break; 5187 case NEGATIVE_INTEGER_LITERAL: 5188 case POSITIVE_INTEGER_LITERAL: 5189 { 5190 alt20=2; 5191 } 5192 break; 5193 case SHORT_LITERAL: 5194 { 5195 alt20=3; 5196 } 5197 break; 5198 case CHAR_LITERAL: 5199 { 5200 alt20=4; 5201 } 5202 break; 5203 case BYTE_LITERAL: 5204 { 5205 alt20=5; 5206 } 5207 break; 5208 default: 5209 NoViableAltException nvae = 5210 new NoViableAltException("", 20, 0, input); 5211 throw nvae; 5212 } 5213 switch (alt20) { 5214 case 1 : 5215 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:641:5: LONG_LITERAL 5216 { 5217 root_0 = (CommonTree)adaptor.nil(); 5218 5219 5220 LONG_LITERAL122=(Token)match(input,LONG_LITERAL,FOLLOW_LONG_LITERAL_in_integral_literal2540); 5221 LONG_LITERAL122_tree = (CommonTree)adaptor.create(LONG_LITERAL122); 5222 adaptor.addChild(root_0, LONG_LITERAL122_tree); 5223 5224 } 5225 break; 5226 case 2 : 5227 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:642:5: integer_literal 5228 { 5229 root_0 = (CommonTree)adaptor.nil(); 5230 5231 5232 pushFollow(FOLLOW_integer_literal_in_integral_literal2546); 5233 integer_literal123=integer_literal(); 5234 state._fsp--; 5235 5236 adaptor.addChild(root_0, integer_literal123.getTree()); 5237 5238 } 5239 break; 5240 case 3 : 5241 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:643:5: SHORT_LITERAL 5242 { 5243 root_0 = (CommonTree)adaptor.nil(); 5244 5245 5246 SHORT_LITERAL124=(Token)match(input,SHORT_LITERAL,FOLLOW_SHORT_LITERAL_in_integral_literal2552); 5247 SHORT_LITERAL124_tree = (CommonTree)adaptor.create(SHORT_LITERAL124); 5248 adaptor.addChild(root_0, SHORT_LITERAL124_tree); 5249 5250 } 5251 break; 5252 case 4 : 5253 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:644:5: CHAR_LITERAL 5254 { 5255 root_0 = (CommonTree)adaptor.nil(); 5256 5257 5258 CHAR_LITERAL125=(Token)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_integral_literal2558); 5259 CHAR_LITERAL125_tree = (CommonTree)adaptor.create(CHAR_LITERAL125); 5260 adaptor.addChild(root_0, CHAR_LITERAL125_tree); 5261 5262 } 5263 break; 5264 case 5 : 5265 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:645:5: BYTE_LITERAL 5266 { 5267 root_0 = (CommonTree)adaptor.nil(); 5268 5269 5270 BYTE_LITERAL126=(Token)match(input,BYTE_LITERAL,FOLLOW_BYTE_LITERAL_in_integral_literal2564); 5271 BYTE_LITERAL126_tree = (CommonTree)adaptor.create(BYTE_LITERAL126); 5272 adaptor.addChild(root_0, BYTE_LITERAL126_tree); 5273 5274 } 5275 break; 5276 5277 } 5278 retval.stop = input.LT(-1); 5279 5280 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 5281 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 5282 5283 } 5284 catch (RecognitionException re) { 5285 reportError(re); 5286 recover(input,re); 5287 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 5288 } 5289 finally { 5290 // do for sure before leaving 5291 } 5292 return retval; 5293 } 5294 // $ANTLR end "integral_literal" 5295 5296 5297 public static class fixed_32bit_literal_return extends ParserRuleReturnScope { 5298 CommonTree tree; 5299 @Override 5300 public CommonTree getTree() { return tree; } 5301 }; 5302 5303 5304 // $ANTLR start "fixed_32bit_literal" 5305 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:647:1: fixed_32bit_literal : ( LONG_LITERAL | integer_literal | SHORT_LITERAL | BYTE_LITERAL | float_literal | CHAR_LITERAL | BOOL_LITERAL ); 5306 public final smaliParser.fixed_32bit_literal_return fixed_32bit_literal() throws RecognitionException { 5307 smaliParser.fixed_32bit_literal_return retval = new smaliParser.fixed_32bit_literal_return(); 5308 retval.start = input.LT(1); 5309 5310 CommonTree root_0 = null; 5311 5312 Token LONG_LITERAL127=null; 5313 Token SHORT_LITERAL129=null; 5314 Token BYTE_LITERAL130=null; 5315 Token CHAR_LITERAL132=null; 5316 Token BOOL_LITERAL133=null; 5317 ParserRuleReturnScope integer_literal128 =null; 5318 ParserRuleReturnScope float_literal131 =null; 5319 5320 CommonTree LONG_LITERAL127_tree=null; 5321 CommonTree SHORT_LITERAL129_tree=null; 5322 CommonTree BYTE_LITERAL130_tree=null; 5323 CommonTree CHAR_LITERAL132_tree=null; 5324 CommonTree BOOL_LITERAL133_tree=null; 5325 5326 try { 5327 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:648:3: ( LONG_LITERAL | integer_literal | SHORT_LITERAL | BYTE_LITERAL | float_literal | CHAR_LITERAL | BOOL_LITERAL ) 5328 int alt21=7; 5329 switch ( input.LA(1) ) { 5330 case LONG_LITERAL: 5331 { 5332 alt21=1; 5333 } 5334 break; 5335 case NEGATIVE_INTEGER_LITERAL: 5336 case POSITIVE_INTEGER_LITERAL: 5337 { 5338 alt21=2; 5339 } 5340 break; 5341 case SHORT_LITERAL: 5342 { 5343 alt21=3; 5344 } 5345 break; 5346 case BYTE_LITERAL: 5347 { 5348 alt21=4; 5349 } 5350 break; 5351 case FLOAT_LITERAL: 5352 case FLOAT_LITERAL_OR_ID: 5353 { 5354 alt21=5; 5355 } 5356 break; 5357 case CHAR_LITERAL: 5358 { 5359 alt21=6; 5360 } 5361 break; 5362 case BOOL_LITERAL: 5363 { 5364 alt21=7; 5365 } 5366 break; 5367 default: 5368 NoViableAltException nvae = 5369 new NoViableAltException("", 21, 0, input); 5370 throw nvae; 5371 } 5372 switch (alt21) { 5373 case 1 : 5374 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:648:5: LONG_LITERAL 5375 { 5376 root_0 = (CommonTree)adaptor.nil(); 5377 5378 5379 LONG_LITERAL127=(Token)match(input,LONG_LITERAL,FOLLOW_LONG_LITERAL_in_fixed_32bit_literal2574); 5380 LONG_LITERAL127_tree = (CommonTree)adaptor.create(LONG_LITERAL127); 5381 adaptor.addChild(root_0, LONG_LITERAL127_tree); 5382 5383 } 5384 break; 5385 case 2 : 5386 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:649:5: integer_literal 5387 { 5388 root_0 = (CommonTree)adaptor.nil(); 5389 5390 5391 pushFollow(FOLLOW_integer_literal_in_fixed_32bit_literal2580); 5392 integer_literal128=integer_literal(); 5393 state._fsp--; 5394 5395 adaptor.addChild(root_0, integer_literal128.getTree()); 5396 5397 } 5398 break; 5399 case 3 : 5400 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:650:5: SHORT_LITERAL 5401 { 5402 root_0 = (CommonTree)adaptor.nil(); 5403 5404 5405 SHORT_LITERAL129=(Token)match(input,SHORT_LITERAL,FOLLOW_SHORT_LITERAL_in_fixed_32bit_literal2586); 5406 SHORT_LITERAL129_tree = (CommonTree)adaptor.create(SHORT_LITERAL129); 5407 adaptor.addChild(root_0, SHORT_LITERAL129_tree); 5408 5409 } 5410 break; 5411 case 4 : 5412 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:651:5: BYTE_LITERAL 5413 { 5414 root_0 = (CommonTree)adaptor.nil(); 5415 5416 5417 BYTE_LITERAL130=(Token)match(input,BYTE_LITERAL,FOLLOW_BYTE_LITERAL_in_fixed_32bit_literal2592); 5418 BYTE_LITERAL130_tree = (CommonTree)adaptor.create(BYTE_LITERAL130); 5419 adaptor.addChild(root_0, BYTE_LITERAL130_tree); 5420 5421 } 5422 break; 5423 case 5 : 5424 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:652:5: float_literal 5425 { 5426 root_0 = (CommonTree)adaptor.nil(); 5427 5428 5429 pushFollow(FOLLOW_float_literal_in_fixed_32bit_literal2598); 5430 float_literal131=float_literal(); 5431 state._fsp--; 5432 5433 adaptor.addChild(root_0, float_literal131.getTree()); 5434 5435 } 5436 break; 5437 case 6 : 5438 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:653:5: CHAR_LITERAL 5439 { 5440 root_0 = (CommonTree)adaptor.nil(); 5441 5442 5443 CHAR_LITERAL132=(Token)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_fixed_32bit_literal2604); 5444 CHAR_LITERAL132_tree = (CommonTree)adaptor.create(CHAR_LITERAL132); 5445 adaptor.addChild(root_0, CHAR_LITERAL132_tree); 5446 5447 } 5448 break; 5449 case 7 : 5450 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:654:5: BOOL_LITERAL 5451 { 5452 root_0 = (CommonTree)adaptor.nil(); 5453 5454 5455 BOOL_LITERAL133=(Token)match(input,BOOL_LITERAL,FOLLOW_BOOL_LITERAL_in_fixed_32bit_literal2610); 5456 BOOL_LITERAL133_tree = (CommonTree)adaptor.create(BOOL_LITERAL133); 5457 adaptor.addChild(root_0, BOOL_LITERAL133_tree); 5458 5459 } 5460 break; 5461 5462 } 5463 retval.stop = input.LT(-1); 5464 5465 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 5466 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 5467 5468 } 5469 catch (RecognitionException re) { 5470 reportError(re); 5471 recover(input,re); 5472 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 5473 } 5474 finally { 5475 // do for sure before leaving 5476 } 5477 return retval; 5478 } 5479 // $ANTLR end "fixed_32bit_literal" 5480 5481 5482 public static class fixed_literal_return extends ParserRuleReturnScope { 5483 CommonTree tree; 5484 @Override 5485 public CommonTree getTree() { return tree; } 5486 }; 5487 5488 5489 // $ANTLR start "fixed_literal" 5490 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:656:1: fixed_literal : ( integer_literal | LONG_LITERAL | SHORT_LITERAL | BYTE_LITERAL | float_literal | double_literal | CHAR_LITERAL | BOOL_LITERAL ); 5491 public final smaliParser.fixed_literal_return fixed_literal() throws RecognitionException { 5492 smaliParser.fixed_literal_return retval = new smaliParser.fixed_literal_return(); 5493 retval.start = input.LT(1); 5494 5495 CommonTree root_0 = null; 5496 5497 Token LONG_LITERAL135=null; 5498 Token SHORT_LITERAL136=null; 5499 Token BYTE_LITERAL137=null; 5500 Token CHAR_LITERAL140=null; 5501 Token BOOL_LITERAL141=null; 5502 ParserRuleReturnScope integer_literal134 =null; 5503 ParserRuleReturnScope float_literal138 =null; 5504 ParserRuleReturnScope double_literal139 =null; 5505 5506 CommonTree LONG_LITERAL135_tree=null; 5507 CommonTree SHORT_LITERAL136_tree=null; 5508 CommonTree BYTE_LITERAL137_tree=null; 5509 CommonTree CHAR_LITERAL140_tree=null; 5510 CommonTree BOOL_LITERAL141_tree=null; 5511 5512 try { 5513 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:657:3: ( integer_literal | LONG_LITERAL | SHORT_LITERAL | BYTE_LITERAL | float_literal | double_literal | CHAR_LITERAL | BOOL_LITERAL ) 5514 int alt22=8; 5515 switch ( input.LA(1) ) { 5516 case NEGATIVE_INTEGER_LITERAL: 5517 case POSITIVE_INTEGER_LITERAL: 5518 { 5519 alt22=1; 5520 } 5521 break; 5522 case LONG_LITERAL: 5523 { 5524 alt22=2; 5525 } 5526 break; 5527 case SHORT_LITERAL: 5528 { 5529 alt22=3; 5530 } 5531 break; 5532 case BYTE_LITERAL: 5533 { 5534 alt22=4; 5535 } 5536 break; 5537 case FLOAT_LITERAL: 5538 case FLOAT_LITERAL_OR_ID: 5539 { 5540 alt22=5; 5541 } 5542 break; 5543 case DOUBLE_LITERAL: 5544 case DOUBLE_LITERAL_OR_ID: 5545 { 5546 alt22=6; 5547 } 5548 break; 5549 case CHAR_LITERAL: 5550 { 5551 alt22=7; 5552 } 5553 break; 5554 case BOOL_LITERAL: 5555 { 5556 alt22=8; 5557 } 5558 break; 5559 default: 5560 NoViableAltException nvae = 5561 new NoViableAltException("", 22, 0, input); 5562 throw nvae; 5563 } 5564 switch (alt22) { 5565 case 1 : 5566 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:657:5: integer_literal 5567 { 5568 root_0 = (CommonTree)adaptor.nil(); 5569 5570 5571 pushFollow(FOLLOW_integer_literal_in_fixed_literal2620); 5572 integer_literal134=integer_literal(); 5573 state._fsp--; 5574 5575 adaptor.addChild(root_0, integer_literal134.getTree()); 5576 5577 } 5578 break; 5579 case 2 : 5580 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:658:5: LONG_LITERAL 5581 { 5582 root_0 = (CommonTree)adaptor.nil(); 5583 5584 5585 LONG_LITERAL135=(Token)match(input,LONG_LITERAL,FOLLOW_LONG_LITERAL_in_fixed_literal2626); 5586 LONG_LITERAL135_tree = (CommonTree)adaptor.create(LONG_LITERAL135); 5587 adaptor.addChild(root_0, LONG_LITERAL135_tree); 5588 5589 } 5590 break; 5591 case 3 : 5592 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:659:5: SHORT_LITERAL 5593 { 5594 root_0 = (CommonTree)adaptor.nil(); 5595 5596 5597 SHORT_LITERAL136=(Token)match(input,SHORT_LITERAL,FOLLOW_SHORT_LITERAL_in_fixed_literal2632); 5598 SHORT_LITERAL136_tree = (CommonTree)adaptor.create(SHORT_LITERAL136); 5599 adaptor.addChild(root_0, SHORT_LITERAL136_tree); 5600 5601 } 5602 break; 5603 case 4 : 5604 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:660:5: BYTE_LITERAL 5605 { 5606 root_0 = (CommonTree)adaptor.nil(); 5607 5608 5609 BYTE_LITERAL137=(Token)match(input,BYTE_LITERAL,FOLLOW_BYTE_LITERAL_in_fixed_literal2638); 5610 BYTE_LITERAL137_tree = (CommonTree)adaptor.create(BYTE_LITERAL137); 5611 adaptor.addChild(root_0, BYTE_LITERAL137_tree); 5612 5613 } 5614 break; 5615 case 5 : 5616 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:661:5: float_literal 5617 { 5618 root_0 = (CommonTree)adaptor.nil(); 5619 5620 5621 pushFollow(FOLLOW_float_literal_in_fixed_literal2644); 5622 float_literal138=float_literal(); 5623 state._fsp--; 5624 5625 adaptor.addChild(root_0, float_literal138.getTree()); 5626 5627 } 5628 break; 5629 case 6 : 5630 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:662:5: double_literal 5631 { 5632 root_0 = (CommonTree)adaptor.nil(); 5633 5634 5635 pushFollow(FOLLOW_double_literal_in_fixed_literal2650); 5636 double_literal139=double_literal(); 5637 state._fsp--; 5638 5639 adaptor.addChild(root_0, double_literal139.getTree()); 5640 5641 } 5642 break; 5643 case 7 : 5644 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:663:5: CHAR_LITERAL 5645 { 5646 root_0 = (CommonTree)adaptor.nil(); 5647 5648 5649 CHAR_LITERAL140=(Token)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_fixed_literal2656); 5650 CHAR_LITERAL140_tree = (CommonTree)adaptor.create(CHAR_LITERAL140); 5651 adaptor.addChild(root_0, CHAR_LITERAL140_tree); 5652 5653 } 5654 break; 5655 case 8 : 5656 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:664:5: BOOL_LITERAL 5657 { 5658 root_0 = (CommonTree)adaptor.nil(); 5659 5660 5661 BOOL_LITERAL141=(Token)match(input,BOOL_LITERAL,FOLLOW_BOOL_LITERAL_in_fixed_literal2662); 5662 BOOL_LITERAL141_tree = (CommonTree)adaptor.create(BOOL_LITERAL141); 5663 adaptor.addChild(root_0, BOOL_LITERAL141_tree); 5664 5665 } 5666 break; 5667 5668 } 5669 retval.stop = input.LT(-1); 5670 5671 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 5672 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 5673 5674 } 5675 catch (RecognitionException re) { 5676 reportError(re); 5677 recover(input,re); 5678 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 5679 } 5680 finally { 5681 // do for sure before leaving 5682 } 5683 return retval; 5684 } 5685 // $ANTLR end "fixed_literal" 5686 5687 5688 public static class array_literal_return extends ParserRuleReturnScope { 5689 CommonTree tree; 5690 @Override 5691 public CommonTree getTree() { return tree; } 5692 }; 5693 5694 5695 // $ANTLR start "array_literal" 5696 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:666:1: array_literal : OPEN_BRACE ( literal ( COMMA literal )* |) CLOSE_BRACE -> ^( I_ENCODED_ARRAY[$start, \"I_ENCODED_ARRAY\"] ( literal )* ) ; 5697 public final smaliParser.array_literal_return array_literal() throws RecognitionException { 5698 smaliParser.array_literal_return retval = new smaliParser.array_literal_return(); 5699 retval.start = input.LT(1); 5700 5701 CommonTree root_0 = null; 5702 5703 Token OPEN_BRACE142=null; 5704 Token COMMA144=null; 5705 Token CLOSE_BRACE146=null; 5706 ParserRuleReturnScope literal143 =null; 5707 ParserRuleReturnScope literal145 =null; 5708 5709 CommonTree OPEN_BRACE142_tree=null; 5710 CommonTree COMMA144_tree=null; 5711 CommonTree CLOSE_BRACE146_tree=null; 5712 RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE"); 5713 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 5714 RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE"); 5715 RewriteRuleSubtreeStream stream_literal=new RewriteRuleSubtreeStream(adaptor,"rule literal"); 5716 5717 try { 5718 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:667:3: ( OPEN_BRACE ( literal ( COMMA literal )* |) CLOSE_BRACE -> ^( I_ENCODED_ARRAY[$start, \"I_ENCODED_ARRAY\"] ( literal )* ) ) 5719 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:667:5: OPEN_BRACE ( literal ( COMMA literal )* |) CLOSE_BRACE 5720 { 5721 OPEN_BRACE142=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_array_literal2672); 5722 stream_OPEN_BRACE.add(OPEN_BRACE142); 5723 5724 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:667:16: ( literal ( COMMA literal )* |) 5725 int alt24=2; 5726 int LA24_0 = input.LA(1); 5727 if ( (LA24_0==ACCESS_SPEC||LA24_0==ANNOTATION_VISIBILITY||LA24_0==ARRAY_DESCRIPTOR||(LA24_0 >= BOOL_LITERAL && LA24_0 <= BYTE_LITERAL)||(LA24_0 >= CHAR_LITERAL && LA24_0 <= CLASS_DESCRIPTOR)||(LA24_0 >= DOUBLE_LITERAL && LA24_0 <= DOUBLE_LITERAL_OR_ID)||LA24_0==ENUM_DIRECTIVE||(LA24_0 >= FLOAT_LITERAL && LA24_0 <= FLOAT_LITERAL_OR_ID)||(LA24_0 >= INSTRUCTION_FORMAT10t && LA24_0 <= INSTRUCTION_FORMAT10x_ODEX)||LA24_0==INSTRUCTION_FORMAT11x||LA24_0==INSTRUCTION_FORMAT12x_OR_ID||(LA24_0 >= INSTRUCTION_FORMAT21c_FIELD && LA24_0 <= INSTRUCTION_FORMAT21c_TYPE)||LA24_0==INSTRUCTION_FORMAT21t||(LA24_0 >= INSTRUCTION_FORMAT22c_FIELD && LA24_0 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA24_0 >= INSTRUCTION_FORMAT22s_OR_ID && LA24_0 <= INSTRUCTION_FORMAT22t)||LA24_0==INSTRUCTION_FORMAT23x||(LA24_0 >= INSTRUCTION_FORMAT31i_OR_ID && LA24_0 <= INSTRUCTION_FORMAT31t)||(LA24_0 >= INSTRUCTION_FORMAT35c_METHOD && LA24_0 <= INSTRUCTION_FORMAT35ms_METHOD)||LA24_0==INSTRUCTION_FORMAT51l||(LA24_0 >= LONG_LITERAL && LA24_0 <= MEMBER_NAME)||(LA24_0 >= NEGATIVE_INTEGER_LITERAL && LA24_0 <= OPEN_BRACE)||LA24_0==PARAM_LIST_OR_ID_START||(LA24_0 >= POSITIVE_INTEGER_LITERAL && LA24_0 <= PRIMITIVE_TYPE)||LA24_0==REGISTER||(LA24_0 >= SHORT_LITERAL && LA24_0 <= SIMPLE_NAME)||(LA24_0 >= STRING_LITERAL && LA24_0 <= SUBANNOTATION_DIRECTIVE)||(LA24_0 >= VERIFICATION_ERROR_TYPE && LA24_0 <= VOID_TYPE)) ) { 5728 alt24=1; 5729 } 5730 else if ( (LA24_0==CLOSE_BRACE) ) { 5731 alt24=2; 5732 } 5733 5734 else { 5735 NoViableAltException nvae = 5736 new NoViableAltException("", 24, 0, input); 5737 throw nvae; 5738 } 5739 5740 switch (alt24) { 5741 case 1 : 5742 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:667:17: literal ( COMMA literal )* 5743 { 5744 pushFollow(FOLLOW_literal_in_array_literal2675); 5745 literal143=literal(); 5746 state._fsp--; 5747 5748 stream_literal.add(literal143.getTree()); 5749 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:667:25: ( COMMA literal )* 5750 loop23: 5751 while (true) { 5752 int alt23=2; 5753 int LA23_0 = input.LA(1); 5754 if ( (LA23_0==COMMA) ) { 5755 alt23=1; 5756 } 5757 5758 switch (alt23) { 5759 case 1 : 5760 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:667:26: COMMA literal 5761 { 5762 COMMA144=(Token)match(input,COMMA,FOLLOW_COMMA_in_array_literal2678); 5763 stream_COMMA.add(COMMA144); 5764 5765 pushFollow(FOLLOW_literal_in_array_literal2680); 5766 literal145=literal(); 5767 state._fsp--; 5768 5769 stream_literal.add(literal145.getTree()); 5770 } 5771 break; 5772 5773 default : 5774 break loop23; 5775 } 5776 } 5777 5778 } 5779 break; 5780 case 2 : 5781 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:667:44: 5782 { 5783 } 5784 break; 5785 5786 } 5787 5788 CLOSE_BRACE146=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_array_literal2688); 5789 stream_CLOSE_BRACE.add(CLOSE_BRACE146); 5790 5791 // AST REWRITE 5792 // elements: literal 5793 // token labels: 5794 // rule labels: retval 5795 // token list labels: 5796 // rule list labels: 5797 // wildcard labels: 5798 retval.tree = root_0; 5799 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 5800 5801 root_0 = (CommonTree)adaptor.nil(); 5802 // 668:5: -> ^( I_ENCODED_ARRAY[$start, \"I_ENCODED_ARRAY\"] ( literal )* ) 5803 { 5804 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:668:8: ^( I_ENCODED_ARRAY[$start, \"I_ENCODED_ARRAY\"] ( literal )* ) 5805 { 5806 CommonTree root_1 = (CommonTree)adaptor.nil(); 5807 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ENCODED_ARRAY, (retval.start), "I_ENCODED_ARRAY"), root_1); 5808 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:668:53: ( literal )* 5809 while ( stream_literal.hasNext() ) { 5810 adaptor.addChild(root_1, stream_literal.nextTree()); 5811 } 5812 stream_literal.reset(); 5813 5814 adaptor.addChild(root_0, root_1); 5815 } 5816 5817 } 5818 5819 5820 retval.tree = root_0; 5821 5822 } 5823 5824 retval.stop = input.LT(-1); 5825 5826 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 5827 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 5828 5829 } 5830 catch (RecognitionException re) { 5831 reportError(re); 5832 recover(input,re); 5833 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 5834 } 5835 finally { 5836 // do for sure before leaving 5837 } 5838 return retval; 5839 } 5840 // $ANTLR end "array_literal" 5841 5842 5843 public static class annotation_element_return extends ParserRuleReturnScope { 5844 CommonTree tree; 5845 @Override 5846 public CommonTree getTree() { return tree; } 5847 }; 5848 5849 5850 // $ANTLR start "annotation_element" 5851 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:670:1: annotation_element : simple_name EQUAL literal -> ^( I_ANNOTATION_ELEMENT[$start, \"I_ANNOTATION_ELEMENT\"] simple_name literal ) ; 5852 public final smaliParser.annotation_element_return annotation_element() throws RecognitionException { 5853 smaliParser.annotation_element_return retval = new smaliParser.annotation_element_return(); 5854 retval.start = input.LT(1); 5855 5856 CommonTree root_0 = null; 5857 5858 Token EQUAL148=null; 5859 ParserRuleReturnScope simple_name147 =null; 5860 ParserRuleReturnScope literal149 =null; 5861 5862 CommonTree EQUAL148_tree=null; 5863 RewriteRuleTokenStream stream_EQUAL=new RewriteRuleTokenStream(adaptor,"token EQUAL"); 5864 RewriteRuleSubtreeStream stream_simple_name=new RewriteRuleSubtreeStream(adaptor,"rule simple_name"); 5865 RewriteRuleSubtreeStream stream_literal=new RewriteRuleSubtreeStream(adaptor,"rule literal"); 5866 5867 try { 5868 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:671:3: ( simple_name EQUAL literal -> ^( I_ANNOTATION_ELEMENT[$start, \"I_ANNOTATION_ELEMENT\"] simple_name literal ) ) 5869 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:671:5: simple_name EQUAL literal 5870 { 5871 pushFollow(FOLLOW_simple_name_in_annotation_element2712); 5872 simple_name147=simple_name(); 5873 state._fsp--; 5874 5875 stream_simple_name.add(simple_name147.getTree()); 5876 EQUAL148=(Token)match(input,EQUAL,FOLLOW_EQUAL_in_annotation_element2714); 5877 stream_EQUAL.add(EQUAL148); 5878 5879 pushFollow(FOLLOW_literal_in_annotation_element2716); 5880 literal149=literal(); 5881 state._fsp--; 5882 5883 stream_literal.add(literal149.getTree()); 5884 // AST REWRITE 5885 // elements: literal, simple_name 5886 // token labels: 5887 // rule labels: retval 5888 // token list labels: 5889 // rule list labels: 5890 // wildcard labels: 5891 retval.tree = root_0; 5892 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 5893 5894 root_0 = (CommonTree)adaptor.nil(); 5895 // 672:5: -> ^( I_ANNOTATION_ELEMENT[$start, \"I_ANNOTATION_ELEMENT\"] simple_name literal ) 5896 { 5897 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:672:8: ^( I_ANNOTATION_ELEMENT[$start, \"I_ANNOTATION_ELEMENT\"] simple_name literal ) 5898 { 5899 CommonTree root_1 = (CommonTree)adaptor.nil(); 5900 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ANNOTATION_ELEMENT, (retval.start), "I_ANNOTATION_ELEMENT"), root_1); 5901 adaptor.addChild(root_1, stream_simple_name.nextTree()); 5902 adaptor.addChild(root_1, stream_literal.nextTree()); 5903 adaptor.addChild(root_0, root_1); 5904 } 5905 5906 } 5907 5908 5909 retval.tree = root_0; 5910 5911 } 5912 5913 retval.stop = input.LT(-1); 5914 5915 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 5916 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 5917 5918 } 5919 catch (RecognitionException re) { 5920 reportError(re); 5921 recover(input,re); 5922 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 5923 } 5924 finally { 5925 // do for sure before leaving 5926 } 5927 return retval; 5928 } 5929 // $ANTLR end "annotation_element" 5930 5931 5932 public static class annotation_return extends ParserRuleReturnScope { 5933 CommonTree tree; 5934 @Override 5935 public CommonTree getTree() { return tree; } 5936 }; 5937 5938 5939 // $ANTLR start "annotation" 5940 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:674: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 )* ) ) ; 5941 public final smaliParser.annotation_return annotation() throws RecognitionException { 5942 smaliParser.annotation_return retval = new smaliParser.annotation_return(); 5943 retval.start = input.LT(1); 5944 5945 CommonTree root_0 = null; 5946 5947 Token ANNOTATION_DIRECTIVE150=null; 5948 Token ANNOTATION_VISIBILITY151=null; 5949 Token CLASS_DESCRIPTOR152=null; 5950 Token END_ANNOTATION_DIRECTIVE154=null; 5951 ParserRuleReturnScope annotation_element153 =null; 5952 5953 CommonTree ANNOTATION_DIRECTIVE150_tree=null; 5954 CommonTree ANNOTATION_VISIBILITY151_tree=null; 5955 CommonTree CLASS_DESCRIPTOR152_tree=null; 5956 CommonTree END_ANNOTATION_DIRECTIVE154_tree=null; 5957 RewriteRuleTokenStream stream_ANNOTATION_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token ANNOTATION_DIRECTIVE"); 5958 RewriteRuleTokenStream stream_END_ANNOTATION_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_ANNOTATION_DIRECTIVE"); 5959 RewriteRuleTokenStream stream_ANNOTATION_VISIBILITY=new RewriteRuleTokenStream(adaptor,"token ANNOTATION_VISIBILITY"); 5960 RewriteRuleTokenStream stream_CLASS_DESCRIPTOR=new RewriteRuleTokenStream(adaptor,"token CLASS_DESCRIPTOR"); 5961 RewriteRuleSubtreeStream stream_annotation_element=new RewriteRuleSubtreeStream(adaptor,"rule annotation_element"); 5962 5963 try { 5964 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:675: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 )* ) ) ) 5965 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:675:5: ANNOTATION_DIRECTIVE ANNOTATION_VISIBILITY CLASS_DESCRIPTOR ( annotation_element )* END_ANNOTATION_DIRECTIVE 5966 { 5967 ANNOTATION_DIRECTIVE150=(Token)match(input,ANNOTATION_DIRECTIVE,FOLLOW_ANNOTATION_DIRECTIVE_in_annotation2741); 5968 stream_ANNOTATION_DIRECTIVE.add(ANNOTATION_DIRECTIVE150); 5969 5970 ANNOTATION_VISIBILITY151=(Token)match(input,ANNOTATION_VISIBILITY,FOLLOW_ANNOTATION_VISIBILITY_in_annotation2743); 5971 stream_ANNOTATION_VISIBILITY.add(ANNOTATION_VISIBILITY151); 5972 5973 CLASS_DESCRIPTOR152=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_annotation2745); 5974 stream_CLASS_DESCRIPTOR.add(CLASS_DESCRIPTOR152); 5975 5976 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:676:5: ( annotation_element )* 5977 loop25: 5978 while (true) { 5979 int alt25=2; 5980 int LA25_0 = input.LA(1); 5981 if ( (LA25_0==ACCESS_SPEC||LA25_0==ANNOTATION_VISIBILITY||LA25_0==BOOL_LITERAL||LA25_0==DOUBLE_LITERAL_OR_ID||LA25_0==FLOAT_LITERAL_OR_ID||(LA25_0 >= INSTRUCTION_FORMAT10t && LA25_0 <= INSTRUCTION_FORMAT10x_ODEX)||LA25_0==INSTRUCTION_FORMAT11x||LA25_0==INSTRUCTION_FORMAT12x_OR_ID||(LA25_0 >= INSTRUCTION_FORMAT21c_FIELD && LA25_0 <= INSTRUCTION_FORMAT21c_TYPE)||LA25_0==INSTRUCTION_FORMAT21t||(LA25_0 >= INSTRUCTION_FORMAT22c_FIELD && LA25_0 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA25_0 >= INSTRUCTION_FORMAT22s_OR_ID && LA25_0 <= INSTRUCTION_FORMAT22t)||LA25_0==INSTRUCTION_FORMAT23x||(LA25_0 >= INSTRUCTION_FORMAT31i_OR_ID && LA25_0 <= INSTRUCTION_FORMAT31t)||(LA25_0 >= INSTRUCTION_FORMAT35c_METHOD && LA25_0 <= INSTRUCTION_FORMAT35ms_METHOD)||LA25_0==INSTRUCTION_FORMAT51l||(LA25_0 >= NEGATIVE_INTEGER_LITERAL && LA25_0 <= NULL_LITERAL)||LA25_0==PARAM_LIST_OR_ID_START||(LA25_0 >= POSITIVE_INTEGER_LITERAL && LA25_0 <= PRIMITIVE_TYPE)||LA25_0==REGISTER||LA25_0==SIMPLE_NAME||(LA25_0 >= VERIFICATION_ERROR_TYPE && LA25_0 <= VOID_TYPE)) ) { 5982 alt25=1; 5983 } 5984 5985 switch (alt25) { 5986 case 1 : 5987 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:676:5: annotation_element 5988 { 5989 pushFollow(FOLLOW_annotation_element_in_annotation2751); 5990 annotation_element153=annotation_element(); 5991 state._fsp--; 5992 5993 stream_annotation_element.add(annotation_element153.getTree()); 5994 } 5995 break; 5996 5997 default : 5998 break loop25; 5999 } 6000 } 6001 6002 END_ANNOTATION_DIRECTIVE154=(Token)match(input,END_ANNOTATION_DIRECTIVE,FOLLOW_END_ANNOTATION_DIRECTIVE_in_annotation2754); 6003 stream_END_ANNOTATION_DIRECTIVE.add(END_ANNOTATION_DIRECTIVE154); 6004 6005 // AST REWRITE 6006 // elements: CLASS_DESCRIPTOR, ANNOTATION_VISIBILITY, annotation_element 6007 // token labels: 6008 // rule labels: retval 6009 // token list labels: 6010 // rule list labels: 6011 // wildcard labels: 6012 retval.tree = root_0; 6013 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 6014 6015 root_0 = (CommonTree)adaptor.nil(); 6016 // 677:5: -> ^( I_ANNOTATION[$start, \"I_ANNOTATION\"] ANNOTATION_VISIBILITY ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) ) 6017 { 6018 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:677:8: ^( I_ANNOTATION[$start, \"I_ANNOTATION\"] ANNOTATION_VISIBILITY ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) ) 6019 { 6020 CommonTree root_1 = (CommonTree)adaptor.nil(); 6021 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ANNOTATION, (retval.start), "I_ANNOTATION"), root_1); 6022 adaptor.addChild(root_1, stream_ANNOTATION_VISIBILITY.nextNode()); 6023 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:677:69: ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) 6024 { 6025 CommonTree root_2 = (CommonTree)adaptor.nil(); 6026 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_SUBANNOTATION, (retval.start), "I_SUBANNOTATION"), root_2); 6027 adaptor.addChild(root_2, stream_CLASS_DESCRIPTOR.nextNode()); 6028 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:677:131: ( annotation_element )* 6029 while ( stream_annotation_element.hasNext() ) { 6030 adaptor.addChild(root_2, stream_annotation_element.nextTree()); 6031 } 6032 stream_annotation_element.reset(); 6033 6034 adaptor.addChild(root_1, root_2); 6035 } 6036 6037 adaptor.addChild(root_0, root_1); 6038 } 6039 6040 } 6041 6042 6043 retval.tree = root_0; 6044 6045 } 6046 6047 retval.stop = input.LT(-1); 6048 6049 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 6050 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 6051 6052 } 6053 catch (RecognitionException re) { 6054 reportError(re); 6055 recover(input,re); 6056 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 6057 } 6058 finally { 6059 // do for sure before leaving 6060 } 6061 return retval; 6062 } 6063 // $ANTLR end "annotation" 6064 6065 6066 public static class subannotation_return extends ParserRuleReturnScope { 6067 CommonTree tree; 6068 @Override 6069 public CommonTree getTree() { return tree; } 6070 }; 6071 6072 6073 // $ANTLR start "subannotation" 6074 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:679:1: subannotation : SUBANNOTATION_DIRECTIVE CLASS_DESCRIPTOR ( annotation_element )* END_SUBANNOTATION_DIRECTIVE -> ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) ; 6075 public final smaliParser.subannotation_return subannotation() throws RecognitionException { 6076 smaliParser.subannotation_return retval = new smaliParser.subannotation_return(); 6077 retval.start = input.LT(1); 6078 6079 CommonTree root_0 = null; 6080 6081 Token SUBANNOTATION_DIRECTIVE155=null; 6082 Token CLASS_DESCRIPTOR156=null; 6083 Token END_SUBANNOTATION_DIRECTIVE158=null; 6084 ParserRuleReturnScope annotation_element157 =null; 6085 6086 CommonTree SUBANNOTATION_DIRECTIVE155_tree=null; 6087 CommonTree CLASS_DESCRIPTOR156_tree=null; 6088 CommonTree END_SUBANNOTATION_DIRECTIVE158_tree=null; 6089 RewriteRuleTokenStream stream_SUBANNOTATION_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token SUBANNOTATION_DIRECTIVE"); 6090 RewriteRuleTokenStream stream_END_SUBANNOTATION_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_SUBANNOTATION_DIRECTIVE"); 6091 RewriteRuleTokenStream stream_CLASS_DESCRIPTOR=new RewriteRuleTokenStream(adaptor,"token CLASS_DESCRIPTOR"); 6092 RewriteRuleSubtreeStream stream_annotation_element=new RewriteRuleSubtreeStream(adaptor,"rule annotation_element"); 6093 6094 try { 6095 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:680:3: ( SUBANNOTATION_DIRECTIVE CLASS_DESCRIPTOR ( annotation_element )* END_SUBANNOTATION_DIRECTIVE -> ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) ) 6096 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:680:5: SUBANNOTATION_DIRECTIVE CLASS_DESCRIPTOR ( annotation_element )* END_SUBANNOTATION_DIRECTIVE 6097 { 6098 SUBANNOTATION_DIRECTIVE155=(Token)match(input,SUBANNOTATION_DIRECTIVE,FOLLOW_SUBANNOTATION_DIRECTIVE_in_subannotation2787); 6099 stream_SUBANNOTATION_DIRECTIVE.add(SUBANNOTATION_DIRECTIVE155); 6100 6101 CLASS_DESCRIPTOR156=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_subannotation2789); 6102 stream_CLASS_DESCRIPTOR.add(CLASS_DESCRIPTOR156); 6103 6104 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:680:46: ( annotation_element )* 6105 loop26: 6106 while (true) { 6107 int alt26=2; 6108 int LA26_0 = input.LA(1); 6109 if ( (LA26_0==ACCESS_SPEC||LA26_0==ANNOTATION_VISIBILITY||LA26_0==BOOL_LITERAL||LA26_0==DOUBLE_LITERAL_OR_ID||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_FORMAT51l||(LA26_0 >= NEGATIVE_INTEGER_LITERAL && LA26_0 <= NULL_LITERAL)||LA26_0==PARAM_LIST_OR_ID_START||(LA26_0 >= POSITIVE_INTEGER_LITERAL && LA26_0 <= PRIMITIVE_TYPE)||LA26_0==REGISTER||LA26_0==SIMPLE_NAME||(LA26_0 >= VERIFICATION_ERROR_TYPE && LA26_0 <= VOID_TYPE)) ) { 6110 alt26=1; 6111 } 6112 6113 switch (alt26) { 6114 case 1 : 6115 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:680:46: annotation_element 6116 { 6117 pushFollow(FOLLOW_annotation_element_in_subannotation2791); 6118 annotation_element157=annotation_element(); 6119 state._fsp--; 6120 6121 stream_annotation_element.add(annotation_element157.getTree()); 6122 } 6123 break; 6124 6125 default : 6126 break loop26; 6127 } 6128 } 6129 6130 END_SUBANNOTATION_DIRECTIVE158=(Token)match(input,END_SUBANNOTATION_DIRECTIVE,FOLLOW_END_SUBANNOTATION_DIRECTIVE_in_subannotation2794); 6131 stream_END_SUBANNOTATION_DIRECTIVE.add(END_SUBANNOTATION_DIRECTIVE158); 6132 6133 // AST REWRITE 6134 // elements: annotation_element, CLASS_DESCRIPTOR 6135 // token labels: 6136 // rule labels: retval 6137 // token list labels: 6138 // rule list labels: 6139 // wildcard labels: 6140 retval.tree = root_0; 6141 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 6142 6143 root_0 = (CommonTree)adaptor.nil(); 6144 // 681:5: -> ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) 6145 { 6146 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:681:8: ^( I_SUBANNOTATION[$start, \"I_SUBANNOTATION\"] CLASS_DESCRIPTOR ( annotation_element )* ) 6147 { 6148 CommonTree root_1 = (CommonTree)adaptor.nil(); 6149 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_SUBANNOTATION, (retval.start), "I_SUBANNOTATION"), root_1); 6150 adaptor.addChild(root_1, stream_CLASS_DESCRIPTOR.nextNode()); 6151 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:681:70: ( annotation_element )* 6152 while ( stream_annotation_element.hasNext() ) { 6153 adaptor.addChild(root_1, stream_annotation_element.nextTree()); 6154 } 6155 stream_annotation_element.reset(); 6156 6157 adaptor.addChild(root_0, root_1); 6158 } 6159 6160 } 6161 6162 6163 retval.tree = root_0; 6164 6165 } 6166 6167 retval.stop = input.LT(-1); 6168 6169 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 6170 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 6171 6172 } 6173 catch (RecognitionException re) { 6174 reportError(re); 6175 recover(input,re); 6176 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 6177 } 6178 finally { 6179 // do for sure before leaving 6180 } 6181 return retval; 6182 } 6183 // $ANTLR end "subannotation" 6184 6185 6186 public static class enum_literal_return extends ParserRuleReturnScope { 6187 CommonTree tree; 6188 @Override 6189 public CommonTree getTree() { return tree; } 6190 }; 6191 6192 6193 // $ANTLR start "enum_literal" 6194 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:683:1: enum_literal : ENUM_DIRECTIVE reference_type_descriptor ARROW simple_name COLON reference_type_descriptor -> ^( I_ENCODED_ENUM reference_type_descriptor simple_name reference_type_descriptor ) ; 6195 public final smaliParser.enum_literal_return enum_literal() throws RecognitionException { 6196 smaliParser.enum_literal_return retval = new smaliParser.enum_literal_return(); 6197 retval.start = input.LT(1); 6198 6199 CommonTree root_0 = null; 6200 6201 Token ENUM_DIRECTIVE159=null; 6202 Token ARROW161=null; 6203 Token COLON163=null; 6204 ParserRuleReturnScope reference_type_descriptor160 =null; 6205 ParserRuleReturnScope simple_name162 =null; 6206 ParserRuleReturnScope reference_type_descriptor164 =null; 6207 6208 CommonTree ENUM_DIRECTIVE159_tree=null; 6209 CommonTree ARROW161_tree=null; 6210 CommonTree COLON163_tree=null; 6211 RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON"); 6212 RewriteRuleTokenStream stream_ENUM_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token ENUM_DIRECTIVE"); 6213 RewriteRuleTokenStream stream_ARROW=new RewriteRuleTokenStream(adaptor,"token ARROW"); 6214 RewriteRuleSubtreeStream stream_reference_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule reference_type_descriptor"); 6215 RewriteRuleSubtreeStream stream_simple_name=new RewriteRuleSubtreeStream(adaptor,"rule simple_name"); 6216 6217 try { 6218 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:684:3: ( ENUM_DIRECTIVE reference_type_descriptor ARROW simple_name COLON reference_type_descriptor -> ^( I_ENCODED_ENUM reference_type_descriptor simple_name reference_type_descriptor ) ) 6219 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:684:5: ENUM_DIRECTIVE reference_type_descriptor ARROW simple_name COLON reference_type_descriptor 6220 { 6221 ENUM_DIRECTIVE159=(Token)match(input,ENUM_DIRECTIVE,FOLLOW_ENUM_DIRECTIVE_in_enum_literal2820); 6222 stream_ENUM_DIRECTIVE.add(ENUM_DIRECTIVE159); 6223 6224 pushFollow(FOLLOW_reference_type_descriptor_in_enum_literal2822); 6225 reference_type_descriptor160=reference_type_descriptor(); 6226 state._fsp--; 6227 6228 stream_reference_type_descriptor.add(reference_type_descriptor160.getTree()); 6229 ARROW161=(Token)match(input,ARROW,FOLLOW_ARROW_in_enum_literal2824); 6230 stream_ARROW.add(ARROW161); 6231 6232 pushFollow(FOLLOW_simple_name_in_enum_literal2826); 6233 simple_name162=simple_name(); 6234 state._fsp--; 6235 6236 stream_simple_name.add(simple_name162.getTree()); 6237 COLON163=(Token)match(input,COLON,FOLLOW_COLON_in_enum_literal2828); 6238 stream_COLON.add(COLON163); 6239 6240 pushFollow(FOLLOW_reference_type_descriptor_in_enum_literal2830); 6241 reference_type_descriptor164=reference_type_descriptor(); 6242 state._fsp--; 6243 6244 stream_reference_type_descriptor.add(reference_type_descriptor164.getTree()); 6245 // AST REWRITE 6246 // elements: simple_name, reference_type_descriptor, reference_type_descriptor 6247 // token labels: 6248 // rule labels: retval 6249 // token list labels: 6250 // rule list labels: 6251 // wildcard labels: 6252 retval.tree = root_0; 6253 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 6254 6255 root_0 = (CommonTree)adaptor.nil(); 6256 // 685:3: -> ^( I_ENCODED_ENUM reference_type_descriptor simple_name reference_type_descriptor ) 6257 { 6258 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:685:6: ^( I_ENCODED_ENUM reference_type_descriptor simple_name reference_type_descriptor ) 6259 { 6260 CommonTree root_1 = (CommonTree)adaptor.nil(); 6261 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ENCODED_ENUM, "I_ENCODED_ENUM"), root_1); 6262 adaptor.addChild(root_1, stream_reference_type_descriptor.nextTree()); 6263 adaptor.addChild(root_1, stream_simple_name.nextTree()); 6264 adaptor.addChild(root_1, stream_reference_type_descriptor.nextTree()); 6265 adaptor.addChild(root_0, root_1); 6266 } 6267 6268 } 6269 6270 6271 retval.tree = root_0; 6272 6273 } 6274 6275 retval.stop = input.LT(-1); 6276 6277 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 6278 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 6279 6280 } 6281 catch (RecognitionException re) { 6282 reportError(re); 6283 recover(input,re); 6284 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 6285 } 6286 finally { 6287 // do for sure before leaving 6288 } 6289 return retval; 6290 } 6291 // $ANTLR end "enum_literal" 6292 6293 6294 public static class type_field_method_literal_return extends ParserRuleReturnScope { 6295 CommonTree tree; 6296 @Override 6297 public CommonTree getTree() { return tree; } 6298 }; 6299 6300 6301 // $ANTLR start "type_field_method_literal" 6302 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:687: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 ); 6303 public final smaliParser.type_field_method_literal_return type_field_method_literal() throws RecognitionException { 6304 smaliParser.type_field_method_literal_return retval = new smaliParser.type_field_method_literal_return(); 6305 retval.start = input.LT(1); 6306 6307 CommonTree root_0 = null; 6308 6309 Token ARROW167=null; 6310 Token COLON169=null; 6311 Token PRIMITIVE_TYPE173=null; 6312 Token VOID_TYPE174=null; 6313 ParserRuleReturnScope reference_type_descriptor165 =null; 6314 ParserRuleReturnScope reference_type_descriptor166 =null; 6315 ParserRuleReturnScope member_name168 =null; 6316 ParserRuleReturnScope nonvoid_type_descriptor170 =null; 6317 ParserRuleReturnScope member_name171 =null; 6318 ParserRuleReturnScope method_prototype172 =null; 6319 6320 CommonTree ARROW167_tree=null; 6321 CommonTree COLON169_tree=null; 6322 CommonTree PRIMITIVE_TYPE173_tree=null; 6323 CommonTree VOID_TYPE174_tree=null; 6324 RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON"); 6325 RewriteRuleTokenStream stream_ARROW=new RewriteRuleTokenStream(adaptor,"token ARROW"); 6326 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 6327 RewriteRuleSubtreeStream stream_method_prototype=new RewriteRuleSubtreeStream(adaptor,"rule method_prototype"); 6328 RewriteRuleSubtreeStream stream_reference_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule reference_type_descriptor"); 6329 RewriteRuleSubtreeStream stream_member_name=new RewriteRuleSubtreeStream(adaptor,"rule member_name"); 6330 6331 try { 6332 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:688: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 ) 6333 int alt29=4; 6334 switch ( input.LA(1) ) { 6335 case ARRAY_DESCRIPTOR: 6336 case CLASS_DESCRIPTOR: 6337 { 6338 int LA29_1 = input.LA(2); 6339 if ( (LA29_1==EOF||(LA29_1 >= ACCESS_SPEC && LA29_1 <= ANNOTATION_VISIBILITY)||LA29_1==BOOL_LITERAL||(LA29_1 >= CLASS_DIRECTIVE && LA29_1 <= CLOSE_BRACE)||LA29_1==COMMA||(LA29_1 >= DOUBLE_LITERAL_OR_ID && LA29_1 <= END_ANNOTATION_DIRECTIVE)||LA29_1==END_FIELD_DIRECTIVE||LA29_1==END_SUBANNOTATION_DIRECTIVE||LA29_1==FIELD_DIRECTIVE||(LA29_1 >= FLOAT_LITERAL_OR_ID && LA29_1 <= IMPLEMENTS_DIRECTIVE)||(LA29_1 >= INSTRUCTION_FORMAT10t && LA29_1 <= INSTRUCTION_FORMAT10x_ODEX)||LA29_1==INSTRUCTION_FORMAT11x||LA29_1==INSTRUCTION_FORMAT12x_OR_ID||(LA29_1 >= INSTRUCTION_FORMAT21c_FIELD && LA29_1 <= INSTRUCTION_FORMAT21c_TYPE)||LA29_1==INSTRUCTION_FORMAT21t||(LA29_1 >= INSTRUCTION_FORMAT22c_FIELD && LA29_1 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA29_1 >= INSTRUCTION_FORMAT22s_OR_ID && LA29_1 <= INSTRUCTION_FORMAT22t)||LA29_1==INSTRUCTION_FORMAT23x||(LA29_1 >= INSTRUCTION_FORMAT31i_OR_ID && LA29_1 <= INSTRUCTION_FORMAT31t)||(LA29_1 >= INSTRUCTION_FORMAT35c_METHOD && LA29_1 <= INSTRUCTION_FORMAT35ms_METHOD)||LA29_1==INSTRUCTION_FORMAT51l||(LA29_1 >= METHOD_DIRECTIVE && LA29_1 <= NULL_LITERAL)||LA29_1==PARAM_LIST_OR_ID_START||(LA29_1 >= POSITIVE_INTEGER_LITERAL && LA29_1 <= PRIMITIVE_TYPE)||LA29_1==REGISTER||(LA29_1 >= SIMPLE_NAME && LA29_1 <= SOURCE_DIRECTIVE)||(LA29_1 >= SUPER_DIRECTIVE && LA29_1 <= VOID_TYPE)) ) { 6340 alt29=1; 6341 } 6342 else if ( (LA29_1==ARROW) ) { 6343 alt29=2; 6344 } 6345 6346 else { 6347 int nvaeMark = input.mark(); 6348 try { 6349 input.consume(); 6350 NoViableAltException nvae = 6351 new NoViableAltException("", 29, 1, input); 6352 throw nvae; 6353 } finally { 6354 input.rewind(nvaeMark); 6355 } 6356 } 6357 6358 } 6359 break; 6360 case ACCESS_SPEC: 6361 case ANNOTATION_VISIBILITY: 6362 case BOOL_LITERAL: 6363 case DOUBLE_LITERAL_OR_ID: 6364 case FLOAT_LITERAL_OR_ID: 6365 case INSTRUCTION_FORMAT10t: 6366 case INSTRUCTION_FORMAT10x: 6367 case INSTRUCTION_FORMAT10x_ODEX: 6368 case INSTRUCTION_FORMAT11x: 6369 case INSTRUCTION_FORMAT12x_OR_ID: 6370 case INSTRUCTION_FORMAT21c_FIELD: 6371 case INSTRUCTION_FORMAT21c_FIELD_ODEX: 6372 case INSTRUCTION_FORMAT21c_STRING: 6373 case INSTRUCTION_FORMAT21c_TYPE: 6374 case INSTRUCTION_FORMAT21t: 6375 case INSTRUCTION_FORMAT22c_FIELD: 6376 case INSTRUCTION_FORMAT22c_FIELD_ODEX: 6377 case INSTRUCTION_FORMAT22c_TYPE: 6378 case INSTRUCTION_FORMAT22cs_FIELD: 6379 case INSTRUCTION_FORMAT22s_OR_ID: 6380 case INSTRUCTION_FORMAT22t: 6381 case INSTRUCTION_FORMAT23x: 6382 case INSTRUCTION_FORMAT31i_OR_ID: 6383 case INSTRUCTION_FORMAT31t: 6384 case INSTRUCTION_FORMAT35c_METHOD: 6385 case INSTRUCTION_FORMAT35c_METHOD_ODEX: 6386 case INSTRUCTION_FORMAT35c_TYPE: 6387 case INSTRUCTION_FORMAT35mi_METHOD: 6388 case INSTRUCTION_FORMAT35ms_METHOD: 6389 case INSTRUCTION_FORMAT51l: 6390 case MEMBER_NAME: 6391 case NEGATIVE_INTEGER_LITERAL: 6392 case NULL_LITERAL: 6393 case PARAM_LIST_OR_ID_START: 6394 case POSITIVE_INTEGER_LITERAL: 6395 case REGISTER: 6396 case SIMPLE_NAME: 6397 case VERIFICATION_ERROR_TYPE: 6398 { 6399 alt29=2; 6400 } 6401 break; 6402 case PRIMITIVE_TYPE: 6403 { 6404 int LA29_3 = input.LA(2); 6405 if ( (LA29_3==COLON||LA29_3==OPEN_PAREN) ) { 6406 alt29=2; 6407 } 6408 else if ( (LA29_3==EOF||(LA29_3 >= ACCESS_SPEC && LA29_3 <= ANNOTATION_VISIBILITY)||LA29_3==BOOL_LITERAL||(LA29_3 >= CLASS_DIRECTIVE && LA29_3 <= CLOSE_BRACE)||LA29_3==COMMA||(LA29_3 >= DOUBLE_LITERAL_OR_ID && LA29_3 <= END_ANNOTATION_DIRECTIVE)||LA29_3==END_FIELD_DIRECTIVE||LA29_3==END_SUBANNOTATION_DIRECTIVE||LA29_3==FIELD_DIRECTIVE||(LA29_3 >= FLOAT_LITERAL_OR_ID && LA29_3 <= IMPLEMENTS_DIRECTIVE)||(LA29_3 >= INSTRUCTION_FORMAT10t && LA29_3 <= INSTRUCTION_FORMAT10x_ODEX)||LA29_3==INSTRUCTION_FORMAT11x||LA29_3==INSTRUCTION_FORMAT12x_OR_ID||(LA29_3 >= INSTRUCTION_FORMAT21c_FIELD && LA29_3 <= INSTRUCTION_FORMAT21c_TYPE)||LA29_3==INSTRUCTION_FORMAT21t||(LA29_3 >= INSTRUCTION_FORMAT22c_FIELD && LA29_3 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA29_3 >= INSTRUCTION_FORMAT22s_OR_ID && LA29_3 <= INSTRUCTION_FORMAT22t)||LA29_3==INSTRUCTION_FORMAT23x||(LA29_3 >= INSTRUCTION_FORMAT31i_OR_ID && LA29_3 <= INSTRUCTION_FORMAT31t)||(LA29_3 >= INSTRUCTION_FORMAT35c_METHOD && LA29_3 <= INSTRUCTION_FORMAT35ms_METHOD)||LA29_3==INSTRUCTION_FORMAT51l||(LA29_3 >= METHOD_DIRECTIVE && LA29_3 <= NULL_LITERAL)||LA29_3==PARAM_LIST_OR_ID_START||(LA29_3 >= POSITIVE_INTEGER_LITERAL && LA29_3 <= PRIMITIVE_TYPE)||LA29_3==REGISTER||(LA29_3 >= SIMPLE_NAME && LA29_3 <= SOURCE_DIRECTIVE)||(LA29_3 >= SUPER_DIRECTIVE && LA29_3 <= VOID_TYPE)) ) { 6409 alt29=3; 6410 } 6411 6412 else { 6413 int nvaeMark = input.mark(); 6414 try { 6415 input.consume(); 6416 NoViableAltException nvae = 6417 new NoViableAltException("", 29, 3, input); 6418 throw nvae; 6419 } finally { 6420 input.rewind(nvaeMark); 6421 } 6422 } 6423 6424 } 6425 break; 6426 case VOID_TYPE: 6427 { 6428 int LA29_4 = input.LA(2); 6429 if ( (LA29_4==COLON||LA29_4==OPEN_PAREN) ) { 6430 alt29=2; 6431 } 6432 else if ( (LA29_4==EOF||(LA29_4 >= ACCESS_SPEC && LA29_4 <= ANNOTATION_VISIBILITY)||LA29_4==BOOL_LITERAL||(LA29_4 >= CLASS_DIRECTIVE && LA29_4 <= CLOSE_BRACE)||LA29_4==COMMA||(LA29_4 >= DOUBLE_LITERAL_OR_ID && LA29_4 <= END_ANNOTATION_DIRECTIVE)||LA29_4==END_FIELD_DIRECTIVE||LA29_4==END_SUBANNOTATION_DIRECTIVE||LA29_4==FIELD_DIRECTIVE||(LA29_4 >= FLOAT_LITERAL_OR_ID && LA29_4 <= IMPLEMENTS_DIRECTIVE)||(LA29_4 >= INSTRUCTION_FORMAT10t && LA29_4 <= INSTRUCTION_FORMAT10x_ODEX)||LA29_4==INSTRUCTION_FORMAT11x||LA29_4==INSTRUCTION_FORMAT12x_OR_ID||(LA29_4 >= INSTRUCTION_FORMAT21c_FIELD && LA29_4 <= INSTRUCTION_FORMAT21c_TYPE)||LA29_4==INSTRUCTION_FORMAT21t||(LA29_4 >= INSTRUCTION_FORMAT22c_FIELD && LA29_4 <= INSTRUCTION_FORMAT22cs_FIELD)||(LA29_4 >= INSTRUCTION_FORMAT22s_OR_ID && LA29_4 <= INSTRUCTION_FORMAT22t)||LA29_4==INSTRUCTION_FORMAT23x||(LA29_4 >= INSTRUCTION_FORMAT31i_OR_ID && LA29_4 <= INSTRUCTION_FORMAT31t)||(LA29_4 >= INSTRUCTION_FORMAT35c_METHOD && LA29_4 <= INSTRUCTION_FORMAT35ms_METHOD)||LA29_4==INSTRUCTION_FORMAT51l||(LA29_4 >= METHOD_DIRECTIVE && LA29_4 <= NULL_LITERAL)||LA29_4==PARAM_LIST_OR_ID_START||(LA29_4 >= POSITIVE_INTEGER_LITERAL && LA29_4 <= PRIMITIVE_TYPE)||LA29_4==REGISTER||(LA29_4 >= SIMPLE_NAME && LA29_4 <= SOURCE_DIRECTIVE)||(LA29_4 >= SUPER_DIRECTIVE && LA29_4 <= VOID_TYPE)) ) { 6433 alt29=4; 6434 } 6435 6436 else { 6437 int nvaeMark = input.mark(); 6438 try { 6439 input.consume(); 6440 NoViableAltException nvae = 6441 new NoViableAltException("", 29, 4, input); 6442 throw nvae; 6443 } finally { 6444 input.rewind(nvaeMark); 6445 } 6446 } 6447 6448 } 6449 break; 6450 default: 6451 NoViableAltException nvae = 6452 new NoViableAltException("", 29, 0, input); 6453 throw nvae; 6454 } 6455 switch (alt29) { 6456 case 1 : 6457 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:688:5: reference_type_descriptor 6458 { 6459 root_0 = (CommonTree)adaptor.nil(); 6460 6461 6462 pushFollow(FOLLOW_reference_type_descriptor_in_type_field_method_literal2854); 6463 reference_type_descriptor165=reference_type_descriptor(); 6464 state._fsp--; 6465 6466 adaptor.addChild(root_0, reference_type_descriptor165.getTree()); 6467 6468 } 6469 break; 6470 case 2 : 6471 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:689: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 ) ) ) 6472 { 6473 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:689: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 ) ) ) 6474 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:689: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 ) ) 6475 { 6476 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:689:7: ( reference_type_descriptor ARROW )? 6477 int alt27=2; 6478 int LA27_0 = input.LA(1); 6479 if ( (LA27_0==ARRAY_DESCRIPTOR||LA27_0==CLASS_DESCRIPTOR) ) { 6480 alt27=1; 6481 } 6482 switch (alt27) { 6483 case 1 : 6484 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:689:8: reference_type_descriptor ARROW 6485 { 6486 pushFollow(FOLLOW_reference_type_descriptor_in_type_field_method_literal2863); 6487 reference_type_descriptor166=reference_type_descriptor(); 6488 state._fsp--; 6489 6490 stream_reference_type_descriptor.add(reference_type_descriptor166.getTree()); 6491 ARROW167=(Token)match(input,ARROW,FOLLOW_ARROW_in_type_field_method_literal2865); 6492 stream_ARROW.add(ARROW167); 6493 6494 } 6495 break; 6496 6497 } 6498 6499 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:690: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 ) ) 6500 int alt28=2; 6501 alt28 = dfa28.predict(input); 6502 switch (alt28) { 6503 case 1 : 6504 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:690:9: member_name COLON nonvoid_type_descriptor 6505 { 6506 pushFollow(FOLLOW_member_name_in_type_field_method_literal2877); 6507 member_name168=member_name(); 6508 state._fsp--; 6509 6510 stream_member_name.add(member_name168.getTree()); 6511 COLON169=(Token)match(input,COLON,FOLLOW_COLON_in_type_field_method_literal2879); 6512 stream_COLON.add(COLON169); 6513 6514 pushFollow(FOLLOW_nonvoid_type_descriptor_in_type_field_method_literal2881); 6515 nonvoid_type_descriptor170=nonvoid_type_descriptor(); 6516 state._fsp--; 6517 6518 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor170.getTree()); 6519 // AST REWRITE 6520 // elements: member_name, nonvoid_type_descriptor, reference_type_descriptor 6521 // token labels: 6522 // rule labels: retval 6523 // token list labels: 6524 // rule list labels: 6525 // wildcard labels: 6526 retval.tree = root_0; 6527 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 6528 6529 root_0 = (CommonTree)adaptor.nil(); 6530 // 690:51: -> ^( I_ENCODED_FIELD ( reference_type_descriptor )? member_name nonvoid_type_descriptor ) 6531 { 6532 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:690:54: ^( I_ENCODED_FIELD ( reference_type_descriptor )? member_name nonvoid_type_descriptor ) 6533 { 6534 CommonTree root_1 = (CommonTree)adaptor.nil(); 6535 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ENCODED_FIELD, "I_ENCODED_FIELD"), root_1); 6536 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:690:72: ( reference_type_descriptor )? 6537 if ( stream_reference_type_descriptor.hasNext() ) { 6538 adaptor.addChild(root_1, stream_reference_type_descriptor.nextTree()); 6539 } 6540 stream_reference_type_descriptor.reset(); 6541 6542 adaptor.addChild(root_1, stream_member_name.nextTree()); 6543 adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree()); 6544 adaptor.addChild(root_0, root_1); 6545 } 6546 6547 } 6548 6549 6550 retval.tree = root_0; 6551 6552 } 6553 break; 6554 case 2 : 6555 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:691:9: member_name method_prototype 6556 { 6557 pushFollow(FOLLOW_member_name_in_type_field_method_literal2904); 6558 member_name171=member_name(); 6559 state._fsp--; 6560 6561 stream_member_name.add(member_name171.getTree()); 6562 pushFollow(FOLLOW_method_prototype_in_type_field_method_literal2906); 6563 method_prototype172=method_prototype(); 6564 state._fsp--; 6565 6566 stream_method_prototype.add(method_prototype172.getTree()); 6567 // AST REWRITE 6568 // elements: member_name, method_prototype, reference_type_descriptor 6569 // token labels: 6570 // rule labels: retval 6571 // token list labels: 6572 // rule list labels: 6573 // wildcard labels: 6574 retval.tree = root_0; 6575 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 6576 6577 root_0 = (CommonTree)adaptor.nil(); 6578 // 691:38: -> ^( I_ENCODED_METHOD ( reference_type_descriptor )? member_name method_prototype ) 6579 { 6580 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:691:41: ^( I_ENCODED_METHOD ( reference_type_descriptor )? member_name method_prototype ) 6581 { 6582 CommonTree root_1 = (CommonTree)adaptor.nil(); 6583 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ENCODED_METHOD, "I_ENCODED_METHOD"), root_1); 6584 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:691:60: ( reference_type_descriptor )? 6585 if ( stream_reference_type_descriptor.hasNext() ) { 6586 adaptor.addChild(root_1, stream_reference_type_descriptor.nextTree()); 6587 } 6588 stream_reference_type_descriptor.reset(); 6589 6590 adaptor.addChild(root_1, stream_member_name.nextTree()); 6591 adaptor.addChild(root_1, stream_method_prototype.nextTree()); 6592 adaptor.addChild(root_0, root_1); 6593 } 6594 6595 } 6596 6597 6598 retval.tree = root_0; 6599 6600 } 6601 break; 6602 6603 } 6604 6605 } 6606 6607 } 6608 break; 6609 case 3 : 6610 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:694:5: PRIMITIVE_TYPE 6611 { 6612 root_0 = (CommonTree)adaptor.nil(); 6613 6614 6615 PRIMITIVE_TYPE173=(Token)match(input,PRIMITIVE_TYPE,FOLLOW_PRIMITIVE_TYPE_in_type_field_method_literal2939); 6616 PRIMITIVE_TYPE173_tree = (CommonTree)adaptor.create(PRIMITIVE_TYPE173); 6617 adaptor.addChild(root_0, PRIMITIVE_TYPE173_tree); 6618 6619 } 6620 break; 6621 case 4 : 6622 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:695:5: VOID_TYPE 6623 { 6624 root_0 = (CommonTree)adaptor.nil(); 6625 6626 6627 VOID_TYPE174=(Token)match(input,VOID_TYPE,FOLLOW_VOID_TYPE_in_type_field_method_literal2945); 6628 VOID_TYPE174_tree = (CommonTree)adaptor.create(VOID_TYPE174); 6629 adaptor.addChild(root_0, VOID_TYPE174_tree); 6630 6631 } 6632 break; 6633 6634 } 6635 retval.stop = input.LT(-1); 6636 6637 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 6638 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 6639 6640 } 6641 catch (RecognitionException re) { 6642 reportError(re); 6643 recover(input,re); 6644 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 6645 } 6646 finally { 6647 // do for sure before leaving 6648 } 6649 return retval; 6650 } 6651 // $ANTLR end "type_field_method_literal" 6652 6653 6654 public static class method_reference_return extends ParserRuleReturnScope { 6655 CommonTree tree; 6656 @Override 6657 public CommonTree getTree() { return tree; } 6658 }; 6659 6660 6661 // $ANTLR start "method_reference" 6662 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:697:1: method_reference : ( reference_type_descriptor ARROW )? member_name method_prototype -> ( reference_type_descriptor )? member_name method_prototype ; 6663 public final smaliParser.method_reference_return method_reference() throws RecognitionException { 6664 smaliParser.method_reference_return retval = new smaliParser.method_reference_return(); 6665 retval.start = input.LT(1); 6666 6667 CommonTree root_0 = null; 6668 6669 Token ARROW176=null; 6670 ParserRuleReturnScope reference_type_descriptor175 =null; 6671 ParserRuleReturnScope member_name177 =null; 6672 ParserRuleReturnScope method_prototype178 =null; 6673 6674 CommonTree ARROW176_tree=null; 6675 RewriteRuleTokenStream stream_ARROW=new RewriteRuleTokenStream(adaptor,"token ARROW"); 6676 RewriteRuleSubtreeStream stream_method_prototype=new RewriteRuleSubtreeStream(adaptor,"rule method_prototype"); 6677 RewriteRuleSubtreeStream stream_reference_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule reference_type_descriptor"); 6678 RewriteRuleSubtreeStream stream_member_name=new RewriteRuleSubtreeStream(adaptor,"rule member_name"); 6679 6680 try { 6681 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:698:3: ( ( reference_type_descriptor ARROW )? member_name method_prototype -> ( reference_type_descriptor )? member_name method_prototype ) 6682 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:698:5: ( reference_type_descriptor ARROW )? member_name method_prototype 6683 { 6684 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:698:5: ( reference_type_descriptor ARROW )? 6685 int alt30=2; 6686 int LA30_0 = input.LA(1); 6687 if ( (LA30_0==ARRAY_DESCRIPTOR||LA30_0==CLASS_DESCRIPTOR) ) { 6688 alt30=1; 6689 } 6690 switch (alt30) { 6691 case 1 : 6692 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:698:6: reference_type_descriptor ARROW 6693 { 6694 pushFollow(FOLLOW_reference_type_descriptor_in_method_reference2956); 6695 reference_type_descriptor175=reference_type_descriptor(); 6696 state._fsp--; 6697 6698 stream_reference_type_descriptor.add(reference_type_descriptor175.getTree()); 6699 ARROW176=(Token)match(input,ARROW,FOLLOW_ARROW_in_method_reference2958); 6700 stream_ARROW.add(ARROW176); 6701 6702 } 6703 break; 6704 6705 } 6706 6707 pushFollow(FOLLOW_member_name_in_method_reference2962); 6708 member_name177=member_name(); 6709 state._fsp--; 6710 6711 stream_member_name.add(member_name177.getTree()); 6712 pushFollow(FOLLOW_method_prototype_in_method_reference2964); 6713 method_prototype178=method_prototype(); 6714 state._fsp--; 6715 6716 stream_method_prototype.add(method_prototype178.getTree()); 6717 // AST REWRITE 6718 // elements: member_name, method_prototype, reference_type_descriptor 6719 // token labels: 6720 // rule labels: retval 6721 // token list labels: 6722 // rule list labels: 6723 // wildcard labels: 6724 retval.tree = root_0; 6725 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 6726 6727 root_0 = (CommonTree)adaptor.nil(); 6728 // 699:3: -> ( reference_type_descriptor )? member_name method_prototype 6729 { 6730 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:699:6: ( reference_type_descriptor )? 6731 if ( stream_reference_type_descriptor.hasNext() ) { 6732 adaptor.addChild(root_0, stream_reference_type_descriptor.nextTree()); 6733 } 6734 stream_reference_type_descriptor.reset(); 6735 6736 adaptor.addChild(root_0, stream_member_name.nextTree()); 6737 adaptor.addChild(root_0, stream_method_prototype.nextTree()); 6738 } 6739 6740 6741 retval.tree = root_0; 6742 6743 } 6744 6745 retval.stop = input.LT(-1); 6746 6747 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 6748 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 6749 6750 } 6751 catch (RecognitionException re) { 6752 reportError(re); 6753 recover(input,re); 6754 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 6755 } 6756 finally { 6757 // do for sure before leaving 6758 } 6759 return retval; 6760 } 6761 // $ANTLR end "method_reference" 6762 6763 6764 public static class field_reference_return extends ParserRuleReturnScope { 6765 CommonTree tree; 6766 @Override 6767 public CommonTree getTree() { return tree; } 6768 }; 6769 6770 6771 // $ANTLR start "field_reference" 6772 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:701:1: field_reference : ( reference_type_descriptor ARROW )? member_name COLON nonvoid_type_descriptor -> ( reference_type_descriptor )? member_name nonvoid_type_descriptor ; 6773 public final smaliParser.field_reference_return field_reference() throws RecognitionException { 6774 smaliParser.field_reference_return retval = new smaliParser.field_reference_return(); 6775 retval.start = input.LT(1); 6776 6777 CommonTree root_0 = null; 6778 6779 Token ARROW180=null; 6780 Token COLON182=null; 6781 ParserRuleReturnScope reference_type_descriptor179 =null; 6782 ParserRuleReturnScope member_name181 =null; 6783 ParserRuleReturnScope nonvoid_type_descriptor183 =null; 6784 6785 CommonTree ARROW180_tree=null; 6786 CommonTree COLON182_tree=null; 6787 RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON"); 6788 RewriteRuleTokenStream stream_ARROW=new RewriteRuleTokenStream(adaptor,"token ARROW"); 6789 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 6790 RewriteRuleSubtreeStream stream_reference_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule reference_type_descriptor"); 6791 RewriteRuleSubtreeStream stream_member_name=new RewriteRuleSubtreeStream(adaptor,"rule member_name"); 6792 6793 try { 6794 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:702:3: ( ( reference_type_descriptor ARROW )? member_name COLON nonvoid_type_descriptor -> ( reference_type_descriptor )? member_name nonvoid_type_descriptor ) 6795 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:702:5: ( reference_type_descriptor ARROW )? member_name COLON nonvoid_type_descriptor 6796 { 6797 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:702:5: ( reference_type_descriptor ARROW )? 6798 int alt31=2; 6799 int LA31_0 = input.LA(1); 6800 if ( (LA31_0==ARRAY_DESCRIPTOR||LA31_0==CLASS_DESCRIPTOR) ) { 6801 alt31=1; 6802 } 6803 switch (alt31) { 6804 case 1 : 6805 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:702:6: reference_type_descriptor ARROW 6806 { 6807 pushFollow(FOLLOW_reference_type_descriptor_in_field_reference2986); 6808 reference_type_descriptor179=reference_type_descriptor(); 6809 state._fsp--; 6810 6811 stream_reference_type_descriptor.add(reference_type_descriptor179.getTree()); 6812 ARROW180=(Token)match(input,ARROW,FOLLOW_ARROW_in_field_reference2988); 6813 stream_ARROW.add(ARROW180); 6814 6815 } 6816 break; 6817 6818 } 6819 6820 pushFollow(FOLLOW_member_name_in_field_reference2992); 6821 member_name181=member_name(); 6822 state._fsp--; 6823 6824 stream_member_name.add(member_name181.getTree()); 6825 COLON182=(Token)match(input,COLON,FOLLOW_COLON_in_field_reference2994); 6826 stream_COLON.add(COLON182); 6827 6828 pushFollow(FOLLOW_nonvoid_type_descriptor_in_field_reference2996); 6829 nonvoid_type_descriptor183=nonvoid_type_descriptor(); 6830 state._fsp--; 6831 6832 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor183.getTree()); 6833 // AST REWRITE 6834 // elements: nonvoid_type_descriptor, member_name, reference_type_descriptor 6835 // token labels: 6836 // rule labels: retval 6837 // token list labels: 6838 // rule list labels: 6839 // wildcard labels: 6840 retval.tree = root_0; 6841 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 6842 6843 root_0 = (CommonTree)adaptor.nil(); 6844 // 703:3: -> ( reference_type_descriptor )? member_name nonvoid_type_descriptor 6845 { 6846 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:703:6: ( reference_type_descriptor )? 6847 if ( stream_reference_type_descriptor.hasNext() ) { 6848 adaptor.addChild(root_0, stream_reference_type_descriptor.nextTree()); 6849 } 6850 stream_reference_type_descriptor.reset(); 6851 6852 adaptor.addChild(root_0, stream_member_name.nextTree()); 6853 adaptor.addChild(root_0, stream_nonvoid_type_descriptor.nextTree()); 6854 } 6855 6856 6857 retval.tree = root_0; 6858 6859 } 6860 6861 retval.stop = input.LT(-1); 6862 6863 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 6864 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 6865 6866 } 6867 catch (RecognitionException re) { 6868 reportError(re); 6869 recover(input,re); 6870 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 6871 } 6872 finally { 6873 // do for sure before leaving 6874 } 6875 return retval; 6876 } 6877 // $ANTLR end "field_reference" 6878 6879 6880 public static class label_return extends ParserRuleReturnScope { 6881 CommonTree tree; 6882 @Override 6883 public CommonTree getTree() { return tree; } 6884 }; 6885 6886 6887 // $ANTLR start "label" 6888 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:705:1: label : COLON simple_name -> ^( I_LABEL[$COLON, \"I_LABEL\"] simple_name ) ; 6889 public final smaliParser.label_return label() throws RecognitionException { 6890 smaliParser.label_return retval = new smaliParser.label_return(); 6891 retval.start = input.LT(1); 6892 6893 CommonTree root_0 = null; 6894 6895 Token COLON184=null; 6896 ParserRuleReturnScope simple_name185 =null; 6897 6898 CommonTree COLON184_tree=null; 6899 RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON"); 6900 RewriteRuleSubtreeStream stream_simple_name=new RewriteRuleSubtreeStream(adaptor,"rule simple_name"); 6901 6902 try { 6903 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:706:3: ( COLON simple_name -> ^( I_LABEL[$COLON, \"I_LABEL\"] simple_name ) ) 6904 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:706:5: COLON simple_name 6905 { 6906 COLON184=(Token)match(input,COLON,FOLLOW_COLON_in_label3017); 6907 stream_COLON.add(COLON184); 6908 6909 pushFollow(FOLLOW_simple_name_in_label3019); 6910 simple_name185=simple_name(); 6911 state._fsp--; 6912 6913 stream_simple_name.add(simple_name185.getTree()); 6914 // AST REWRITE 6915 // elements: simple_name 6916 // token labels: 6917 // rule labels: retval 6918 // token list labels: 6919 // rule list labels: 6920 // wildcard labels: 6921 retval.tree = root_0; 6922 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 6923 6924 root_0 = (CommonTree)adaptor.nil(); 6925 // 706:23: -> ^( I_LABEL[$COLON, \"I_LABEL\"] simple_name ) 6926 { 6927 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:706:26: ^( I_LABEL[$COLON, \"I_LABEL\"] simple_name ) 6928 { 6929 CommonTree root_1 = (CommonTree)adaptor.nil(); 6930 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_LABEL, COLON184, "I_LABEL"), root_1); 6931 adaptor.addChild(root_1, stream_simple_name.nextTree()); 6932 adaptor.addChild(root_0, root_1); 6933 } 6934 6935 } 6936 6937 6938 retval.tree = root_0; 6939 6940 } 6941 6942 retval.stop = input.LT(-1); 6943 6944 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 6945 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 6946 6947 } 6948 catch (RecognitionException re) { 6949 reportError(re); 6950 recover(input,re); 6951 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 6952 } 6953 finally { 6954 // do for sure before leaving 6955 } 6956 return retval; 6957 } 6958 // $ANTLR end "label" 6959 6960 6961 public static class label_ref_return extends ParserRuleReturnScope { 6962 CommonTree tree; 6963 @Override 6964 public CommonTree getTree() { return tree; } 6965 }; 6966 6967 6968 // $ANTLR start "label_ref" 6969 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:708:1: label_ref : COLON simple_name -> simple_name ; 6970 public final smaliParser.label_ref_return label_ref() throws RecognitionException { 6971 smaliParser.label_ref_return retval = new smaliParser.label_ref_return(); 6972 retval.start = input.LT(1); 6973 6974 CommonTree root_0 = null; 6975 6976 Token COLON186=null; 6977 ParserRuleReturnScope simple_name187 =null; 6978 6979 CommonTree COLON186_tree=null; 6980 RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON"); 6981 RewriteRuleSubtreeStream stream_simple_name=new RewriteRuleSubtreeStream(adaptor,"rule simple_name"); 6982 6983 try { 6984 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:709:3: ( COLON simple_name -> simple_name ) 6985 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:709:5: COLON simple_name 6986 { 6987 COLON186=(Token)match(input,COLON,FOLLOW_COLON_in_label_ref3038); 6988 stream_COLON.add(COLON186); 6989 6990 pushFollow(FOLLOW_simple_name_in_label_ref3040); 6991 simple_name187=simple_name(); 6992 state._fsp--; 6993 6994 stream_simple_name.add(simple_name187.getTree()); 6995 // AST REWRITE 6996 // elements: simple_name 6997 // token labels: 6998 // rule labels: retval 6999 // token list labels: 7000 // rule list labels: 7001 // wildcard labels: 7002 retval.tree = root_0; 7003 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7004 7005 root_0 = (CommonTree)adaptor.nil(); 7006 // 709:23: -> simple_name 7007 { 7008 adaptor.addChild(root_0, stream_simple_name.nextTree()); 7009 } 7010 7011 7012 retval.tree = root_0; 7013 7014 } 7015 7016 retval.stop = input.LT(-1); 7017 7018 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 7019 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 7020 7021 } 7022 catch (RecognitionException re) { 7023 reportError(re); 7024 recover(input,re); 7025 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 7026 } 7027 finally { 7028 // do for sure before leaving 7029 } 7030 return retval; 7031 } 7032 // $ANTLR end "label_ref" 7033 7034 7035 public static class register_list_return extends ParserRuleReturnScope { 7036 CommonTree tree; 7037 @Override 7038 public CommonTree getTree() { return tree; } 7039 }; 7040 7041 7042 // $ANTLR start "register_list" 7043 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:711:1: register_list : ( REGISTER ( COMMA REGISTER )* -> ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ( REGISTER )* ) | -> ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ) ); 7044 public final smaliParser.register_list_return register_list() throws RecognitionException { 7045 smaliParser.register_list_return retval = new smaliParser.register_list_return(); 7046 retval.start = input.LT(1); 7047 7048 CommonTree root_0 = null; 7049 7050 Token REGISTER188=null; 7051 Token COMMA189=null; 7052 Token REGISTER190=null; 7053 7054 CommonTree REGISTER188_tree=null; 7055 CommonTree COMMA189_tree=null; 7056 CommonTree REGISTER190_tree=null; 7057 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 7058 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 7059 7060 try { 7061 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:712:3: ( REGISTER ( COMMA REGISTER )* -> ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ( REGISTER )* ) | -> ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ) ) 7062 int alt33=2; 7063 int LA33_0 = input.LA(1); 7064 if ( (LA33_0==REGISTER) ) { 7065 alt33=1; 7066 } 7067 else if ( (LA33_0==CLOSE_BRACE) ) { 7068 alt33=2; 7069 } 7070 7071 else { 7072 NoViableAltException nvae = 7073 new NoViableAltException("", 33, 0, input); 7074 throw nvae; 7075 } 7076 7077 switch (alt33) { 7078 case 1 : 7079 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:712:5: REGISTER ( COMMA REGISTER )* 7080 { 7081 REGISTER188=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_register_list3054); 7082 stream_REGISTER.add(REGISTER188); 7083 7084 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:712:14: ( COMMA REGISTER )* 7085 loop32: 7086 while (true) { 7087 int alt32=2; 7088 int LA32_0 = input.LA(1); 7089 if ( (LA32_0==COMMA) ) { 7090 alt32=1; 7091 } 7092 7093 switch (alt32) { 7094 case 1 : 7095 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:712:15: COMMA REGISTER 7096 { 7097 COMMA189=(Token)match(input,COMMA,FOLLOW_COMMA_in_register_list3057); 7098 stream_COMMA.add(COMMA189); 7099 7100 REGISTER190=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_register_list3059); 7101 stream_REGISTER.add(REGISTER190); 7102 7103 } 7104 break; 7105 7106 default : 7107 break loop32; 7108 } 7109 } 7110 7111 // AST REWRITE 7112 // elements: REGISTER 7113 // token labels: 7114 // rule labels: retval 7115 // token list labels: 7116 // rule list labels: 7117 // wildcard labels: 7118 retval.tree = root_0; 7119 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7120 7121 root_0 = (CommonTree)adaptor.nil(); 7122 // 712:32: -> ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ( REGISTER )* ) 7123 { 7124 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:712:35: ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ( REGISTER )* ) 7125 { 7126 CommonTree root_1 = (CommonTree)adaptor.nil(); 7127 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_REGISTER_LIST, (retval.start), "I_REGISTER_LIST"), root_1); 7128 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:712:80: ( REGISTER )* 7129 while ( stream_REGISTER.hasNext() ) { 7130 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 7131 } 7132 stream_REGISTER.reset(); 7133 7134 adaptor.addChild(root_0, root_1); 7135 } 7136 7137 } 7138 7139 7140 retval.tree = root_0; 7141 7142 } 7143 break; 7144 case 2 : 7145 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:713:5: 7146 { 7147 // AST REWRITE 7148 // elements: 7149 // token labels: 7150 // rule labels: retval 7151 // token list labels: 7152 // rule list labels: 7153 // wildcard labels: 7154 retval.tree = root_0; 7155 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7156 7157 root_0 = (CommonTree)adaptor.nil(); 7158 // 713:5: -> ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ) 7159 { 7160 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:713:7: ^( I_REGISTER_LIST[$start, \"I_REGISTER_LIST\"] ) 7161 { 7162 CommonTree root_1 = (CommonTree)adaptor.nil(); 7163 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_REGISTER_LIST, (retval.start), "I_REGISTER_LIST"), root_1); 7164 adaptor.addChild(root_0, root_1); 7165 } 7166 7167 } 7168 7169 7170 retval.tree = root_0; 7171 7172 } 7173 break; 7174 7175 } 7176 retval.stop = input.LT(-1); 7177 7178 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 7179 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 7180 7181 } 7182 catch (RecognitionException re) { 7183 reportError(re); 7184 recover(input,re); 7185 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 7186 } 7187 finally { 7188 // do for sure before leaving 7189 } 7190 return retval; 7191 } 7192 // $ANTLR end "register_list" 7193 7194 7195 public static class register_range_return extends ParserRuleReturnScope { 7196 CommonTree tree; 7197 @Override 7198 public CommonTree getTree() { return tree; } 7199 }; 7200 7201 7202 // $ANTLR start "register_range" 7203 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:715:1: register_range : (startreg= REGISTER ( DOTDOT endreg= REGISTER )? )? -> ^( I_REGISTER_RANGE[$start, \"I_REGISTER_RANGE\"] ( $startreg)? ( $endreg)? ) ; 7204 public final smaliParser.register_range_return register_range() throws RecognitionException { 7205 smaliParser.register_range_return retval = new smaliParser.register_range_return(); 7206 retval.start = input.LT(1); 7207 7208 CommonTree root_0 = null; 7209 7210 Token startreg=null; 7211 Token endreg=null; 7212 Token DOTDOT191=null; 7213 7214 CommonTree startreg_tree=null; 7215 CommonTree endreg_tree=null; 7216 CommonTree DOTDOT191_tree=null; 7217 RewriteRuleTokenStream stream_DOTDOT=new RewriteRuleTokenStream(adaptor,"token DOTDOT"); 7218 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 7219 7220 try { 7221 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:716:3: ( (startreg= REGISTER ( DOTDOT endreg= REGISTER )? )? -> ^( I_REGISTER_RANGE[$start, \"I_REGISTER_RANGE\"] ( $startreg)? ( $endreg)? ) ) 7222 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:716:5: (startreg= REGISTER ( DOTDOT endreg= REGISTER )? )? 7223 { 7224 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:716:5: (startreg= REGISTER ( DOTDOT endreg= REGISTER )? )? 7225 int alt35=2; 7226 int LA35_0 = input.LA(1); 7227 if ( (LA35_0==REGISTER) ) { 7228 alt35=1; 7229 } 7230 switch (alt35) { 7231 case 1 : 7232 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:716:6: startreg= REGISTER ( DOTDOT endreg= REGISTER )? 7233 { 7234 startreg=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_register_range3094); 7235 stream_REGISTER.add(startreg); 7236 7237 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:716:24: ( DOTDOT endreg= REGISTER )? 7238 int alt34=2; 7239 int LA34_0 = input.LA(1); 7240 if ( (LA34_0==DOTDOT) ) { 7241 alt34=1; 7242 } 7243 switch (alt34) { 7244 case 1 : 7245 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:716:25: DOTDOT endreg= REGISTER 7246 { 7247 DOTDOT191=(Token)match(input,DOTDOT,FOLLOW_DOTDOT_in_register_range3097); 7248 stream_DOTDOT.add(DOTDOT191); 7249 7250 endreg=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_register_range3101); 7251 stream_REGISTER.add(endreg); 7252 7253 } 7254 break; 7255 7256 } 7257 7258 } 7259 break; 7260 7261 } 7262 7263 // AST REWRITE 7264 // elements: endreg, startreg 7265 // token labels: endreg, startreg 7266 // rule labels: retval 7267 // token list labels: 7268 // rule list labels: 7269 // wildcard labels: 7270 retval.tree = root_0; 7271 RewriteRuleTokenStream stream_endreg=new RewriteRuleTokenStream(adaptor,"token endreg",endreg); 7272 RewriteRuleTokenStream stream_startreg=new RewriteRuleTokenStream(adaptor,"token startreg",startreg); 7273 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7274 7275 root_0 = (CommonTree)adaptor.nil(); 7276 // 716:52: -> ^( I_REGISTER_RANGE[$start, \"I_REGISTER_RANGE\"] ( $startreg)? ( $endreg)? ) 7277 { 7278 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:716:55: ^( I_REGISTER_RANGE[$start, \"I_REGISTER_RANGE\"] ( $startreg)? ( $endreg)? ) 7279 { 7280 CommonTree root_1 = (CommonTree)adaptor.nil(); 7281 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_REGISTER_RANGE, (retval.start), "I_REGISTER_RANGE"), root_1); 7282 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:716:103: ( $startreg)? 7283 if ( stream_startreg.hasNext() ) { 7284 adaptor.addChild(root_1, stream_startreg.nextNode()); 7285 } 7286 stream_startreg.reset(); 7287 7288 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:716:114: ( $endreg)? 7289 if ( stream_endreg.hasNext() ) { 7290 adaptor.addChild(root_1, stream_endreg.nextNode()); 7291 } 7292 stream_endreg.reset(); 7293 7294 adaptor.addChild(root_0, root_1); 7295 } 7296 7297 } 7298 7299 7300 retval.tree = root_0; 7301 7302 } 7303 7304 retval.stop = input.LT(-1); 7305 7306 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 7307 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 7308 7309 } 7310 catch (RecognitionException re) { 7311 reportError(re); 7312 recover(input,re); 7313 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 7314 } 7315 finally { 7316 // do for sure before leaving 7317 } 7318 return retval; 7319 } 7320 // $ANTLR end "register_range" 7321 7322 7323 public static class verification_error_reference_return extends ParserRuleReturnScope { 7324 CommonTree tree; 7325 @Override 7326 public CommonTree getTree() { return tree; } 7327 }; 7328 7329 7330 // $ANTLR start "verification_error_reference" 7331 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:718:1: verification_error_reference : ( CLASS_DESCRIPTOR | field_reference | method_reference ); 7332 public final smaliParser.verification_error_reference_return verification_error_reference() throws RecognitionException { 7333 smaliParser.verification_error_reference_return retval = new smaliParser.verification_error_reference_return(); 7334 retval.start = input.LT(1); 7335 7336 CommonTree root_0 = null; 7337 7338 Token CLASS_DESCRIPTOR192=null; 7339 ParserRuleReturnScope field_reference193 =null; 7340 ParserRuleReturnScope method_reference194 =null; 7341 7342 CommonTree CLASS_DESCRIPTOR192_tree=null; 7343 7344 try { 7345 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:719:3: ( CLASS_DESCRIPTOR | field_reference | method_reference ) 7346 int alt36=3; 7347 alt36 = dfa36.predict(input); 7348 switch (alt36) { 7349 case 1 : 7350 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:719:5: CLASS_DESCRIPTOR 7351 { 7352 root_0 = (CommonTree)adaptor.nil(); 7353 7354 7355 CLASS_DESCRIPTOR192=(Token)match(input,CLASS_DESCRIPTOR,FOLLOW_CLASS_DESCRIPTOR_in_verification_error_reference3130); 7356 CLASS_DESCRIPTOR192_tree = (CommonTree)adaptor.create(CLASS_DESCRIPTOR192); 7357 adaptor.addChild(root_0, CLASS_DESCRIPTOR192_tree); 7358 7359 } 7360 break; 7361 case 2 : 7362 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:719:24: field_reference 7363 { 7364 root_0 = (CommonTree)adaptor.nil(); 7365 7366 7367 pushFollow(FOLLOW_field_reference_in_verification_error_reference3134); 7368 field_reference193=field_reference(); 7369 state._fsp--; 7370 7371 adaptor.addChild(root_0, field_reference193.getTree()); 7372 7373 } 7374 break; 7375 case 3 : 7376 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:719:42: method_reference 7377 { 7378 root_0 = (CommonTree)adaptor.nil(); 7379 7380 7381 pushFollow(FOLLOW_method_reference_in_verification_error_reference3138); 7382 method_reference194=method_reference(); 7383 state._fsp--; 7384 7385 adaptor.addChild(root_0, method_reference194.getTree()); 7386 7387 } 7388 break; 7389 7390 } 7391 retval.stop = input.LT(-1); 7392 7393 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 7394 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 7395 7396 } 7397 catch (RecognitionException re) { 7398 reportError(re); 7399 recover(input,re); 7400 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 7401 } 7402 finally { 7403 // do for sure before leaving 7404 } 7405 return retval; 7406 } 7407 // $ANTLR end "verification_error_reference" 7408 7409 7410 public static class catch_directive_return extends ParserRuleReturnScope { 7411 CommonTree tree; 7412 @Override 7413 public CommonTree getTree() { return tree; } 7414 }; 7415 7416 7417 // $ANTLR start "catch_directive" 7418 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:721: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) ; 7419 public final smaliParser.catch_directive_return catch_directive() throws RecognitionException { 7420 smaliParser.catch_directive_return retval = new smaliParser.catch_directive_return(); 7421 retval.start = input.LT(1); 7422 7423 CommonTree root_0 = null; 7424 7425 Token CATCH_DIRECTIVE195=null; 7426 Token OPEN_BRACE197=null; 7427 Token DOTDOT198=null; 7428 Token CLOSE_BRACE199=null; 7429 ParserRuleReturnScope from =null; 7430 ParserRuleReturnScope to =null; 7431 ParserRuleReturnScope using =null; 7432 ParserRuleReturnScope nonvoid_type_descriptor196 =null; 7433 7434 CommonTree CATCH_DIRECTIVE195_tree=null; 7435 CommonTree OPEN_BRACE197_tree=null; 7436 CommonTree DOTDOT198_tree=null; 7437 CommonTree CLOSE_BRACE199_tree=null; 7438 RewriteRuleTokenStream stream_DOTDOT=new RewriteRuleTokenStream(adaptor,"token DOTDOT"); 7439 RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE"); 7440 RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE"); 7441 RewriteRuleTokenStream stream_CATCH_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token CATCH_DIRECTIVE"); 7442 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 7443 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 7444 7445 try { 7446 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:722: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) ) 7447 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:722:5: CATCH_DIRECTIVE nonvoid_type_descriptor OPEN_BRACE from= label_ref DOTDOT to= label_ref CLOSE_BRACE using= label_ref 7448 { 7449 CATCH_DIRECTIVE195=(Token)match(input,CATCH_DIRECTIVE,FOLLOW_CATCH_DIRECTIVE_in_catch_directive3148); 7450 stream_CATCH_DIRECTIVE.add(CATCH_DIRECTIVE195); 7451 7452 pushFollow(FOLLOW_nonvoid_type_descriptor_in_catch_directive3150); 7453 nonvoid_type_descriptor196=nonvoid_type_descriptor(); 7454 state._fsp--; 7455 7456 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor196.getTree()); 7457 OPEN_BRACE197=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_catch_directive3152); 7458 stream_OPEN_BRACE.add(OPEN_BRACE197); 7459 7460 pushFollow(FOLLOW_label_ref_in_catch_directive3156); 7461 from=label_ref(); 7462 state._fsp--; 7463 7464 stream_label_ref.add(from.getTree()); 7465 DOTDOT198=(Token)match(input,DOTDOT,FOLLOW_DOTDOT_in_catch_directive3158); 7466 stream_DOTDOT.add(DOTDOT198); 7467 7468 pushFollow(FOLLOW_label_ref_in_catch_directive3162); 7469 to=label_ref(); 7470 state._fsp--; 7471 7472 stream_label_ref.add(to.getTree()); 7473 CLOSE_BRACE199=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_catch_directive3164); 7474 stream_CLOSE_BRACE.add(CLOSE_BRACE199); 7475 7476 pushFollow(FOLLOW_label_ref_in_catch_directive3168); 7477 using=label_ref(); 7478 state._fsp--; 7479 7480 stream_label_ref.add(using.getTree()); 7481 // AST REWRITE 7482 // elements: using, from, to, nonvoid_type_descriptor 7483 // token labels: 7484 // rule labels: to, retval, using, from 7485 // token list labels: 7486 // rule list labels: 7487 // wildcard labels: 7488 retval.tree = root_0; 7489 RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.getTree():null); 7490 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7491 RewriteRuleSubtreeStream stream_using=new RewriteRuleSubtreeStream(adaptor,"rule using",using!=null?using.getTree():null); 7492 RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.getTree():null); 7493 7494 root_0 = (CommonTree)adaptor.nil(); 7495 // 723:5: -> ^( I_CATCH[$start, \"I_CATCH\"] nonvoid_type_descriptor $from $to $using) 7496 { 7497 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:723:8: ^( I_CATCH[$start, \"I_CATCH\"] nonvoid_type_descriptor $from $to $using) 7498 { 7499 CommonTree root_1 = (CommonTree)adaptor.nil(); 7500 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_CATCH, (retval.start), "I_CATCH"), root_1); 7501 adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree()); 7502 adaptor.addChild(root_1, stream_from.nextTree()); 7503 adaptor.addChild(root_1, stream_to.nextTree()); 7504 adaptor.addChild(root_1, stream_using.nextTree()); 7505 adaptor.addChild(root_0, root_1); 7506 } 7507 7508 } 7509 7510 7511 retval.tree = root_0; 7512 7513 } 7514 7515 retval.stop = input.LT(-1); 7516 7517 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 7518 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 7519 7520 } 7521 catch (RecognitionException re) { 7522 reportError(re); 7523 recover(input,re); 7524 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 7525 } 7526 finally { 7527 // do for sure before leaving 7528 } 7529 return retval; 7530 } 7531 // $ANTLR end "catch_directive" 7532 7533 7534 public static class catchall_directive_return extends ParserRuleReturnScope { 7535 CommonTree tree; 7536 @Override 7537 public CommonTree getTree() { return tree; } 7538 }; 7539 7540 7541 // $ANTLR start "catchall_directive" 7542 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:725: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) ; 7543 public final smaliParser.catchall_directive_return catchall_directive() throws RecognitionException { 7544 smaliParser.catchall_directive_return retval = new smaliParser.catchall_directive_return(); 7545 retval.start = input.LT(1); 7546 7547 CommonTree root_0 = null; 7548 7549 Token CATCHALL_DIRECTIVE200=null; 7550 Token OPEN_BRACE201=null; 7551 Token DOTDOT202=null; 7552 Token CLOSE_BRACE203=null; 7553 ParserRuleReturnScope from =null; 7554 ParserRuleReturnScope to =null; 7555 ParserRuleReturnScope using =null; 7556 7557 CommonTree CATCHALL_DIRECTIVE200_tree=null; 7558 CommonTree OPEN_BRACE201_tree=null; 7559 CommonTree DOTDOT202_tree=null; 7560 CommonTree CLOSE_BRACE203_tree=null; 7561 RewriteRuleTokenStream stream_DOTDOT=new RewriteRuleTokenStream(adaptor,"token DOTDOT"); 7562 RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE"); 7563 RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE"); 7564 RewriteRuleTokenStream stream_CATCHALL_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token CATCHALL_DIRECTIVE"); 7565 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 7566 7567 try { 7568 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:726: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) ) 7569 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:726:5: CATCHALL_DIRECTIVE OPEN_BRACE from= label_ref DOTDOT to= label_ref CLOSE_BRACE using= label_ref 7570 { 7571 CATCHALL_DIRECTIVE200=(Token)match(input,CATCHALL_DIRECTIVE,FOLLOW_CATCHALL_DIRECTIVE_in_catchall_directive3200); 7572 stream_CATCHALL_DIRECTIVE.add(CATCHALL_DIRECTIVE200); 7573 7574 OPEN_BRACE201=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_catchall_directive3202); 7575 stream_OPEN_BRACE.add(OPEN_BRACE201); 7576 7577 pushFollow(FOLLOW_label_ref_in_catchall_directive3206); 7578 from=label_ref(); 7579 state._fsp--; 7580 7581 stream_label_ref.add(from.getTree()); 7582 DOTDOT202=(Token)match(input,DOTDOT,FOLLOW_DOTDOT_in_catchall_directive3208); 7583 stream_DOTDOT.add(DOTDOT202); 7584 7585 pushFollow(FOLLOW_label_ref_in_catchall_directive3212); 7586 to=label_ref(); 7587 state._fsp--; 7588 7589 stream_label_ref.add(to.getTree()); 7590 CLOSE_BRACE203=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_catchall_directive3214); 7591 stream_CLOSE_BRACE.add(CLOSE_BRACE203); 7592 7593 pushFollow(FOLLOW_label_ref_in_catchall_directive3218); 7594 using=label_ref(); 7595 state._fsp--; 7596 7597 stream_label_ref.add(using.getTree()); 7598 // AST REWRITE 7599 // elements: from, to, using 7600 // token labels: 7601 // rule labels: to, retval, using, from 7602 // token list labels: 7603 // rule list labels: 7604 // wildcard labels: 7605 retval.tree = root_0; 7606 RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.getTree():null); 7607 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7608 RewriteRuleSubtreeStream stream_using=new RewriteRuleSubtreeStream(adaptor,"rule using",using!=null?using.getTree():null); 7609 RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.getTree():null); 7610 7611 root_0 = (CommonTree)adaptor.nil(); 7612 // 727:5: -> ^( I_CATCHALL[$start, \"I_CATCHALL\"] $from $to $using) 7613 { 7614 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:727:8: ^( I_CATCHALL[$start, \"I_CATCHALL\"] $from $to $using) 7615 { 7616 CommonTree root_1 = (CommonTree)adaptor.nil(); 7617 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_CATCHALL, (retval.start), "I_CATCHALL"), root_1); 7618 adaptor.addChild(root_1, stream_from.nextTree()); 7619 adaptor.addChild(root_1, stream_to.nextTree()); 7620 adaptor.addChild(root_1, stream_using.nextTree()); 7621 adaptor.addChild(root_0, root_1); 7622 } 7623 7624 } 7625 7626 7627 retval.tree = root_0; 7628 7629 } 7630 7631 retval.stop = input.LT(-1); 7632 7633 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 7634 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 7635 7636 } 7637 catch (RecognitionException re) { 7638 reportError(re); 7639 recover(input,re); 7640 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 7641 } 7642 finally { 7643 // do for sure before leaving 7644 } 7645 return retval; 7646 } 7647 // $ANTLR end "catchall_directive" 7648 7649 7650 public static class parameter_directive_return extends ParserRuleReturnScope { 7651 CommonTree tree; 7652 @Override 7653 public CommonTree getTree() { return tree; } 7654 }; 7655 7656 7657 // $ANTLR start "parameter_directive" 7658 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:733: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 ) ) ) ; 7659 public final smaliParser.parameter_directive_return parameter_directive() throws RecognitionException { 7660 smaliParser.parameter_directive_return retval = new smaliParser.parameter_directive_return(); 7661 retval.start = input.LT(1); 7662 7663 CommonTree root_0 = null; 7664 7665 Token PARAMETER_DIRECTIVE204=null; 7666 Token REGISTER205=null; 7667 Token COMMA206=null; 7668 Token STRING_LITERAL207=null; 7669 Token END_PARAMETER_DIRECTIVE209=null; 7670 ParserRuleReturnScope annotation208 =null; 7671 7672 CommonTree PARAMETER_DIRECTIVE204_tree=null; 7673 CommonTree REGISTER205_tree=null; 7674 CommonTree COMMA206_tree=null; 7675 CommonTree STRING_LITERAL207_tree=null; 7676 CommonTree END_PARAMETER_DIRECTIVE209_tree=null; 7677 RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL"); 7678 RewriteRuleTokenStream stream_END_PARAMETER_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_PARAMETER_DIRECTIVE"); 7679 RewriteRuleTokenStream stream_PARAMETER_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token PARAMETER_DIRECTIVE"); 7680 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 7681 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 7682 RewriteRuleSubtreeStream stream_annotation=new RewriteRuleSubtreeStream(adaptor,"rule annotation"); 7683 7684 List<CommonTree> annotations = new ArrayList<CommonTree>(); 7685 try { 7686 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:735: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 ) ) ) ) 7687 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:735: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 ) ) ) 7688 { 7689 PARAMETER_DIRECTIVE204=(Token)match(input,PARAMETER_DIRECTIVE,FOLLOW_PARAMETER_DIRECTIVE_in_parameter_directive3257); 7690 stream_PARAMETER_DIRECTIVE.add(PARAMETER_DIRECTIVE204); 7691 7692 REGISTER205=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_parameter_directive3259); 7693 stream_REGISTER.add(REGISTER205); 7694 7695 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:735:34: ( COMMA STRING_LITERAL )? 7696 int alt37=2; 7697 int LA37_0 = input.LA(1); 7698 if ( (LA37_0==COMMA) ) { 7699 alt37=1; 7700 } 7701 switch (alt37) { 7702 case 1 : 7703 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:735:35: COMMA STRING_LITERAL 7704 { 7705 COMMA206=(Token)match(input,COMMA,FOLLOW_COMMA_in_parameter_directive3262); 7706 stream_COMMA.add(COMMA206); 7707 7708 STRING_LITERAL207=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_parameter_directive3264); 7709 stream_STRING_LITERAL.add(STRING_LITERAL207); 7710 7711 } 7712 break; 7713 7714 } 7715 7716 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:736:5: ({...}? annotation )* 7717 loop38: 7718 while (true) { 7719 int alt38=2; 7720 alt38 = dfa38.predict(input); 7721 switch (alt38) { 7722 case 1 : 7723 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:736:6: {...}? annotation 7724 { 7725 if ( !((input.LA(1) == ANNOTATION_DIRECTIVE)) ) { 7726 throw new FailedPredicateException(input, "parameter_directive", "input.LA(1) == ANNOTATION_DIRECTIVE"); 7727 } 7728 pushFollow(FOLLOW_annotation_in_parameter_directive3275); 7729 annotation208=annotation(); 7730 state._fsp--; 7731 7732 stream_annotation.add(annotation208.getTree()); 7733 annotations.add((annotation208!=null?((CommonTree)annotation208.getTree()):null)); 7734 } 7735 break; 7736 7737 default : 7738 break loop38; 7739 } 7740 } 7741 7742 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:738: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 ) ) ) 7743 int alt39=2; 7744 int LA39_0 = input.LA(1); 7745 if ( (LA39_0==END_PARAMETER_DIRECTIVE) ) { 7746 alt39=1; 7747 } 7748 else if ( (LA39_0==ANNOTATION_DIRECTIVE||LA39_0==ARRAY_DATA_DIRECTIVE||(LA39_0 >= CATCHALL_DIRECTIVE && LA39_0 <= CATCH_DIRECTIVE)||LA39_0==COLON||(LA39_0 >= END_LOCAL_DIRECTIVE && LA39_0 <= END_METHOD_DIRECTIVE)||LA39_0==EPILOGUE_DIRECTIVE||(LA39_0 >= INSTRUCTION_FORMAT10t && LA39_0 <= INSTRUCTION_FORMAT51l)||(LA39_0 >= LINE_DIRECTIVE && LA39_0 <= LOCAL_DIRECTIVE)||(LA39_0 >= PACKED_SWITCH_DIRECTIVE && LA39_0 <= PARAMETER_DIRECTIVE)||LA39_0==PROLOGUE_DIRECTIVE||(LA39_0 >= REGISTERS_DIRECTIVE && LA39_0 <= RESTART_LOCAL_DIRECTIVE)||(LA39_0 >= SOURCE_DIRECTIVE && LA39_0 <= SPARSE_SWITCH_DIRECTIVE)) ) { 7749 alt39=2; 7750 } 7751 7752 else { 7753 NoViableAltException nvae = 7754 new NoViableAltException("", 39, 0, input); 7755 throw nvae; 7756 } 7757 7758 switch (alt39) { 7759 case 1 : 7760 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:738:7: END_PARAMETER_DIRECTIVE 7761 { 7762 END_PARAMETER_DIRECTIVE209=(Token)match(input,END_PARAMETER_DIRECTIVE,FOLLOW_END_PARAMETER_DIRECTIVE_in_parameter_directive3288); 7763 stream_END_PARAMETER_DIRECTIVE.add(END_PARAMETER_DIRECTIVE209); 7764 7765 // AST REWRITE 7766 // elements: STRING_LITERAL, annotation, REGISTER 7767 // token labels: 7768 // rule labels: retval 7769 // token list labels: 7770 // rule list labels: 7771 // wildcard labels: 7772 retval.tree = root_0; 7773 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7774 7775 root_0 = (CommonTree)adaptor.nil(); 7776 // 739:7: -> ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ( annotation )* ) ) 7777 { 7778 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:739:10: ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ( annotation )* ) ) 7779 { 7780 CommonTree root_1 = (CommonTree)adaptor.nil(); 7781 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_PARAMETER, (retval.start), "I_PARAMETER"), root_1); 7782 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 7783 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:739:56: ( STRING_LITERAL )? 7784 if ( stream_STRING_LITERAL.hasNext() ) { 7785 adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode()); 7786 } 7787 stream_STRING_LITERAL.reset(); 7788 7789 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:739:72: ^( I_ANNOTATIONS ( annotation )* ) 7790 { 7791 CommonTree root_2 = (CommonTree)adaptor.nil(); 7792 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ANNOTATIONS, "I_ANNOTATIONS"), root_2); 7793 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:739:88: ( annotation )* 7794 while ( stream_annotation.hasNext() ) { 7795 adaptor.addChild(root_2, stream_annotation.nextTree()); 7796 } 7797 stream_annotation.reset(); 7798 7799 adaptor.addChild(root_1, root_2); 7800 } 7801 7802 adaptor.addChild(root_0, root_1); 7803 } 7804 7805 } 7806 7807 7808 retval.tree = root_0; 7809 7810 } 7811 break; 7812 case 2 : 7813 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:740:19: 7814 { 7815 statements_and_directives_stack.peek().methodAnnotations.addAll(annotations); 7816 // AST REWRITE 7817 // elements: STRING_LITERAL, REGISTER 7818 // token labels: 7819 // rule labels: retval 7820 // token list labels: 7821 // rule list labels: 7822 // wildcard labels: 7823 retval.tree = root_0; 7824 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 7825 7826 root_0 = (CommonTree)adaptor.nil(); 7827 // 741:7: -> ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ) ) 7828 { 7829 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:741:10: ^( I_PARAMETER[$start, \"I_PARAMETER\"] REGISTER ( STRING_LITERAL )? ^( I_ANNOTATIONS ) ) 7830 { 7831 CommonTree root_1 = (CommonTree)adaptor.nil(); 7832 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_PARAMETER, (retval.start), "I_PARAMETER"), root_1); 7833 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 7834 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:741:56: ( STRING_LITERAL )? 7835 if ( stream_STRING_LITERAL.hasNext() ) { 7836 adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode()); 7837 } 7838 stream_STRING_LITERAL.reset(); 7839 7840 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:741:72: ^( I_ANNOTATIONS ) 7841 { 7842 CommonTree root_2 = (CommonTree)adaptor.nil(); 7843 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ANNOTATIONS, "I_ANNOTATIONS"), root_2); 7844 adaptor.addChild(root_1, root_2); 7845 } 7846 7847 adaptor.addChild(root_0, root_1); 7848 } 7849 7850 } 7851 7852 7853 retval.tree = root_0; 7854 7855 } 7856 break; 7857 7858 } 7859 7860 } 7861 7862 retval.stop = input.LT(-1); 7863 7864 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 7865 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 7866 7867 } 7868 catch (RecognitionException re) { 7869 reportError(re); 7870 recover(input,re); 7871 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 7872 } 7873 finally { 7874 // do for sure before leaving 7875 } 7876 return retval; 7877 } 7878 // $ANTLR end "parameter_directive" 7879 7880 7881 public static class debug_directive_return extends ParserRuleReturnScope { 7882 CommonTree tree; 7883 @Override 7884 public CommonTree getTree() { return tree; } 7885 }; 7886 7887 7888 // $ANTLR start "debug_directive" 7889 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:744:1: debug_directive : ( line_directive | local_directive | end_local_directive | restart_local_directive | prologue_directive | epilogue_directive | source_directive ); 7890 public final smaliParser.debug_directive_return debug_directive() throws RecognitionException { 7891 smaliParser.debug_directive_return retval = new smaliParser.debug_directive_return(); 7892 retval.start = input.LT(1); 7893 7894 CommonTree root_0 = null; 7895 7896 ParserRuleReturnScope line_directive210 =null; 7897 ParserRuleReturnScope local_directive211 =null; 7898 ParserRuleReturnScope end_local_directive212 =null; 7899 ParserRuleReturnScope restart_local_directive213 =null; 7900 ParserRuleReturnScope prologue_directive214 =null; 7901 ParserRuleReturnScope epilogue_directive215 =null; 7902 ParserRuleReturnScope source_directive216 =null; 7903 7904 7905 try { 7906 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:745:3: ( line_directive | local_directive | end_local_directive | restart_local_directive | prologue_directive | epilogue_directive | source_directive ) 7907 int alt40=7; 7908 switch ( input.LA(1) ) { 7909 case LINE_DIRECTIVE: 7910 { 7911 alt40=1; 7912 } 7913 break; 7914 case LOCAL_DIRECTIVE: 7915 { 7916 alt40=2; 7917 } 7918 break; 7919 case END_LOCAL_DIRECTIVE: 7920 { 7921 alt40=3; 7922 } 7923 break; 7924 case RESTART_LOCAL_DIRECTIVE: 7925 { 7926 alt40=4; 7927 } 7928 break; 7929 case PROLOGUE_DIRECTIVE: 7930 { 7931 alt40=5; 7932 } 7933 break; 7934 case EPILOGUE_DIRECTIVE: 7935 { 7936 alt40=6; 7937 } 7938 break; 7939 case SOURCE_DIRECTIVE: 7940 { 7941 alt40=7; 7942 } 7943 break; 7944 default: 7945 NoViableAltException nvae = 7946 new NoViableAltException("", 40, 0, input); 7947 throw nvae; 7948 } 7949 switch (alt40) { 7950 case 1 : 7951 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:745:5: line_directive 7952 { 7953 root_0 = (CommonTree)adaptor.nil(); 7954 7955 7956 pushFollow(FOLLOW_line_directive_in_debug_directive3361); 7957 line_directive210=line_directive(); 7958 state._fsp--; 7959 7960 adaptor.addChild(root_0, line_directive210.getTree()); 7961 7962 } 7963 break; 7964 case 2 : 7965 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:746:5: local_directive 7966 { 7967 root_0 = (CommonTree)adaptor.nil(); 7968 7969 7970 pushFollow(FOLLOW_local_directive_in_debug_directive3367); 7971 local_directive211=local_directive(); 7972 state._fsp--; 7973 7974 adaptor.addChild(root_0, local_directive211.getTree()); 7975 7976 } 7977 break; 7978 case 3 : 7979 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:747:5: end_local_directive 7980 { 7981 root_0 = (CommonTree)adaptor.nil(); 7982 7983 7984 pushFollow(FOLLOW_end_local_directive_in_debug_directive3373); 7985 end_local_directive212=end_local_directive(); 7986 state._fsp--; 7987 7988 adaptor.addChild(root_0, end_local_directive212.getTree()); 7989 7990 } 7991 break; 7992 case 4 : 7993 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:748:5: restart_local_directive 7994 { 7995 root_0 = (CommonTree)adaptor.nil(); 7996 7997 7998 pushFollow(FOLLOW_restart_local_directive_in_debug_directive3379); 7999 restart_local_directive213=restart_local_directive(); 8000 state._fsp--; 8001 8002 adaptor.addChild(root_0, restart_local_directive213.getTree()); 8003 8004 } 8005 break; 8006 case 5 : 8007 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:749:5: prologue_directive 8008 { 8009 root_0 = (CommonTree)adaptor.nil(); 8010 8011 8012 pushFollow(FOLLOW_prologue_directive_in_debug_directive3385); 8013 prologue_directive214=prologue_directive(); 8014 state._fsp--; 8015 8016 adaptor.addChild(root_0, prologue_directive214.getTree()); 8017 8018 } 8019 break; 8020 case 6 : 8021 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:750:5: epilogue_directive 8022 { 8023 root_0 = (CommonTree)adaptor.nil(); 8024 8025 8026 pushFollow(FOLLOW_epilogue_directive_in_debug_directive3391); 8027 epilogue_directive215=epilogue_directive(); 8028 state._fsp--; 8029 8030 adaptor.addChild(root_0, epilogue_directive215.getTree()); 8031 8032 } 8033 break; 8034 case 7 : 8035 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:751:5: source_directive 8036 { 8037 root_0 = (CommonTree)adaptor.nil(); 8038 8039 8040 pushFollow(FOLLOW_source_directive_in_debug_directive3397); 8041 source_directive216=source_directive(); 8042 state._fsp--; 8043 8044 adaptor.addChild(root_0, source_directive216.getTree()); 8045 8046 } 8047 break; 8048 8049 } 8050 retval.stop = input.LT(-1); 8051 8052 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8053 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8054 8055 } 8056 catch (RecognitionException re) { 8057 reportError(re); 8058 recover(input,re); 8059 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8060 } 8061 finally { 8062 // do for sure before leaving 8063 } 8064 return retval; 8065 } 8066 // $ANTLR end "debug_directive" 8067 8068 8069 public static class line_directive_return extends ParserRuleReturnScope { 8070 CommonTree tree; 8071 @Override 8072 public CommonTree getTree() { return tree; } 8073 }; 8074 8075 8076 // $ANTLR start "line_directive" 8077 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:753:1: line_directive : LINE_DIRECTIVE integral_literal -> ^( I_LINE[$start, \"I_LINE\"] integral_literal ) ; 8078 public final smaliParser.line_directive_return line_directive() throws RecognitionException { 8079 smaliParser.line_directive_return retval = new smaliParser.line_directive_return(); 8080 retval.start = input.LT(1); 8081 8082 CommonTree root_0 = null; 8083 8084 Token LINE_DIRECTIVE217=null; 8085 ParserRuleReturnScope integral_literal218 =null; 8086 8087 CommonTree LINE_DIRECTIVE217_tree=null; 8088 RewriteRuleTokenStream stream_LINE_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token LINE_DIRECTIVE"); 8089 RewriteRuleSubtreeStream stream_integral_literal=new RewriteRuleSubtreeStream(adaptor,"rule integral_literal"); 8090 8091 try { 8092 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:754:3: ( LINE_DIRECTIVE integral_literal -> ^( I_LINE[$start, \"I_LINE\"] integral_literal ) ) 8093 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:754:5: LINE_DIRECTIVE integral_literal 8094 { 8095 LINE_DIRECTIVE217=(Token)match(input,LINE_DIRECTIVE,FOLLOW_LINE_DIRECTIVE_in_line_directive3407); 8096 stream_LINE_DIRECTIVE.add(LINE_DIRECTIVE217); 8097 8098 pushFollow(FOLLOW_integral_literal_in_line_directive3409); 8099 integral_literal218=integral_literal(); 8100 state._fsp--; 8101 8102 stream_integral_literal.add(integral_literal218.getTree()); 8103 // AST REWRITE 8104 // elements: integral_literal 8105 // token labels: 8106 // rule labels: retval 8107 // token list labels: 8108 // rule list labels: 8109 // wildcard labels: 8110 retval.tree = root_0; 8111 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 8112 8113 root_0 = (CommonTree)adaptor.nil(); 8114 // 755:5: -> ^( I_LINE[$start, \"I_LINE\"] integral_literal ) 8115 { 8116 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:755:8: ^( I_LINE[$start, \"I_LINE\"] integral_literal ) 8117 { 8118 CommonTree root_1 = (CommonTree)adaptor.nil(); 8119 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_LINE, (retval.start), "I_LINE"), root_1); 8120 adaptor.addChild(root_1, stream_integral_literal.nextTree()); 8121 adaptor.addChild(root_0, root_1); 8122 } 8123 8124 } 8125 8126 8127 retval.tree = root_0; 8128 8129 } 8130 8131 retval.stop = input.LT(-1); 8132 8133 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8134 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8135 8136 } 8137 catch (RecognitionException re) { 8138 reportError(re); 8139 recover(input,re); 8140 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8141 } 8142 finally { 8143 // do for sure before leaving 8144 } 8145 return retval; 8146 } 8147 // $ANTLR end "line_directive" 8148 8149 8150 public static class local_directive_return extends ParserRuleReturnScope { 8151 CommonTree tree; 8152 @Override 8153 public CommonTree getTree() { return tree; } 8154 }; 8155 8156 8157 // $ANTLR start "local_directive" 8158 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:757:1: local_directive : LOCAL_DIRECTIVE REGISTER ( COMMA ( NULL_LITERAL |name= STRING_LITERAL ) COLON ( VOID_TYPE | nonvoid_type_descriptor ) ( COMMA signature= STRING_LITERAL )? )? -> ^( I_LOCAL[$start, \"I_LOCAL\"] REGISTER ( NULL_LITERAL )? ( $name)? ( nonvoid_type_descriptor )? ( $signature)? ) ; 8159 public final smaliParser.local_directive_return local_directive() throws RecognitionException { 8160 smaliParser.local_directive_return retval = new smaliParser.local_directive_return(); 8161 retval.start = input.LT(1); 8162 8163 CommonTree root_0 = null; 8164 8165 Token name=null; 8166 Token signature=null; 8167 Token LOCAL_DIRECTIVE219=null; 8168 Token REGISTER220=null; 8169 Token COMMA221=null; 8170 Token NULL_LITERAL222=null; 8171 Token COLON223=null; 8172 Token VOID_TYPE224=null; 8173 Token COMMA226=null; 8174 ParserRuleReturnScope nonvoid_type_descriptor225 =null; 8175 8176 CommonTree name_tree=null; 8177 CommonTree signature_tree=null; 8178 CommonTree LOCAL_DIRECTIVE219_tree=null; 8179 CommonTree REGISTER220_tree=null; 8180 CommonTree COMMA221_tree=null; 8181 CommonTree NULL_LITERAL222_tree=null; 8182 CommonTree COLON223_tree=null; 8183 CommonTree VOID_TYPE224_tree=null; 8184 CommonTree COMMA226_tree=null; 8185 RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON"); 8186 RewriteRuleTokenStream stream_NULL_LITERAL=new RewriteRuleTokenStream(adaptor,"token NULL_LITERAL"); 8187 RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL"); 8188 RewriteRuleTokenStream stream_LOCAL_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token LOCAL_DIRECTIVE"); 8189 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 8190 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 8191 RewriteRuleTokenStream stream_VOID_TYPE=new RewriteRuleTokenStream(adaptor,"token VOID_TYPE"); 8192 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 8193 8194 try { 8195 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:758:3: ( LOCAL_DIRECTIVE REGISTER ( COMMA ( NULL_LITERAL |name= STRING_LITERAL ) COLON ( VOID_TYPE | nonvoid_type_descriptor ) ( COMMA signature= STRING_LITERAL )? )? -> ^( I_LOCAL[$start, \"I_LOCAL\"] REGISTER ( NULL_LITERAL )? ( $name)? ( nonvoid_type_descriptor )? ( $signature)? ) ) 8196 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:758:5: LOCAL_DIRECTIVE REGISTER ( COMMA ( NULL_LITERAL |name= STRING_LITERAL ) COLON ( VOID_TYPE | nonvoid_type_descriptor ) ( COMMA signature= STRING_LITERAL )? )? 8197 { 8198 LOCAL_DIRECTIVE219=(Token)match(input,LOCAL_DIRECTIVE,FOLLOW_LOCAL_DIRECTIVE_in_local_directive3432); 8199 stream_LOCAL_DIRECTIVE.add(LOCAL_DIRECTIVE219); 8200 8201 REGISTER220=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_local_directive3434); 8202 stream_REGISTER.add(REGISTER220); 8203 8204 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:758:30: ( COMMA ( NULL_LITERAL |name= STRING_LITERAL ) COLON ( VOID_TYPE | nonvoid_type_descriptor ) ( COMMA signature= STRING_LITERAL )? )? 8205 int alt44=2; 8206 int LA44_0 = input.LA(1); 8207 if ( (LA44_0==COMMA) ) { 8208 alt44=1; 8209 } 8210 switch (alt44) { 8211 case 1 : 8212 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:758:31: COMMA ( NULL_LITERAL |name= STRING_LITERAL ) COLON ( VOID_TYPE | nonvoid_type_descriptor ) ( COMMA signature= STRING_LITERAL )? 8213 { 8214 COMMA221=(Token)match(input,COMMA,FOLLOW_COMMA_in_local_directive3437); 8215 stream_COMMA.add(COMMA221); 8216 8217 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:758:37: ( NULL_LITERAL |name= STRING_LITERAL ) 8218 int alt41=2; 8219 int LA41_0 = input.LA(1); 8220 if ( (LA41_0==NULL_LITERAL) ) { 8221 alt41=1; 8222 } 8223 else if ( (LA41_0==STRING_LITERAL) ) { 8224 alt41=2; 8225 } 8226 8227 else { 8228 NoViableAltException nvae = 8229 new NoViableAltException("", 41, 0, input); 8230 throw nvae; 8231 } 8232 8233 switch (alt41) { 8234 case 1 : 8235 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:758:38: NULL_LITERAL 8236 { 8237 NULL_LITERAL222=(Token)match(input,NULL_LITERAL,FOLLOW_NULL_LITERAL_in_local_directive3440); 8238 stream_NULL_LITERAL.add(NULL_LITERAL222); 8239 8240 } 8241 break; 8242 case 2 : 8243 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:758:53: name= STRING_LITERAL 8244 { 8245 name=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_local_directive3446); 8246 stream_STRING_LITERAL.add(name); 8247 8248 } 8249 break; 8250 8251 } 8252 8253 COLON223=(Token)match(input,COLON,FOLLOW_COLON_in_local_directive3449); 8254 stream_COLON.add(COLON223); 8255 8256 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:758:80: ( VOID_TYPE | nonvoid_type_descriptor ) 8257 int alt42=2; 8258 int LA42_0 = input.LA(1); 8259 if ( (LA42_0==VOID_TYPE) ) { 8260 alt42=1; 8261 } 8262 else if ( (LA42_0==ARRAY_DESCRIPTOR||LA42_0==CLASS_DESCRIPTOR||LA42_0==PRIMITIVE_TYPE) ) { 8263 alt42=2; 8264 } 8265 8266 else { 8267 NoViableAltException nvae = 8268 new NoViableAltException("", 42, 0, input); 8269 throw nvae; 8270 } 8271 8272 switch (alt42) { 8273 case 1 : 8274 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:758:81: VOID_TYPE 8275 { 8276 VOID_TYPE224=(Token)match(input,VOID_TYPE,FOLLOW_VOID_TYPE_in_local_directive3452); 8277 stream_VOID_TYPE.add(VOID_TYPE224); 8278 8279 } 8280 break; 8281 case 2 : 8282 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:758:93: nonvoid_type_descriptor 8283 { 8284 pushFollow(FOLLOW_nonvoid_type_descriptor_in_local_directive3456); 8285 nonvoid_type_descriptor225=nonvoid_type_descriptor(); 8286 state._fsp--; 8287 8288 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor225.getTree()); 8289 } 8290 break; 8291 8292 } 8293 8294 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:759:31: ( COMMA signature= STRING_LITERAL )? 8295 int alt43=2; 8296 int LA43_0 = input.LA(1); 8297 if ( (LA43_0==COMMA) ) { 8298 alt43=1; 8299 } 8300 switch (alt43) { 8301 case 1 : 8302 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:759:32: COMMA signature= STRING_LITERAL 8303 { 8304 COMMA226=(Token)match(input,COMMA,FOLLOW_COMMA_in_local_directive3490); 8305 stream_COMMA.add(COMMA226); 8306 8307 signature=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_local_directive3494); 8308 stream_STRING_LITERAL.add(signature); 8309 8310 } 8311 break; 8312 8313 } 8314 8315 } 8316 break; 8317 8318 } 8319 8320 // AST REWRITE 8321 // elements: nonvoid_type_descriptor, name, NULL_LITERAL, signature, REGISTER 8322 // token labels: name, signature 8323 // rule labels: retval 8324 // token list labels: 8325 // rule list labels: 8326 // wildcard labels: 8327 retval.tree = root_0; 8328 RewriteRuleTokenStream stream_name=new RewriteRuleTokenStream(adaptor,"token name",name); 8329 RewriteRuleTokenStream stream_signature=new RewriteRuleTokenStream(adaptor,"token signature",signature); 8330 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 8331 8332 root_0 = (CommonTree)adaptor.nil(); 8333 // 760:5: -> ^( I_LOCAL[$start, \"I_LOCAL\"] REGISTER ( NULL_LITERAL )? ( $name)? ( nonvoid_type_descriptor )? ( $signature)? ) 8334 { 8335 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:760:8: ^( I_LOCAL[$start, \"I_LOCAL\"] REGISTER ( NULL_LITERAL )? ( $name)? ( nonvoid_type_descriptor )? ( $signature)? ) 8336 { 8337 CommonTree root_1 = (CommonTree)adaptor.nil(); 8338 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_LOCAL, (retval.start), "I_LOCAL"), root_1); 8339 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 8340 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:760:46: ( NULL_LITERAL )? 8341 if ( stream_NULL_LITERAL.hasNext() ) { 8342 adaptor.addChild(root_1, stream_NULL_LITERAL.nextNode()); 8343 } 8344 stream_NULL_LITERAL.reset(); 8345 8346 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:760:61: ( $name)? 8347 if ( stream_name.hasNext() ) { 8348 adaptor.addChild(root_1, stream_name.nextNode()); 8349 } 8350 stream_name.reset(); 8351 8352 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:760:67: ( nonvoid_type_descriptor )? 8353 if ( stream_nonvoid_type_descriptor.hasNext() ) { 8354 adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree()); 8355 } 8356 stream_nonvoid_type_descriptor.reset(); 8357 8358 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:760:93: ( $signature)? 8359 if ( stream_signature.hasNext() ) { 8360 adaptor.addChild(root_1, stream_signature.nextNode()); 8361 } 8362 stream_signature.reset(); 8363 8364 adaptor.addChild(root_0, root_1); 8365 } 8366 8367 } 8368 8369 8370 retval.tree = root_0; 8371 8372 } 8373 8374 retval.stop = input.LT(-1); 8375 8376 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8377 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8378 8379 } 8380 catch (RecognitionException re) { 8381 reportError(re); 8382 recover(input,re); 8383 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8384 } 8385 finally { 8386 // do for sure before leaving 8387 } 8388 return retval; 8389 } 8390 // $ANTLR end "local_directive" 8391 8392 8393 public static class end_local_directive_return extends ParserRuleReturnScope { 8394 CommonTree tree; 8395 @Override 8396 public CommonTree getTree() { return tree; } 8397 }; 8398 8399 8400 // $ANTLR start "end_local_directive" 8401 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:762:1: end_local_directive : END_LOCAL_DIRECTIVE REGISTER -> ^( I_END_LOCAL[$start, \"I_END_LOCAL\"] REGISTER ) ; 8402 public final smaliParser.end_local_directive_return end_local_directive() throws RecognitionException { 8403 smaliParser.end_local_directive_return retval = new smaliParser.end_local_directive_return(); 8404 retval.start = input.LT(1); 8405 8406 CommonTree root_0 = null; 8407 8408 Token END_LOCAL_DIRECTIVE227=null; 8409 Token REGISTER228=null; 8410 8411 CommonTree END_LOCAL_DIRECTIVE227_tree=null; 8412 CommonTree REGISTER228_tree=null; 8413 RewriteRuleTokenStream stream_END_LOCAL_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_LOCAL_DIRECTIVE"); 8414 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 8415 8416 try { 8417 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:763:3: ( END_LOCAL_DIRECTIVE REGISTER -> ^( I_END_LOCAL[$start, \"I_END_LOCAL\"] REGISTER ) ) 8418 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:763:5: END_LOCAL_DIRECTIVE REGISTER 8419 { 8420 END_LOCAL_DIRECTIVE227=(Token)match(input,END_LOCAL_DIRECTIVE,FOLLOW_END_LOCAL_DIRECTIVE_in_end_local_directive3536); 8421 stream_END_LOCAL_DIRECTIVE.add(END_LOCAL_DIRECTIVE227); 8422 8423 REGISTER228=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_end_local_directive3538); 8424 stream_REGISTER.add(REGISTER228); 8425 8426 // AST REWRITE 8427 // elements: REGISTER 8428 // token labels: 8429 // rule labels: retval 8430 // token list labels: 8431 // rule list labels: 8432 // wildcard labels: 8433 retval.tree = root_0; 8434 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 8435 8436 root_0 = (CommonTree)adaptor.nil(); 8437 // 764:5: -> ^( I_END_LOCAL[$start, \"I_END_LOCAL\"] REGISTER ) 8438 { 8439 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:764:8: ^( I_END_LOCAL[$start, \"I_END_LOCAL\"] REGISTER ) 8440 { 8441 CommonTree root_1 = (CommonTree)adaptor.nil(); 8442 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_END_LOCAL, (retval.start), "I_END_LOCAL"), root_1); 8443 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 8444 adaptor.addChild(root_0, root_1); 8445 } 8446 8447 } 8448 8449 8450 retval.tree = root_0; 8451 8452 } 8453 8454 retval.stop = input.LT(-1); 8455 8456 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8457 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8458 8459 } 8460 catch (RecognitionException re) { 8461 reportError(re); 8462 recover(input,re); 8463 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8464 } 8465 finally { 8466 // do for sure before leaving 8467 } 8468 return retval; 8469 } 8470 // $ANTLR end "end_local_directive" 8471 8472 8473 public static class restart_local_directive_return extends ParserRuleReturnScope { 8474 CommonTree tree; 8475 @Override 8476 public CommonTree getTree() { return tree; } 8477 }; 8478 8479 8480 // $ANTLR start "restart_local_directive" 8481 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:766:1: restart_local_directive : RESTART_LOCAL_DIRECTIVE REGISTER -> ^( I_RESTART_LOCAL[$start, \"I_RESTART_LOCAL\"] REGISTER ) ; 8482 public final smaliParser.restart_local_directive_return restart_local_directive() throws RecognitionException { 8483 smaliParser.restart_local_directive_return retval = new smaliParser.restart_local_directive_return(); 8484 retval.start = input.LT(1); 8485 8486 CommonTree root_0 = null; 8487 8488 Token RESTART_LOCAL_DIRECTIVE229=null; 8489 Token REGISTER230=null; 8490 8491 CommonTree RESTART_LOCAL_DIRECTIVE229_tree=null; 8492 CommonTree REGISTER230_tree=null; 8493 RewriteRuleTokenStream stream_RESTART_LOCAL_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token RESTART_LOCAL_DIRECTIVE"); 8494 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 8495 8496 try { 8497 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:767:3: ( RESTART_LOCAL_DIRECTIVE REGISTER -> ^( I_RESTART_LOCAL[$start, \"I_RESTART_LOCAL\"] REGISTER ) ) 8498 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:767:5: RESTART_LOCAL_DIRECTIVE REGISTER 8499 { 8500 RESTART_LOCAL_DIRECTIVE229=(Token)match(input,RESTART_LOCAL_DIRECTIVE,FOLLOW_RESTART_LOCAL_DIRECTIVE_in_restart_local_directive3561); 8501 stream_RESTART_LOCAL_DIRECTIVE.add(RESTART_LOCAL_DIRECTIVE229); 8502 8503 REGISTER230=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_restart_local_directive3563); 8504 stream_REGISTER.add(REGISTER230); 8505 8506 // AST REWRITE 8507 // elements: REGISTER 8508 // token labels: 8509 // rule labels: retval 8510 // token list labels: 8511 // rule list labels: 8512 // wildcard labels: 8513 retval.tree = root_0; 8514 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 8515 8516 root_0 = (CommonTree)adaptor.nil(); 8517 // 768:5: -> ^( I_RESTART_LOCAL[$start, \"I_RESTART_LOCAL\"] REGISTER ) 8518 { 8519 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:768:8: ^( I_RESTART_LOCAL[$start, \"I_RESTART_LOCAL\"] REGISTER ) 8520 { 8521 CommonTree root_1 = (CommonTree)adaptor.nil(); 8522 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_RESTART_LOCAL, (retval.start), "I_RESTART_LOCAL"), root_1); 8523 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 8524 adaptor.addChild(root_0, root_1); 8525 } 8526 8527 } 8528 8529 8530 retval.tree = root_0; 8531 8532 } 8533 8534 retval.stop = input.LT(-1); 8535 8536 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8537 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8538 8539 } 8540 catch (RecognitionException re) { 8541 reportError(re); 8542 recover(input,re); 8543 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8544 } 8545 finally { 8546 // do for sure before leaving 8547 } 8548 return retval; 8549 } 8550 // $ANTLR end "restart_local_directive" 8551 8552 8553 public static class prologue_directive_return extends ParserRuleReturnScope { 8554 CommonTree tree; 8555 @Override 8556 public CommonTree getTree() { return tree; } 8557 }; 8558 8559 8560 // $ANTLR start "prologue_directive" 8561 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:770:1: prologue_directive : PROLOGUE_DIRECTIVE -> ^( I_PROLOGUE[$start, \"I_PROLOGUE\"] ) ; 8562 public final smaliParser.prologue_directive_return prologue_directive() throws RecognitionException { 8563 smaliParser.prologue_directive_return retval = new smaliParser.prologue_directive_return(); 8564 retval.start = input.LT(1); 8565 8566 CommonTree root_0 = null; 8567 8568 Token PROLOGUE_DIRECTIVE231=null; 8569 8570 CommonTree PROLOGUE_DIRECTIVE231_tree=null; 8571 RewriteRuleTokenStream stream_PROLOGUE_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token PROLOGUE_DIRECTIVE"); 8572 8573 try { 8574 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:771:3: ( PROLOGUE_DIRECTIVE -> ^( I_PROLOGUE[$start, \"I_PROLOGUE\"] ) ) 8575 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:771:5: PROLOGUE_DIRECTIVE 8576 { 8577 PROLOGUE_DIRECTIVE231=(Token)match(input,PROLOGUE_DIRECTIVE,FOLLOW_PROLOGUE_DIRECTIVE_in_prologue_directive3586); 8578 stream_PROLOGUE_DIRECTIVE.add(PROLOGUE_DIRECTIVE231); 8579 8580 // AST REWRITE 8581 // elements: 8582 // token labels: 8583 // rule labels: retval 8584 // token list labels: 8585 // rule list labels: 8586 // wildcard labels: 8587 retval.tree = root_0; 8588 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 8589 8590 root_0 = (CommonTree)adaptor.nil(); 8591 // 772:5: -> ^( I_PROLOGUE[$start, \"I_PROLOGUE\"] ) 8592 { 8593 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:772:8: ^( I_PROLOGUE[$start, \"I_PROLOGUE\"] ) 8594 { 8595 CommonTree root_1 = (CommonTree)adaptor.nil(); 8596 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_PROLOGUE, (retval.start), "I_PROLOGUE"), root_1); 8597 adaptor.addChild(root_0, root_1); 8598 } 8599 8600 } 8601 8602 8603 retval.tree = root_0; 8604 8605 } 8606 8607 retval.stop = input.LT(-1); 8608 8609 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8610 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8611 8612 } 8613 catch (RecognitionException re) { 8614 reportError(re); 8615 recover(input,re); 8616 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8617 } 8618 finally { 8619 // do for sure before leaving 8620 } 8621 return retval; 8622 } 8623 // $ANTLR end "prologue_directive" 8624 8625 8626 public static class epilogue_directive_return extends ParserRuleReturnScope { 8627 CommonTree tree; 8628 @Override 8629 public CommonTree getTree() { return tree; } 8630 }; 8631 8632 8633 // $ANTLR start "epilogue_directive" 8634 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:774:1: epilogue_directive : EPILOGUE_DIRECTIVE -> ^( I_EPILOGUE[$start, \"I_EPILOGUE\"] ) ; 8635 public final smaliParser.epilogue_directive_return epilogue_directive() throws RecognitionException { 8636 smaliParser.epilogue_directive_return retval = new smaliParser.epilogue_directive_return(); 8637 retval.start = input.LT(1); 8638 8639 CommonTree root_0 = null; 8640 8641 Token EPILOGUE_DIRECTIVE232=null; 8642 8643 CommonTree EPILOGUE_DIRECTIVE232_tree=null; 8644 RewriteRuleTokenStream stream_EPILOGUE_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token EPILOGUE_DIRECTIVE"); 8645 8646 try { 8647 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:775:3: ( EPILOGUE_DIRECTIVE -> ^( I_EPILOGUE[$start, \"I_EPILOGUE\"] ) ) 8648 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:775:5: EPILOGUE_DIRECTIVE 8649 { 8650 EPILOGUE_DIRECTIVE232=(Token)match(input,EPILOGUE_DIRECTIVE,FOLLOW_EPILOGUE_DIRECTIVE_in_epilogue_directive3607); 8651 stream_EPILOGUE_DIRECTIVE.add(EPILOGUE_DIRECTIVE232); 8652 8653 // AST REWRITE 8654 // elements: 8655 // token labels: 8656 // rule labels: retval 8657 // token list labels: 8658 // rule list labels: 8659 // wildcard labels: 8660 retval.tree = root_0; 8661 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 8662 8663 root_0 = (CommonTree)adaptor.nil(); 8664 // 776:5: -> ^( I_EPILOGUE[$start, \"I_EPILOGUE\"] ) 8665 { 8666 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:776:8: ^( I_EPILOGUE[$start, \"I_EPILOGUE\"] ) 8667 { 8668 CommonTree root_1 = (CommonTree)adaptor.nil(); 8669 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_EPILOGUE, (retval.start), "I_EPILOGUE"), root_1); 8670 adaptor.addChild(root_0, root_1); 8671 } 8672 8673 } 8674 8675 8676 retval.tree = root_0; 8677 8678 } 8679 8680 retval.stop = input.LT(-1); 8681 8682 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8683 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8684 8685 } 8686 catch (RecognitionException re) { 8687 reportError(re); 8688 recover(input,re); 8689 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8690 } 8691 finally { 8692 // do for sure before leaving 8693 } 8694 return retval; 8695 } 8696 // $ANTLR end "epilogue_directive" 8697 8698 8699 public static class source_directive_return extends ParserRuleReturnScope { 8700 CommonTree tree; 8701 @Override 8702 public CommonTree getTree() { return tree; } 8703 }; 8704 8705 8706 // $ANTLR start "source_directive" 8707 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:778:1: source_directive : SOURCE_DIRECTIVE ( STRING_LITERAL )? -> ^( I_SOURCE[$start, \"I_SOURCE\"] ( STRING_LITERAL )? ) ; 8708 public final smaliParser.source_directive_return source_directive() throws RecognitionException { 8709 smaliParser.source_directive_return retval = new smaliParser.source_directive_return(); 8710 retval.start = input.LT(1); 8711 8712 CommonTree root_0 = null; 8713 8714 Token SOURCE_DIRECTIVE233=null; 8715 Token STRING_LITERAL234=null; 8716 8717 CommonTree SOURCE_DIRECTIVE233_tree=null; 8718 CommonTree STRING_LITERAL234_tree=null; 8719 RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL"); 8720 RewriteRuleTokenStream stream_SOURCE_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token SOURCE_DIRECTIVE"); 8721 8722 try { 8723 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:779:3: ( SOURCE_DIRECTIVE ( STRING_LITERAL )? -> ^( I_SOURCE[$start, \"I_SOURCE\"] ( STRING_LITERAL )? ) ) 8724 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:779:5: SOURCE_DIRECTIVE ( STRING_LITERAL )? 8725 { 8726 SOURCE_DIRECTIVE233=(Token)match(input,SOURCE_DIRECTIVE,FOLLOW_SOURCE_DIRECTIVE_in_source_directive3628); 8727 stream_SOURCE_DIRECTIVE.add(SOURCE_DIRECTIVE233); 8728 8729 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:779:22: ( STRING_LITERAL )? 8730 int alt45=2; 8731 int LA45_0 = input.LA(1); 8732 if ( (LA45_0==STRING_LITERAL) ) { 8733 alt45=1; 8734 } 8735 switch (alt45) { 8736 case 1 : 8737 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:779:22: STRING_LITERAL 8738 { 8739 STRING_LITERAL234=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_source_directive3630); 8740 stream_STRING_LITERAL.add(STRING_LITERAL234); 8741 8742 } 8743 break; 8744 8745 } 8746 8747 // AST REWRITE 8748 // elements: STRING_LITERAL 8749 // token labels: 8750 // rule labels: retval 8751 // token list labels: 8752 // rule list labels: 8753 // wildcard labels: 8754 retval.tree = root_0; 8755 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 8756 8757 root_0 = (CommonTree)adaptor.nil(); 8758 // 780:5: -> ^( I_SOURCE[$start, \"I_SOURCE\"] ( STRING_LITERAL )? ) 8759 { 8760 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:780:8: ^( I_SOURCE[$start, \"I_SOURCE\"] ( STRING_LITERAL )? ) 8761 { 8762 CommonTree root_1 = (CommonTree)adaptor.nil(); 8763 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_SOURCE, (retval.start), "I_SOURCE"), root_1); 8764 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:780:39: ( STRING_LITERAL )? 8765 if ( stream_STRING_LITERAL.hasNext() ) { 8766 adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode()); 8767 } 8768 stream_STRING_LITERAL.reset(); 8769 8770 adaptor.addChild(root_0, root_1); 8771 } 8772 8773 } 8774 8775 8776 retval.tree = root_0; 8777 8778 } 8779 8780 retval.stop = input.LT(-1); 8781 8782 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8783 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8784 8785 } 8786 catch (RecognitionException re) { 8787 reportError(re); 8788 recover(input,re); 8789 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8790 } 8791 finally { 8792 // do for sure before leaving 8793 } 8794 return retval; 8795 } 8796 // $ANTLR end "source_directive" 8797 8798 8799 public static class instruction_format12x_return extends ParserRuleReturnScope { 8800 CommonTree tree; 8801 @Override 8802 public CommonTree getTree() { return tree; } 8803 }; 8804 8805 8806 // $ANTLR start "instruction_format12x" 8807 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:782:1: instruction_format12x : ( INSTRUCTION_FORMAT12x | INSTRUCTION_FORMAT12x_OR_ID -> INSTRUCTION_FORMAT12x[$INSTRUCTION_FORMAT12x_OR_ID] ); 8808 public final smaliParser.instruction_format12x_return instruction_format12x() throws RecognitionException { 8809 smaliParser.instruction_format12x_return retval = new smaliParser.instruction_format12x_return(); 8810 retval.start = input.LT(1); 8811 8812 CommonTree root_0 = null; 8813 8814 Token INSTRUCTION_FORMAT12x235=null; 8815 Token INSTRUCTION_FORMAT12x_OR_ID236=null; 8816 8817 CommonTree INSTRUCTION_FORMAT12x235_tree=null; 8818 CommonTree INSTRUCTION_FORMAT12x_OR_ID236_tree=null; 8819 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT12x_OR_ID=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT12x_OR_ID"); 8820 8821 try { 8822 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:783:3: ( INSTRUCTION_FORMAT12x | INSTRUCTION_FORMAT12x_OR_ID -> INSTRUCTION_FORMAT12x[$INSTRUCTION_FORMAT12x_OR_ID] ) 8823 int alt46=2; 8824 int LA46_0 = input.LA(1); 8825 if ( (LA46_0==INSTRUCTION_FORMAT12x) ) { 8826 alt46=1; 8827 } 8828 else if ( (LA46_0==INSTRUCTION_FORMAT12x_OR_ID) ) { 8829 alt46=2; 8830 } 8831 8832 else { 8833 NoViableAltException nvae = 8834 new NoViableAltException("", 46, 0, input); 8835 throw nvae; 8836 } 8837 8838 switch (alt46) { 8839 case 1 : 8840 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:783:5: INSTRUCTION_FORMAT12x 8841 { 8842 root_0 = (CommonTree)adaptor.nil(); 8843 8844 8845 INSTRUCTION_FORMAT12x235=(Token)match(input,INSTRUCTION_FORMAT12x,FOLLOW_INSTRUCTION_FORMAT12x_in_instruction_format12x3655); 8846 INSTRUCTION_FORMAT12x235_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT12x235); 8847 adaptor.addChild(root_0, INSTRUCTION_FORMAT12x235_tree); 8848 8849 } 8850 break; 8851 case 2 : 8852 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:784:5: INSTRUCTION_FORMAT12x_OR_ID 8853 { 8854 INSTRUCTION_FORMAT12x_OR_ID236=(Token)match(input,INSTRUCTION_FORMAT12x_OR_ID,FOLLOW_INSTRUCTION_FORMAT12x_OR_ID_in_instruction_format12x3661); 8855 stream_INSTRUCTION_FORMAT12x_OR_ID.add(INSTRUCTION_FORMAT12x_OR_ID236); 8856 8857 // AST REWRITE 8858 // elements: 8859 // token labels: 8860 // rule labels: retval 8861 // token list labels: 8862 // rule list labels: 8863 // wildcard labels: 8864 retval.tree = root_0; 8865 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 8866 8867 root_0 = (CommonTree)adaptor.nil(); 8868 // 784:33: -> INSTRUCTION_FORMAT12x[$INSTRUCTION_FORMAT12x_OR_ID] 8869 { 8870 adaptor.addChild(root_0, (CommonTree)adaptor.create(INSTRUCTION_FORMAT12x, INSTRUCTION_FORMAT12x_OR_ID236)); 8871 } 8872 8873 8874 retval.tree = root_0; 8875 8876 } 8877 break; 8878 8879 } 8880 retval.stop = input.LT(-1); 8881 8882 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8883 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8884 8885 } 8886 catch (RecognitionException re) { 8887 reportError(re); 8888 recover(input,re); 8889 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8890 } 8891 finally { 8892 // do for sure before leaving 8893 } 8894 return retval; 8895 } 8896 // $ANTLR end "instruction_format12x" 8897 8898 8899 public static class instruction_format22s_return extends ParserRuleReturnScope { 8900 CommonTree tree; 8901 @Override 8902 public CommonTree getTree() { return tree; } 8903 }; 8904 8905 8906 // $ANTLR start "instruction_format22s" 8907 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:786:1: instruction_format22s : ( INSTRUCTION_FORMAT22s | INSTRUCTION_FORMAT22s_OR_ID -> INSTRUCTION_FORMAT22s[$INSTRUCTION_FORMAT22s_OR_ID] ); 8908 public final smaliParser.instruction_format22s_return instruction_format22s() throws RecognitionException { 8909 smaliParser.instruction_format22s_return retval = new smaliParser.instruction_format22s_return(); 8910 retval.start = input.LT(1); 8911 8912 CommonTree root_0 = null; 8913 8914 Token INSTRUCTION_FORMAT22s237=null; 8915 Token INSTRUCTION_FORMAT22s_OR_ID238=null; 8916 8917 CommonTree INSTRUCTION_FORMAT22s237_tree=null; 8918 CommonTree INSTRUCTION_FORMAT22s_OR_ID238_tree=null; 8919 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22s_OR_ID=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22s_OR_ID"); 8920 8921 try { 8922 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:787:3: ( INSTRUCTION_FORMAT22s | INSTRUCTION_FORMAT22s_OR_ID -> INSTRUCTION_FORMAT22s[$INSTRUCTION_FORMAT22s_OR_ID] ) 8923 int alt47=2; 8924 int LA47_0 = input.LA(1); 8925 if ( (LA47_0==INSTRUCTION_FORMAT22s) ) { 8926 alt47=1; 8927 } 8928 else if ( (LA47_0==INSTRUCTION_FORMAT22s_OR_ID) ) { 8929 alt47=2; 8930 } 8931 8932 else { 8933 NoViableAltException nvae = 8934 new NoViableAltException("", 47, 0, input); 8935 throw nvae; 8936 } 8937 8938 switch (alt47) { 8939 case 1 : 8940 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:787:5: INSTRUCTION_FORMAT22s 8941 { 8942 root_0 = (CommonTree)adaptor.nil(); 8943 8944 8945 INSTRUCTION_FORMAT22s237=(Token)match(input,INSTRUCTION_FORMAT22s,FOLLOW_INSTRUCTION_FORMAT22s_in_instruction_format22s3676); 8946 INSTRUCTION_FORMAT22s237_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT22s237); 8947 adaptor.addChild(root_0, INSTRUCTION_FORMAT22s237_tree); 8948 8949 } 8950 break; 8951 case 2 : 8952 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:788:5: INSTRUCTION_FORMAT22s_OR_ID 8953 { 8954 INSTRUCTION_FORMAT22s_OR_ID238=(Token)match(input,INSTRUCTION_FORMAT22s_OR_ID,FOLLOW_INSTRUCTION_FORMAT22s_OR_ID_in_instruction_format22s3682); 8955 stream_INSTRUCTION_FORMAT22s_OR_ID.add(INSTRUCTION_FORMAT22s_OR_ID238); 8956 8957 // AST REWRITE 8958 // elements: 8959 // token labels: 8960 // rule labels: retval 8961 // token list labels: 8962 // rule list labels: 8963 // wildcard labels: 8964 retval.tree = root_0; 8965 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 8966 8967 root_0 = (CommonTree)adaptor.nil(); 8968 // 788:33: -> INSTRUCTION_FORMAT22s[$INSTRUCTION_FORMAT22s_OR_ID] 8969 { 8970 adaptor.addChild(root_0, (CommonTree)adaptor.create(INSTRUCTION_FORMAT22s, INSTRUCTION_FORMAT22s_OR_ID238)); 8971 } 8972 8973 8974 retval.tree = root_0; 8975 8976 } 8977 break; 8978 8979 } 8980 retval.stop = input.LT(-1); 8981 8982 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 8983 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 8984 8985 } 8986 catch (RecognitionException re) { 8987 reportError(re); 8988 recover(input,re); 8989 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 8990 } 8991 finally { 8992 // do for sure before leaving 8993 } 8994 return retval; 8995 } 8996 // $ANTLR end "instruction_format22s" 8997 8998 8999 public static class instruction_format31i_return extends ParserRuleReturnScope { 9000 CommonTree tree; 9001 @Override 9002 public CommonTree getTree() { return tree; } 9003 }; 9004 9005 9006 // $ANTLR start "instruction_format31i" 9007 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:790:1: instruction_format31i : ( INSTRUCTION_FORMAT31i | INSTRUCTION_FORMAT31i_OR_ID -> INSTRUCTION_FORMAT31i[$INSTRUCTION_FORMAT31i_OR_ID] ); 9008 public final smaliParser.instruction_format31i_return instruction_format31i() throws RecognitionException { 9009 smaliParser.instruction_format31i_return retval = new smaliParser.instruction_format31i_return(); 9010 retval.start = input.LT(1); 9011 9012 CommonTree root_0 = null; 9013 9014 Token INSTRUCTION_FORMAT31i239=null; 9015 Token INSTRUCTION_FORMAT31i_OR_ID240=null; 9016 9017 CommonTree INSTRUCTION_FORMAT31i239_tree=null; 9018 CommonTree INSTRUCTION_FORMAT31i_OR_ID240_tree=null; 9019 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT31i_OR_ID=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT31i_OR_ID"); 9020 9021 try { 9022 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:791:3: ( INSTRUCTION_FORMAT31i | INSTRUCTION_FORMAT31i_OR_ID -> INSTRUCTION_FORMAT31i[$INSTRUCTION_FORMAT31i_OR_ID] ) 9023 int alt48=2; 9024 int LA48_0 = input.LA(1); 9025 if ( (LA48_0==INSTRUCTION_FORMAT31i) ) { 9026 alt48=1; 9027 } 9028 else if ( (LA48_0==INSTRUCTION_FORMAT31i_OR_ID) ) { 9029 alt48=2; 9030 } 9031 9032 else { 9033 NoViableAltException nvae = 9034 new NoViableAltException("", 48, 0, input); 9035 throw nvae; 9036 } 9037 9038 switch (alt48) { 9039 case 1 : 9040 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:791:5: INSTRUCTION_FORMAT31i 9041 { 9042 root_0 = (CommonTree)adaptor.nil(); 9043 9044 9045 INSTRUCTION_FORMAT31i239=(Token)match(input,INSTRUCTION_FORMAT31i,FOLLOW_INSTRUCTION_FORMAT31i_in_instruction_format31i3697); 9046 INSTRUCTION_FORMAT31i239_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT31i239); 9047 adaptor.addChild(root_0, INSTRUCTION_FORMAT31i239_tree); 9048 9049 } 9050 break; 9051 case 2 : 9052 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:792:5: INSTRUCTION_FORMAT31i_OR_ID 9053 { 9054 INSTRUCTION_FORMAT31i_OR_ID240=(Token)match(input,INSTRUCTION_FORMAT31i_OR_ID,FOLLOW_INSTRUCTION_FORMAT31i_OR_ID_in_instruction_format31i3703); 9055 stream_INSTRUCTION_FORMAT31i_OR_ID.add(INSTRUCTION_FORMAT31i_OR_ID240); 9056 9057 // AST REWRITE 9058 // elements: 9059 // token labels: 9060 // rule labels: retval 9061 // token list labels: 9062 // rule list labels: 9063 // wildcard labels: 9064 retval.tree = root_0; 9065 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 9066 9067 root_0 = (CommonTree)adaptor.nil(); 9068 // 792:33: -> INSTRUCTION_FORMAT31i[$INSTRUCTION_FORMAT31i_OR_ID] 9069 { 9070 adaptor.addChild(root_0, (CommonTree)adaptor.create(INSTRUCTION_FORMAT31i, INSTRUCTION_FORMAT31i_OR_ID240)); 9071 } 9072 9073 9074 retval.tree = root_0; 9075 9076 } 9077 break; 9078 9079 } 9080 retval.stop = input.LT(-1); 9081 9082 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 9083 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 9084 9085 } 9086 catch (RecognitionException re) { 9087 reportError(re); 9088 recover(input,re); 9089 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 9090 } 9091 finally { 9092 // do for sure before leaving 9093 } 9094 return retval; 9095 } 9096 // $ANTLR end "instruction_format31i" 9097 9098 9099 public static class instruction_return extends ParserRuleReturnScope { 9100 CommonTree tree; 9101 @Override 9102 public CommonTree getTree() { return tree; } 9103 }; 9104 9105 9106 // $ANTLR start "instruction" 9107 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:796:1: instruction : ( insn_format10t | insn_format10x | insn_format10x_odex | insn_format11n | insn_format11x | insn_format12x | insn_format20bc | insn_format20t | insn_format21c_field | insn_format21c_field_odex | insn_format21c_string | insn_format21c_type | insn_format21ih | insn_format21lh | insn_format21s | insn_format21t | insn_format22b | insn_format22c_field | insn_format22c_field_odex | insn_format22c_type | insn_format22cs_field | insn_format22s | insn_format22t | insn_format22x | insn_format23x | insn_format30t | insn_format31c | insn_format31i | insn_format31t | insn_format32x | insn_format35c_method | insn_format35c_type | insn_format35c_method_odex | insn_format35mi_method | insn_format35ms_method | insn_format3rc_method | insn_format3rc_method_odex | insn_format3rc_type | insn_format3rmi_method | insn_format3rms_method | insn_format51l | insn_array_data_directive | insn_packed_switch_directive | insn_sparse_switch_directive ); 9108 public final smaliParser.instruction_return instruction() throws RecognitionException { 9109 smaliParser.instruction_return retval = new smaliParser.instruction_return(); 9110 retval.start = input.LT(1); 9111 9112 CommonTree root_0 = null; 9113 9114 ParserRuleReturnScope insn_format10t241 =null; 9115 ParserRuleReturnScope insn_format10x242 =null; 9116 ParserRuleReturnScope insn_format10x_odex243 =null; 9117 ParserRuleReturnScope insn_format11n244 =null; 9118 ParserRuleReturnScope insn_format11x245 =null; 9119 ParserRuleReturnScope insn_format12x246 =null; 9120 ParserRuleReturnScope insn_format20bc247 =null; 9121 ParserRuleReturnScope insn_format20t248 =null; 9122 ParserRuleReturnScope insn_format21c_field249 =null; 9123 ParserRuleReturnScope insn_format21c_field_odex250 =null; 9124 ParserRuleReturnScope insn_format21c_string251 =null; 9125 ParserRuleReturnScope insn_format21c_type252 =null; 9126 ParserRuleReturnScope insn_format21ih253 =null; 9127 ParserRuleReturnScope insn_format21lh254 =null; 9128 ParserRuleReturnScope insn_format21s255 =null; 9129 ParserRuleReturnScope insn_format21t256 =null; 9130 ParserRuleReturnScope insn_format22b257 =null; 9131 ParserRuleReturnScope insn_format22c_field258 =null; 9132 ParserRuleReturnScope insn_format22c_field_odex259 =null; 9133 ParserRuleReturnScope insn_format22c_type260 =null; 9134 ParserRuleReturnScope insn_format22cs_field261 =null; 9135 ParserRuleReturnScope insn_format22s262 =null; 9136 ParserRuleReturnScope insn_format22t263 =null; 9137 ParserRuleReturnScope insn_format22x264 =null; 9138 ParserRuleReturnScope insn_format23x265 =null; 9139 ParserRuleReturnScope insn_format30t266 =null; 9140 ParserRuleReturnScope insn_format31c267 =null; 9141 ParserRuleReturnScope insn_format31i268 =null; 9142 ParserRuleReturnScope insn_format31t269 =null; 9143 ParserRuleReturnScope insn_format32x270 =null; 9144 ParserRuleReturnScope insn_format35c_method271 =null; 9145 ParserRuleReturnScope insn_format35c_type272 =null; 9146 ParserRuleReturnScope insn_format35c_method_odex273 =null; 9147 ParserRuleReturnScope insn_format35mi_method274 =null; 9148 ParserRuleReturnScope insn_format35ms_method275 =null; 9149 ParserRuleReturnScope insn_format3rc_method276 =null; 9150 ParserRuleReturnScope insn_format3rc_method_odex277 =null; 9151 ParserRuleReturnScope insn_format3rc_type278 =null; 9152 ParserRuleReturnScope insn_format3rmi_method279 =null; 9153 ParserRuleReturnScope insn_format3rms_method280 =null; 9154 ParserRuleReturnScope insn_format51l281 =null; 9155 ParserRuleReturnScope insn_array_data_directive282 =null; 9156 ParserRuleReturnScope insn_packed_switch_directive283 =null; 9157 ParserRuleReturnScope insn_sparse_switch_directive284 =null; 9158 9159 9160 try { 9161 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:797:3: ( insn_format10t | insn_format10x | insn_format10x_odex | insn_format11n | insn_format11x | insn_format12x | insn_format20bc | insn_format20t | insn_format21c_field | insn_format21c_field_odex | insn_format21c_string | insn_format21c_type | insn_format21ih | insn_format21lh | insn_format21s | insn_format21t | insn_format22b | insn_format22c_field | insn_format22c_field_odex | insn_format22c_type | insn_format22cs_field | insn_format22s | insn_format22t | insn_format22x | insn_format23x | insn_format30t | insn_format31c | insn_format31i | insn_format31t | insn_format32x | insn_format35c_method | insn_format35c_type | insn_format35c_method_odex | insn_format35mi_method | insn_format35ms_method | insn_format3rc_method | insn_format3rc_method_odex | insn_format3rc_type | insn_format3rmi_method | insn_format3rms_method | insn_format51l | insn_array_data_directive | insn_packed_switch_directive | insn_sparse_switch_directive ) 9162 int alt49=44; 9163 switch ( input.LA(1) ) { 9164 case INSTRUCTION_FORMAT10t: 9165 { 9166 alt49=1; 9167 } 9168 break; 9169 case INSTRUCTION_FORMAT10x: 9170 { 9171 alt49=2; 9172 } 9173 break; 9174 case INSTRUCTION_FORMAT10x_ODEX: 9175 { 9176 alt49=3; 9177 } 9178 break; 9179 case INSTRUCTION_FORMAT11n: 9180 { 9181 alt49=4; 9182 } 9183 break; 9184 case INSTRUCTION_FORMAT11x: 9185 { 9186 alt49=5; 9187 } 9188 break; 9189 case INSTRUCTION_FORMAT12x: 9190 case INSTRUCTION_FORMAT12x_OR_ID: 9191 { 9192 alt49=6; 9193 } 9194 break; 9195 case INSTRUCTION_FORMAT20bc: 9196 { 9197 alt49=7; 9198 } 9199 break; 9200 case INSTRUCTION_FORMAT20t: 9201 { 9202 alt49=8; 9203 } 9204 break; 9205 case INSTRUCTION_FORMAT21c_FIELD: 9206 { 9207 alt49=9; 9208 } 9209 break; 9210 case INSTRUCTION_FORMAT21c_FIELD_ODEX: 9211 { 9212 alt49=10; 9213 } 9214 break; 9215 case INSTRUCTION_FORMAT21c_STRING: 9216 { 9217 alt49=11; 9218 } 9219 break; 9220 case INSTRUCTION_FORMAT21c_TYPE: 9221 { 9222 alt49=12; 9223 } 9224 break; 9225 case INSTRUCTION_FORMAT21ih: 9226 { 9227 alt49=13; 9228 } 9229 break; 9230 case INSTRUCTION_FORMAT21lh: 9231 { 9232 alt49=14; 9233 } 9234 break; 9235 case INSTRUCTION_FORMAT21s: 9236 { 9237 alt49=15; 9238 } 9239 break; 9240 case INSTRUCTION_FORMAT21t: 9241 { 9242 alt49=16; 9243 } 9244 break; 9245 case INSTRUCTION_FORMAT22b: 9246 { 9247 alt49=17; 9248 } 9249 break; 9250 case INSTRUCTION_FORMAT22c_FIELD: 9251 { 9252 alt49=18; 9253 } 9254 break; 9255 case INSTRUCTION_FORMAT22c_FIELD_ODEX: 9256 { 9257 alt49=19; 9258 } 9259 break; 9260 case INSTRUCTION_FORMAT22c_TYPE: 9261 { 9262 alt49=20; 9263 } 9264 break; 9265 case INSTRUCTION_FORMAT22cs_FIELD: 9266 { 9267 alt49=21; 9268 } 9269 break; 9270 case INSTRUCTION_FORMAT22s: 9271 case INSTRUCTION_FORMAT22s_OR_ID: 9272 { 9273 alt49=22; 9274 } 9275 break; 9276 case INSTRUCTION_FORMAT22t: 9277 { 9278 alt49=23; 9279 } 9280 break; 9281 case INSTRUCTION_FORMAT22x: 9282 { 9283 alt49=24; 9284 } 9285 break; 9286 case INSTRUCTION_FORMAT23x: 9287 { 9288 alt49=25; 9289 } 9290 break; 9291 case INSTRUCTION_FORMAT30t: 9292 { 9293 alt49=26; 9294 } 9295 break; 9296 case INSTRUCTION_FORMAT31c: 9297 { 9298 alt49=27; 9299 } 9300 break; 9301 case INSTRUCTION_FORMAT31i: 9302 case INSTRUCTION_FORMAT31i_OR_ID: 9303 { 9304 alt49=28; 9305 } 9306 break; 9307 case INSTRUCTION_FORMAT31t: 9308 { 9309 alt49=29; 9310 } 9311 break; 9312 case INSTRUCTION_FORMAT32x: 9313 { 9314 alt49=30; 9315 } 9316 break; 9317 case INSTRUCTION_FORMAT35c_METHOD: 9318 { 9319 alt49=31; 9320 } 9321 break; 9322 case INSTRUCTION_FORMAT35c_TYPE: 9323 { 9324 alt49=32; 9325 } 9326 break; 9327 case INSTRUCTION_FORMAT35c_METHOD_ODEX: 9328 { 9329 alt49=33; 9330 } 9331 break; 9332 case INSTRUCTION_FORMAT35mi_METHOD: 9333 { 9334 alt49=34; 9335 } 9336 break; 9337 case INSTRUCTION_FORMAT35ms_METHOD: 9338 { 9339 alt49=35; 9340 } 9341 break; 9342 case INSTRUCTION_FORMAT3rc_METHOD: 9343 { 9344 alt49=36; 9345 } 9346 break; 9347 case INSTRUCTION_FORMAT3rc_METHOD_ODEX: 9348 { 9349 alt49=37; 9350 } 9351 break; 9352 case INSTRUCTION_FORMAT3rc_TYPE: 9353 { 9354 alt49=38; 9355 } 9356 break; 9357 case INSTRUCTION_FORMAT3rmi_METHOD: 9358 { 9359 alt49=39; 9360 } 9361 break; 9362 case INSTRUCTION_FORMAT3rms_METHOD: 9363 { 9364 alt49=40; 9365 } 9366 break; 9367 case INSTRUCTION_FORMAT51l: 9368 { 9369 alt49=41; 9370 } 9371 break; 9372 case ARRAY_DATA_DIRECTIVE: 9373 { 9374 alt49=42; 9375 } 9376 break; 9377 case PACKED_SWITCH_DIRECTIVE: 9378 { 9379 alt49=43; 9380 } 9381 break; 9382 case SPARSE_SWITCH_DIRECTIVE: 9383 { 9384 alt49=44; 9385 } 9386 break; 9387 default: 9388 NoViableAltException nvae = 9389 new NoViableAltException("", 49, 0, input); 9390 throw nvae; 9391 } 9392 switch (alt49) { 9393 case 1 : 9394 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:797:5: insn_format10t 9395 { 9396 root_0 = (CommonTree)adaptor.nil(); 9397 9398 9399 pushFollow(FOLLOW_insn_format10t_in_instruction3720); 9400 insn_format10t241=insn_format10t(); 9401 state._fsp--; 9402 9403 adaptor.addChild(root_0, insn_format10t241.getTree()); 9404 9405 } 9406 break; 9407 case 2 : 9408 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:798:5: insn_format10x 9409 { 9410 root_0 = (CommonTree)adaptor.nil(); 9411 9412 9413 pushFollow(FOLLOW_insn_format10x_in_instruction3726); 9414 insn_format10x242=insn_format10x(); 9415 state._fsp--; 9416 9417 adaptor.addChild(root_0, insn_format10x242.getTree()); 9418 9419 } 9420 break; 9421 case 3 : 9422 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:799:5: insn_format10x_odex 9423 { 9424 root_0 = (CommonTree)adaptor.nil(); 9425 9426 9427 pushFollow(FOLLOW_insn_format10x_odex_in_instruction3732); 9428 insn_format10x_odex243=insn_format10x_odex(); 9429 state._fsp--; 9430 9431 adaptor.addChild(root_0, insn_format10x_odex243.getTree()); 9432 9433 } 9434 break; 9435 case 4 : 9436 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:800:5: insn_format11n 9437 { 9438 root_0 = (CommonTree)adaptor.nil(); 9439 9440 9441 pushFollow(FOLLOW_insn_format11n_in_instruction3738); 9442 insn_format11n244=insn_format11n(); 9443 state._fsp--; 9444 9445 adaptor.addChild(root_0, insn_format11n244.getTree()); 9446 9447 } 9448 break; 9449 case 5 : 9450 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:801:5: insn_format11x 9451 { 9452 root_0 = (CommonTree)adaptor.nil(); 9453 9454 9455 pushFollow(FOLLOW_insn_format11x_in_instruction3744); 9456 insn_format11x245=insn_format11x(); 9457 state._fsp--; 9458 9459 adaptor.addChild(root_0, insn_format11x245.getTree()); 9460 9461 } 9462 break; 9463 case 6 : 9464 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:802:5: insn_format12x 9465 { 9466 root_0 = (CommonTree)adaptor.nil(); 9467 9468 9469 pushFollow(FOLLOW_insn_format12x_in_instruction3750); 9470 insn_format12x246=insn_format12x(); 9471 state._fsp--; 9472 9473 adaptor.addChild(root_0, insn_format12x246.getTree()); 9474 9475 } 9476 break; 9477 case 7 : 9478 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:803:5: insn_format20bc 9479 { 9480 root_0 = (CommonTree)adaptor.nil(); 9481 9482 9483 pushFollow(FOLLOW_insn_format20bc_in_instruction3756); 9484 insn_format20bc247=insn_format20bc(); 9485 state._fsp--; 9486 9487 adaptor.addChild(root_0, insn_format20bc247.getTree()); 9488 9489 } 9490 break; 9491 case 8 : 9492 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:804:5: insn_format20t 9493 { 9494 root_0 = (CommonTree)adaptor.nil(); 9495 9496 9497 pushFollow(FOLLOW_insn_format20t_in_instruction3762); 9498 insn_format20t248=insn_format20t(); 9499 state._fsp--; 9500 9501 adaptor.addChild(root_0, insn_format20t248.getTree()); 9502 9503 } 9504 break; 9505 case 9 : 9506 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:805:5: insn_format21c_field 9507 { 9508 root_0 = (CommonTree)adaptor.nil(); 9509 9510 9511 pushFollow(FOLLOW_insn_format21c_field_in_instruction3768); 9512 insn_format21c_field249=insn_format21c_field(); 9513 state._fsp--; 9514 9515 adaptor.addChild(root_0, insn_format21c_field249.getTree()); 9516 9517 } 9518 break; 9519 case 10 : 9520 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:806:5: insn_format21c_field_odex 9521 { 9522 root_0 = (CommonTree)adaptor.nil(); 9523 9524 9525 pushFollow(FOLLOW_insn_format21c_field_odex_in_instruction3774); 9526 insn_format21c_field_odex250=insn_format21c_field_odex(); 9527 state._fsp--; 9528 9529 adaptor.addChild(root_0, insn_format21c_field_odex250.getTree()); 9530 9531 } 9532 break; 9533 case 11 : 9534 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:807:5: insn_format21c_string 9535 { 9536 root_0 = (CommonTree)adaptor.nil(); 9537 9538 9539 pushFollow(FOLLOW_insn_format21c_string_in_instruction3780); 9540 insn_format21c_string251=insn_format21c_string(); 9541 state._fsp--; 9542 9543 adaptor.addChild(root_0, insn_format21c_string251.getTree()); 9544 9545 } 9546 break; 9547 case 12 : 9548 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:808:5: insn_format21c_type 9549 { 9550 root_0 = (CommonTree)adaptor.nil(); 9551 9552 9553 pushFollow(FOLLOW_insn_format21c_type_in_instruction3786); 9554 insn_format21c_type252=insn_format21c_type(); 9555 state._fsp--; 9556 9557 adaptor.addChild(root_0, insn_format21c_type252.getTree()); 9558 9559 } 9560 break; 9561 case 13 : 9562 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:809:5: insn_format21ih 9563 { 9564 root_0 = (CommonTree)adaptor.nil(); 9565 9566 9567 pushFollow(FOLLOW_insn_format21ih_in_instruction3792); 9568 insn_format21ih253=insn_format21ih(); 9569 state._fsp--; 9570 9571 adaptor.addChild(root_0, insn_format21ih253.getTree()); 9572 9573 } 9574 break; 9575 case 14 : 9576 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:810:5: insn_format21lh 9577 { 9578 root_0 = (CommonTree)adaptor.nil(); 9579 9580 9581 pushFollow(FOLLOW_insn_format21lh_in_instruction3798); 9582 insn_format21lh254=insn_format21lh(); 9583 state._fsp--; 9584 9585 adaptor.addChild(root_0, insn_format21lh254.getTree()); 9586 9587 } 9588 break; 9589 case 15 : 9590 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:811:5: insn_format21s 9591 { 9592 root_0 = (CommonTree)adaptor.nil(); 9593 9594 9595 pushFollow(FOLLOW_insn_format21s_in_instruction3804); 9596 insn_format21s255=insn_format21s(); 9597 state._fsp--; 9598 9599 adaptor.addChild(root_0, insn_format21s255.getTree()); 9600 9601 } 9602 break; 9603 case 16 : 9604 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:812:5: insn_format21t 9605 { 9606 root_0 = (CommonTree)adaptor.nil(); 9607 9608 9609 pushFollow(FOLLOW_insn_format21t_in_instruction3810); 9610 insn_format21t256=insn_format21t(); 9611 state._fsp--; 9612 9613 adaptor.addChild(root_0, insn_format21t256.getTree()); 9614 9615 } 9616 break; 9617 case 17 : 9618 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:813:5: insn_format22b 9619 { 9620 root_0 = (CommonTree)adaptor.nil(); 9621 9622 9623 pushFollow(FOLLOW_insn_format22b_in_instruction3816); 9624 insn_format22b257=insn_format22b(); 9625 state._fsp--; 9626 9627 adaptor.addChild(root_0, insn_format22b257.getTree()); 9628 9629 } 9630 break; 9631 case 18 : 9632 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:814:5: insn_format22c_field 9633 { 9634 root_0 = (CommonTree)adaptor.nil(); 9635 9636 9637 pushFollow(FOLLOW_insn_format22c_field_in_instruction3822); 9638 insn_format22c_field258=insn_format22c_field(); 9639 state._fsp--; 9640 9641 adaptor.addChild(root_0, insn_format22c_field258.getTree()); 9642 9643 } 9644 break; 9645 case 19 : 9646 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:815:5: insn_format22c_field_odex 9647 { 9648 root_0 = (CommonTree)adaptor.nil(); 9649 9650 9651 pushFollow(FOLLOW_insn_format22c_field_odex_in_instruction3828); 9652 insn_format22c_field_odex259=insn_format22c_field_odex(); 9653 state._fsp--; 9654 9655 adaptor.addChild(root_0, insn_format22c_field_odex259.getTree()); 9656 9657 } 9658 break; 9659 case 20 : 9660 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:816:5: insn_format22c_type 9661 { 9662 root_0 = (CommonTree)adaptor.nil(); 9663 9664 9665 pushFollow(FOLLOW_insn_format22c_type_in_instruction3834); 9666 insn_format22c_type260=insn_format22c_type(); 9667 state._fsp--; 9668 9669 adaptor.addChild(root_0, insn_format22c_type260.getTree()); 9670 9671 } 9672 break; 9673 case 21 : 9674 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:817:5: insn_format22cs_field 9675 { 9676 root_0 = (CommonTree)adaptor.nil(); 9677 9678 9679 pushFollow(FOLLOW_insn_format22cs_field_in_instruction3840); 9680 insn_format22cs_field261=insn_format22cs_field(); 9681 state._fsp--; 9682 9683 adaptor.addChild(root_0, insn_format22cs_field261.getTree()); 9684 9685 } 9686 break; 9687 case 22 : 9688 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:818:5: insn_format22s 9689 { 9690 root_0 = (CommonTree)adaptor.nil(); 9691 9692 9693 pushFollow(FOLLOW_insn_format22s_in_instruction3846); 9694 insn_format22s262=insn_format22s(); 9695 state._fsp--; 9696 9697 adaptor.addChild(root_0, insn_format22s262.getTree()); 9698 9699 } 9700 break; 9701 case 23 : 9702 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:819:5: insn_format22t 9703 { 9704 root_0 = (CommonTree)adaptor.nil(); 9705 9706 9707 pushFollow(FOLLOW_insn_format22t_in_instruction3852); 9708 insn_format22t263=insn_format22t(); 9709 state._fsp--; 9710 9711 adaptor.addChild(root_0, insn_format22t263.getTree()); 9712 9713 } 9714 break; 9715 case 24 : 9716 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:820:5: insn_format22x 9717 { 9718 root_0 = (CommonTree)adaptor.nil(); 9719 9720 9721 pushFollow(FOLLOW_insn_format22x_in_instruction3858); 9722 insn_format22x264=insn_format22x(); 9723 state._fsp--; 9724 9725 adaptor.addChild(root_0, insn_format22x264.getTree()); 9726 9727 } 9728 break; 9729 case 25 : 9730 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:821:5: insn_format23x 9731 { 9732 root_0 = (CommonTree)adaptor.nil(); 9733 9734 9735 pushFollow(FOLLOW_insn_format23x_in_instruction3864); 9736 insn_format23x265=insn_format23x(); 9737 state._fsp--; 9738 9739 adaptor.addChild(root_0, insn_format23x265.getTree()); 9740 9741 } 9742 break; 9743 case 26 : 9744 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:822:5: insn_format30t 9745 { 9746 root_0 = (CommonTree)adaptor.nil(); 9747 9748 9749 pushFollow(FOLLOW_insn_format30t_in_instruction3870); 9750 insn_format30t266=insn_format30t(); 9751 state._fsp--; 9752 9753 adaptor.addChild(root_0, insn_format30t266.getTree()); 9754 9755 } 9756 break; 9757 case 27 : 9758 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:823:5: insn_format31c 9759 { 9760 root_0 = (CommonTree)adaptor.nil(); 9761 9762 9763 pushFollow(FOLLOW_insn_format31c_in_instruction3876); 9764 insn_format31c267=insn_format31c(); 9765 state._fsp--; 9766 9767 adaptor.addChild(root_0, insn_format31c267.getTree()); 9768 9769 } 9770 break; 9771 case 28 : 9772 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:824:5: insn_format31i 9773 { 9774 root_0 = (CommonTree)adaptor.nil(); 9775 9776 9777 pushFollow(FOLLOW_insn_format31i_in_instruction3882); 9778 insn_format31i268=insn_format31i(); 9779 state._fsp--; 9780 9781 adaptor.addChild(root_0, insn_format31i268.getTree()); 9782 9783 } 9784 break; 9785 case 29 : 9786 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:825:5: insn_format31t 9787 { 9788 root_0 = (CommonTree)adaptor.nil(); 9789 9790 9791 pushFollow(FOLLOW_insn_format31t_in_instruction3888); 9792 insn_format31t269=insn_format31t(); 9793 state._fsp--; 9794 9795 adaptor.addChild(root_0, insn_format31t269.getTree()); 9796 9797 } 9798 break; 9799 case 30 : 9800 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:826:5: insn_format32x 9801 { 9802 root_0 = (CommonTree)adaptor.nil(); 9803 9804 9805 pushFollow(FOLLOW_insn_format32x_in_instruction3894); 9806 insn_format32x270=insn_format32x(); 9807 state._fsp--; 9808 9809 adaptor.addChild(root_0, insn_format32x270.getTree()); 9810 9811 } 9812 break; 9813 case 31 : 9814 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:827:5: insn_format35c_method 9815 { 9816 root_0 = (CommonTree)adaptor.nil(); 9817 9818 9819 pushFollow(FOLLOW_insn_format35c_method_in_instruction3900); 9820 insn_format35c_method271=insn_format35c_method(); 9821 state._fsp--; 9822 9823 adaptor.addChild(root_0, insn_format35c_method271.getTree()); 9824 9825 } 9826 break; 9827 case 32 : 9828 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:828:5: insn_format35c_type 9829 { 9830 root_0 = (CommonTree)adaptor.nil(); 9831 9832 9833 pushFollow(FOLLOW_insn_format35c_type_in_instruction3906); 9834 insn_format35c_type272=insn_format35c_type(); 9835 state._fsp--; 9836 9837 adaptor.addChild(root_0, insn_format35c_type272.getTree()); 9838 9839 } 9840 break; 9841 case 33 : 9842 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:829:5: insn_format35c_method_odex 9843 { 9844 root_0 = (CommonTree)adaptor.nil(); 9845 9846 9847 pushFollow(FOLLOW_insn_format35c_method_odex_in_instruction3912); 9848 insn_format35c_method_odex273=insn_format35c_method_odex(); 9849 state._fsp--; 9850 9851 adaptor.addChild(root_0, insn_format35c_method_odex273.getTree()); 9852 9853 } 9854 break; 9855 case 34 : 9856 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:830:5: insn_format35mi_method 9857 { 9858 root_0 = (CommonTree)adaptor.nil(); 9859 9860 9861 pushFollow(FOLLOW_insn_format35mi_method_in_instruction3918); 9862 insn_format35mi_method274=insn_format35mi_method(); 9863 state._fsp--; 9864 9865 adaptor.addChild(root_0, insn_format35mi_method274.getTree()); 9866 9867 } 9868 break; 9869 case 35 : 9870 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:831:5: insn_format35ms_method 9871 { 9872 root_0 = (CommonTree)adaptor.nil(); 9873 9874 9875 pushFollow(FOLLOW_insn_format35ms_method_in_instruction3924); 9876 insn_format35ms_method275=insn_format35ms_method(); 9877 state._fsp--; 9878 9879 adaptor.addChild(root_0, insn_format35ms_method275.getTree()); 9880 9881 } 9882 break; 9883 case 36 : 9884 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:832:5: insn_format3rc_method 9885 { 9886 root_0 = (CommonTree)adaptor.nil(); 9887 9888 9889 pushFollow(FOLLOW_insn_format3rc_method_in_instruction3930); 9890 insn_format3rc_method276=insn_format3rc_method(); 9891 state._fsp--; 9892 9893 adaptor.addChild(root_0, insn_format3rc_method276.getTree()); 9894 9895 } 9896 break; 9897 case 37 : 9898 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:833:5: insn_format3rc_method_odex 9899 { 9900 root_0 = (CommonTree)adaptor.nil(); 9901 9902 9903 pushFollow(FOLLOW_insn_format3rc_method_odex_in_instruction3936); 9904 insn_format3rc_method_odex277=insn_format3rc_method_odex(); 9905 state._fsp--; 9906 9907 adaptor.addChild(root_0, insn_format3rc_method_odex277.getTree()); 9908 9909 } 9910 break; 9911 case 38 : 9912 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:834:5: insn_format3rc_type 9913 { 9914 root_0 = (CommonTree)adaptor.nil(); 9915 9916 9917 pushFollow(FOLLOW_insn_format3rc_type_in_instruction3942); 9918 insn_format3rc_type278=insn_format3rc_type(); 9919 state._fsp--; 9920 9921 adaptor.addChild(root_0, insn_format3rc_type278.getTree()); 9922 9923 } 9924 break; 9925 case 39 : 9926 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:835:5: insn_format3rmi_method 9927 { 9928 root_0 = (CommonTree)adaptor.nil(); 9929 9930 9931 pushFollow(FOLLOW_insn_format3rmi_method_in_instruction3948); 9932 insn_format3rmi_method279=insn_format3rmi_method(); 9933 state._fsp--; 9934 9935 adaptor.addChild(root_0, insn_format3rmi_method279.getTree()); 9936 9937 } 9938 break; 9939 case 40 : 9940 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:836:5: insn_format3rms_method 9941 { 9942 root_0 = (CommonTree)adaptor.nil(); 9943 9944 9945 pushFollow(FOLLOW_insn_format3rms_method_in_instruction3954); 9946 insn_format3rms_method280=insn_format3rms_method(); 9947 state._fsp--; 9948 9949 adaptor.addChild(root_0, insn_format3rms_method280.getTree()); 9950 9951 } 9952 break; 9953 case 41 : 9954 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:837:5: insn_format51l 9955 { 9956 root_0 = (CommonTree)adaptor.nil(); 9957 9958 9959 pushFollow(FOLLOW_insn_format51l_in_instruction3960); 9960 insn_format51l281=insn_format51l(); 9961 state._fsp--; 9962 9963 adaptor.addChild(root_0, insn_format51l281.getTree()); 9964 9965 } 9966 break; 9967 case 42 : 9968 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:838:5: insn_array_data_directive 9969 { 9970 root_0 = (CommonTree)adaptor.nil(); 9971 9972 9973 pushFollow(FOLLOW_insn_array_data_directive_in_instruction3966); 9974 insn_array_data_directive282=insn_array_data_directive(); 9975 state._fsp--; 9976 9977 adaptor.addChild(root_0, insn_array_data_directive282.getTree()); 9978 9979 } 9980 break; 9981 case 43 : 9982 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:839:5: insn_packed_switch_directive 9983 { 9984 root_0 = (CommonTree)adaptor.nil(); 9985 9986 9987 pushFollow(FOLLOW_insn_packed_switch_directive_in_instruction3972); 9988 insn_packed_switch_directive283=insn_packed_switch_directive(); 9989 state._fsp--; 9990 9991 adaptor.addChild(root_0, insn_packed_switch_directive283.getTree()); 9992 9993 } 9994 break; 9995 case 44 : 9996 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:840:5: insn_sparse_switch_directive 9997 { 9998 root_0 = (CommonTree)adaptor.nil(); 9999 10000 10001 pushFollow(FOLLOW_insn_sparse_switch_directive_in_instruction3978); 10002 insn_sparse_switch_directive284=insn_sparse_switch_directive(); 10003 state._fsp--; 10004 10005 adaptor.addChild(root_0, insn_sparse_switch_directive284.getTree()); 10006 10007 } 10008 break; 10009 10010 } 10011 retval.stop = input.LT(-1); 10012 10013 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10014 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10015 10016 } 10017 catch (RecognitionException re) { 10018 reportError(re); 10019 recover(input,re); 10020 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10021 } 10022 finally { 10023 // do for sure before leaving 10024 } 10025 return retval; 10026 } 10027 // $ANTLR end "instruction" 10028 10029 10030 public static class insn_format10t_return extends ParserRuleReturnScope { 10031 CommonTree tree; 10032 @Override 10033 public CommonTree getTree() { return tree; } 10034 }; 10035 10036 10037 // $ANTLR start "insn_format10t" 10038 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:842:1: insn_format10t : INSTRUCTION_FORMAT10t label_ref -> ^( I_STATEMENT_FORMAT10t[$start, \"I_STATEMENT_FORMAT10t\"] INSTRUCTION_FORMAT10t label_ref ) ; 10039 public final smaliParser.insn_format10t_return insn_format10t() throws RecognitionException { 10040 smaliParser.insn_format10t_return retval = new smaliParser.insn_format10t_return(); 10041 retval.start = input.LT(1); 10042 10043 CommonTree root_0 = null; 10044 10045 Token INSTRUCTION_FORMAT10t285=null; 10046 ParserRuleReturnScope label_ref286 =null; 10047 10048 CommonTree INSTRUCTION_FORMAT10t285_tree=null; 10049 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT10t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT10t"); 10050 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 10051 10052 try { 10053 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:843:3: ( INSTRUCTION_FORMAT10t label_ref -> ^( I_STATEMENT_FORMAT10t[$start, \"I_STATEMENT_FORMAT10t\"] INSTRUCTION_FORMAT10t label_ref ) ) 10054 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:845:5: INSTRUCTION_FORMAT10t label_ref 10055 { 10056 INSTRUCTION_FORMAT10t285=(Token)match(input,INSTRUCTION_FORMAT10t,FOLLOW_INSTRUCTION_FORMAT10t_in_insn_format10t3998); 10057 stream_INSTRUCTION_FORMAT10t.add(INSTRUCTION_FORMAT10t285); 10058 10059 pushFollow(FOLLOW_label_ref_in_insn_format10t4000); 10060 label_ref286=label_ref(); 10061 state._fsp--; 10062 10063 stream_label_ref.add(label_ref286.getTree()); 10064 // AST REWRITE 10065 // elements: label_ref, INSTRUCTION_FORMAT10t 10066 // token labels: 10067 // rule labels: retval 10068 // token list labels: 10069 // rule list labels: 10070 // wildcard labels: 10071 retval.tree = root_0; 10072 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10073 10074 root_0 = (CommonTree)adaptor.nil(); 10075 // 846:5: -> ^( I_STATEMENT_FORMAT10t[$start, \"I_STATEMENT_FORMAT10t\"] INSTRUCTION_FORMAT10t label_ref ) 10076 { 10077 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:846:8: ^( I_STATEMENT_FORMAT10t[$start, \"I_STATEMENT_FORMAT10t\"] INSTRUCTION_FORMAT10t label_ref ) 10078 { 10079 CommonTree root_1 = (CommonTree)adaptor.nil(); 10080 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT10t, (retval.start), "I_STATEMENT_FORMAT10t"), root_1); 10081 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT10t.nextNode()); 10082 adaptor.addChild(root_1, stream_label_ref.nextTree()); 10083 adaptor.addChild(root_0, root_1); 10084 } 10085 10086 } 10087 10088 10089 retval.tree = root_0; 10090 10091 } 10092 10093 retval.stop = input.LT(-1); 10094 10095 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10096 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10097 10098 } 10099 catch (RecognitionException re) { 10100 reportError(re); 10101 recover(input,re); 10102 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10103 } 10104 finally { 10105 // do for sure before leaving 10106 } 10107 return retval; 10108 } 10109 // $ANTLR end "insn_format10t" 10110 10111 10112 public static class insn_format10x_return extends ParserRuleReturnScope { 10113 CommonTree tree; 10114 @Override 10115 public CommonTree getTree() { return tree; } 10116 }; 10117 10118 10119 // $ANTLR start "insn_format10x" 10120 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:848:1: insn_format10x : INSTRUCTION_FORMAT10x -> ^( I_STATEMENT_FORMAT10x[$start, \"I_STATEMENT_FORMAT10x\"] INSTRUCTION_FORMAT10x ) ; 10121 public final smaliParser.insn_format10x_return insn_format10x() throws RecognitionException { 10122 smaliParser.insn_format10x_return retval = new smaliParser.insn_format10x_return(); 10123 retval.start = input.LT(1); 10124 10125 CommonTree root_0 = null; 10126 10127 Token INSTRUCTION_FORMAT10x287=null; 10128 10129 CommonTree INSTRUCTION_FORMAT10x287_tree=null; 10130 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT10x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT10x"); 10131 10132 try { 10133 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:849:3: ( INSTRUCTION_FORMAT10x -> ^( I_STATEMENT_FORMAT10x[$start, \"I_STATEMENT_FORMAT10x\"] INSTRUCTION_FORMAT10x ) ) 10134 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:850:5: INSTRUCTION_FORMAT10x 10135 { 10136 INSTRUCTION_FORMAT10x287=(Token)match(input,INSTRUCTION_FORMAT10x,FOLLOW_INSTRUCTION_FORMAT10x_in_insn_format10x4030); 10137 stream_INSTRUCTION_FORMAT10x.add(INSTRUCTION_FORMAT10x287); 10138 10139 // AST REWRITE 10140 // elements: INSTRUCTION_FORMAT10x 10141 // token labels: 10142 // rule labels: retval 10143 // token list labels: 10144 // rule list labels: 10145 // wildcard labels: 10146 retval.tree = root_0; 10147 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10148 10149 root_0 = (CommonTree)adaptor.nil(); 10150 // 851:5: -> ^( I_STATEMENT_FORMAT10x[$start, \"I_STATEMENT_FORMAT10x\"] INSTRUCTION_FORMAT10x ) 10151 { 10152 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:851:8: ^( I_STATEMENT_FORMAT10x[$start, \"I_STATEMENT_FORMAT10x\"] INSTRUCTION_FORMAT10x ) 10153 { 10154 CommonTree root_1 = (CommonTree)adaptor.nil(); 10155 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT10x, (retval.start), "I_STATEMENT_FORMAT10x"), root_1); 10156 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT10x.nextNode()); 10157 adaptor.addChild(root_0, root_1); 10158 } 10159 10160 } 10161 10162 10163 retval.tree = root_0; 10164 10165 } 10166 10167 retval.stop = input.LT(-1); 10168 10169 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10170 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10171 10172 } 10173 catch (RecognitionException re) { 10174 reportError(re); 10175 recover(input,re); 10176 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10177 } 10178 finally { 10179 // do for sure before leaving 10180 } 10181 return retval; 10182 } 10183 // $ANTLR end "insn_format10x" 10184 10185 10186 public static class insn_format10x_odex_return extends ParserRuleReturnScope { 10187 CommonTree tree; 10188 @Override 10189 public CommonTree getTree() { return tree; } 10190 }; 10191 10192 10193 // $ANTLR start "insn_format10x_odex" 10194 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:853:1: insn_format10x_odex : INSTRUCTION_FORMAT10x_ODEX ; 10195 public final smaliParser.insn_format10x_odex_return insn_format10x_odex() throws RecognitionException { 10196 smaliParser.insn_format10x_odex_return retval = new smaliParser.insn_format10x_odex_return(); 10197 retval.start = input.LT(1); 10198 10199 CommonTree root_0 = null; 10200 10201 Token INSTRUCTION_FORMAT10x_ODEX288=null; 10202 10203 CommonTree INSTRUCTION_FORMAT10x_ODEX288_tree=null; 10204 10205 try { 10206 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:854:3: ( INSTRUCTION_FORMAT10x_ODEX ) 10207 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:855:5: INSTRUCTION_FORMAT10x_ODEX 10208 { 10209 root_0 = (CommonTree)adaptor.nil(); 10210 10211 10212 INSTRUCTION_FORMAT10x_ODEX288=(Token)match(input,INSTRUCTION_FORMAT10x_ODEX,FOLLOW_INSTRUCTION_FORMAT10x_ODEX_in_insn_format10x_odex4058); 10213 INSTRUCTION_FORMAT10x_ODEX288_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT10x_ODEX288); 10214 adaptor.addChild(root_0, INSTRUCTION_FORMAT10x_ODEX288_tree); 10215 10216 10217 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT10x_ODEX288!=null?INSTRUCTION_FORMAT10x_ODEX288.getText():null)); 10218 10219 } 10220 10221 retval.stop = input.LT(-1); 10222 10223 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10224 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10225 10226 } 10227 catch (RecognitionException re) { 10228 reportError(re); 10229 recover(input,re); 10230 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10231 } 10232 finally { 10233 // do for sure before leaving 10234 } 10235 return retval; 10236 } 10237 // $ANTLR end "insn_format10x_odex" 10238 10239 10240 public static class insn_format11n_return extends ParserRuleReturnScope { 10241 CommonTree tree; 10242 @Override 10243 public CommonTree getTree() { return tree; } 10244 }; 10245 10246 10247 // $ANTLR start "insn_format11n" 10248 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:860:1: insn_format11n : INSTRUCTION_FORMAT11n REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT11n[$start, \"I_STATEMENT_FORMAT11n\"] INSTRUCTION_FORMAT11n REGISTER integral_literal ) ; 10249 public final smaliParser.insn_format11n_return insn_format11n() throws RecognitionException { 10250 smaliParser.insn_format11n_return retval = new smaliParser.insn_format11n_return(); 10251 retval.start = input.LT(1); 10252 10253 CommonTree root_0 = null; 10254 10255 Token INSTRUCTION_FORMAT11n289=null; 10256 Token REGISTER290=null; 10257 Token COMMA291=null; 10258 ParserRuleReturnScope integral_literal292 =null; 10259 10260 CommonTree INSTRUCTION_FORMAT11n289_tree=null; 10261 CommonTree REGISTER290_tree=null; 10262 CommonTree COMMA291_tree=null; 10263 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 10264 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 10265 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT11n=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT11n"); 10266 RewriteRuleSubtreeStream stream_integral_literal=new RewriteRuleSubtreeStream(adaptor,"rule integral_literal"); 10267 10268 try { 10269 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:861:3: ( INSTRUCTION_FORMAT11n REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT11n[$start, \"I_STATEMENT_FORMAT11n\"] INSTRUCTION_FORMAT11n REGISTER integral_literal ) ) 10270 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:862:5: INSTRUCTION_FORMAT11n REGISTER COMMA integral_literal 10271 { 10272 INSTRUCTION_FORMAT11n289=(Token)match(input,INSTRUCTION_FORMAT11n,FOLLOW_INSTRUCTION_FORMAT11n_in_insn_format11n4079); 10273 stream_INSTRUCTION_FORMAT11n.add(INSTRUCTION_FORMAT11n289); 10274 10275 REGISTER290=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format11n4081); 10276 stream_REGISTER.add(REGISTER290); 10277 10278 COMMA291=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format11n4083); 10279 stream_COMMA.add(COMMA291); 10280 10281 pushFollow(FOLLOW_integral_literal_in_insn_format11n4085); 10282 integral_literal292=integral_literal(); 10283 state._fsp--; 10284 10285 stream_integral_literal.add(integral_literal292.getTree()); 10286 // AST REWRITE 10287 // elements: REGISTER, integral_literal, INSTRUCTION_FORMAT11n 10288 // token labels: 10289 // rule labels: retval 10290 // token list labels: 10291 // rule list labels: 10292 // wildcard labels: 10293 retval.tree = root_0; 10294 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10295 10296 root_0 = (CommonTree)adaptor.nil(); 10297 // 863:5: -> ^( I_STATEMENT_FORMAT11n[$start, \"I_STATEMENT_FORMAT11n\"] INSTRUCTION_FORMAT11n REGISTER integral_literal ) 10298 { 10299 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:863:8: ^( I_STATEMENT_FORMAT11n[$start, \"I_STATEMENT_FORMAT11n\"] INSTRUCTION_FORMAT11n REGISTER integral_literal ) 10300 { 10301 CommonTree root_1 = (CommonTree)adaptor.nil(); 10302 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT11n, (retval.start), "I_STATEMENT_FORMAT11n"), root_1); 10303 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT11n.nextNode()); 10304 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 10305 adaptor.addChild(root_1, stream_integral_literal.nextTree()); 10306 adaptor.addChild(root_0, root_1); 10307 } 10308 10309 } 10310 10311 10312 retval.tree = root_0; 10313 10314 } 10315 10316 retval.stop = input.LT(-1); 10317 10318 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10319 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10320 10321 } 10322 catch (RecognitionException re) { 10323 reportError(re); 10324 recover(input,re); 10325 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10326 } 10327 finally { 10328 // do for sure before leaving 10329 } 10330 return retval; 10331 } 10332 // $ANTLR end "insn_format11n" 10333 10334 10335 public static class insn_format11x_return extends ParserRuleReturnScope { 10336 CommonTree tree; 10337 @Override 10338 public CommonTree getTree() { return tree; } 10339 }; 10340 10341 10342 // $ANTLR start "insn_format11x" 10343 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:865:1: insn_format11x : INSTRUCTION_FORMAT11x REGISTER -> ^( I_STATEMENT_FORMAT11x[$start, \"I_STATEMENT_FORMAT11x\"] INSTRUCTION_FORMAT11x REGISTER ) ; 10344 public final smaliParser.insn_format11x_return insn_format11x() throws RecognitionException { 10345 smaliParser.insn_format11x_return retval = new smaliParser.insn_format11x_return(); 10346 retval.start = input.LT(1); 10347 10348 CommonTree root_0 = null; 10349 10350 Token INSTRUCTION_FORMAT11x293=null; 10351 Token REGISTER294=null; 10352 10353 CommonTree INSTRUCTION_FORMAT11x293_tree=null; 10354 CommonTree REGISTER294_tree=null; 10355 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT11x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT11x"); 10356 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 10357 10358 try { 10359 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:866:3: ( INSTRUCTION_FORMAT11x REGISTER -> ^( I_STATEMENT_FORMAT11x[$start, \"I_STATEMENT_FORMAT11x\"] INSTRUCTION_FORMAT11x REGISTER ) ) 10360 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:867:5: INSTRUCTION_FORMAT11x REGISTER 10361 { 10362 INSTRUCTION_FORMAT11x293=(Token)match(input,INSTRUCTION_FORMAT11x,FOLLOW_INSTRUCTION_FORMAT11x_in_insn_format11x4117); 10363 stream_INSTRUCTION_FORMAT11x.add(INSTRUCTION_FORMAT11x293); 10364 10365 REGISTER294=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format11x4119); 10366 stream_REGISTER.add(REGISTER294); 10367 10368 // AST REWRITE 10369 // elements: INSTRUCTION_FORMAT11x, REGISTER 10370 // token labels: 10371 // rule labels: retval 10372 // token list labels: 10373 // rule list labels: 10374 // wildcard labels: 10375 retval.tree = root_0; 10376 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10377 10378 root_0 = (CommonTree)adaptor.nil(); 10379 // 868:5: -> ^( I_STATEMENT_FORMAT11x[$start, \"I_STATEMENT_FORMAT11x\"] INSTRUCTION_FORMAT11x REGISTER ) 10380 { 10381 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:868:8: ^( I_STATEMENT_FORMAT11x[$start, \"I_STATEMENT_FORMAT11x\"] INSTRUCTION_FORMAT11x REGISTER ) 10382 { 10383 CommonTree root_1 = (CommonTree)adaptor.nil(); 10384 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT11x, (retval.start), "I_STATEMENT_FORMAT11x"), root_1); 10385 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT11x.nextNode()); 10386 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 10387 adaptor.addChild(root_0, root_1); 10388 } 10389 10390 } 10391 10392 10393 retval.tree = root_0; 10394 10395 } 10396 10397 retval.stop = input.LT(-1); 10398 10399 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10400 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10401 10402 } 10403 catch (RecognitionException re) { 10404 reportError(re); 10405 recover(input,re); 10406 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10407 } 10408 finally { 10409 // do for sure before leaving 10410 } 10411 return retval; 10412 } 10413 // $ANTLR end "insn_format11x" 10414 10415 10416 public static class insn_format12x_return extends ParserRuleReturnScope { 10417 CommonTree tree; 10418 @Override 10419 public CommonTree getTree() { return tree; } 10420 }; 10421 10422 10423 // $ANTLR start "insn_format12x" 10424 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:870:1: insn_format12x : instruction_format12x REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT12x[$start, \"I_STATEMENT_FORMAT12x\"] instruction_format12x REGISTER REGISTER ) ; 10425 public final smaliParser.insn_format12x_return insn_format12x() throws RecognitionException { 10426 smaliParser.insn_format12x_return retval = new smaliParser.insn_format12x_return(); 10427 retval.start = input.LT(1); 10428 10429 CommonTree root_0 = null; 10430 10431 Token REGISTER296=null; 10432 Token COMMA297=null; 10433 Token REGISTER298=null; 10434 ParserRuleReturnScope instruction_format12x295 =null; 10435 10436 CommonTree REGISTER296_tree=null; 10437 CommonTree COMMA297_tree=null; 10438 CommonTree REGISTER298_tree=null; 10439 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 10440 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 10441 RewriteRuleSubtreeStream stream_instruction_format12x=new RewriteRuleSubtreeStream(adaptor,"rule instruction_format12x"); 10442 10443 try { 10444 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:871:3: ( instruction_format12x REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT12x[$start, \"I_STATEMENT_FORMAT12x\"] instruction_format12x REGISTER REGISTER ) ) 10445 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:872:5: instruction_format12x REGISTER COMMA REGISTER 10446 { 10447 pushFollow(FOLLOW_instruction_format12x_in_insn_format12x4149); 10448 instruction_format12x295=instruction_format12x(); 10449 state._fsp--; 10450 10451 stream_instruction_format12x.add(instruction_format12x295.getTree()); 10452 REGISTER296=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format12x4151); 10453 stream_REGISTER.add(REGISTER296); 10454 10455 COMMA297=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format12x4153); 10456 stream_COMMA.add(COMMA297); 10457 10458 REGISTER298=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format12x4155); 10459 stream_REGISTER.add(REGISTER298); 10460 10461 // AST REWRITE 10462 // elements: REGISTER, instruction_format12x, REGISTER 10463 // token labels: 10464 // rule labels: retval 10465 // token list labels: 10466 // rule list labels: 10467 // wildcard labels: 10468 retval.tree = root_0; 10469 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10470 10471 root_0 = (CommonTree)adaptor.nil(); 10472 // 873:5: -> ^( I_STATEMENT_FORMAT12x[$start, \"I_STATEMENT_FORMAT12x\"] instruction_format12x REGISTER REGISTER ) 10473 { 10474 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:873:8: ^( I_STATEMENT_FORMAT12x[$start, \"I_STATEMENT_FORMAT12x\"] instruction_format12x REGISTER REGISTER ) 10475 { 10476 CommonTree root_1 = (CommonTree)adaptor.nil(); 10477 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT12x, (retval.start), "I_STATEMENT_FORMAT12x"), root_1); 10478 adaptor.addChild(root_1, stream_instruction_format12x.nextTree()); 10479 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 10480 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 10481 adaptor.addChild(root_0, root_1); 10482 } 10483 10484 } 10485 10486 10487 retval.tree = root_0; 10488 10489 } 10490 10491 retval.stop = input.LT(-1); 10492 10493 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10494 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10495 10496 } 10497 catch (RecognitionException re) { 10498 reportError(re); 10499 recover(input,re); 10500 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10501 } 10502 finally { 10503 // do for sure before leaving 10504 } 10505 return retval; 10506 } 10507 // $ANTLR end "insn_format12x" 10508 10509 10510 public static class insn_format20bc_return extends ParserRuleReturnScope { 10511 CommonTree tree; 10512 @Override 10513 public CommonTree getTree() { return tree; } 10514 }; 10515 10516 10517 // $ANTLR start "insn_format20bc" 10518 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:875:1: insn_format20bc : INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE COMMA verification_error_reference -> ^( I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE verification_error_reference ) ; 10519 public final smaliParser.insn_format20bc_return insn_format20bc() throws RecognitionException { 10520 smaliParser.insn_format20bc_return retval = new smaliParser.insn_format20bc_return(); 10521 retval.start = input.LT(1); 10522 10523 CommonTree root_0 = null; 10524 10525 Token INSTRUCTION_FORMAT20bc299=null; 10526 Token VERIFICATION_ERROR_TYPE300=null; 10527 Token COMMA301=null; 10528 ParserRuleReturnScope verification_error_reference302 =null; 10529 10530 CommonTree INSTRUCTION_FORMAT20bc299_tree=null; 10531 CommonTree VERIFICATION_ERROR_TYPE300_tree=null; 10532 CommonTree COMMA301_tree=null; 10533 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT20bc=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT20bc"); 10534 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 10535 RewriteRuleTokenStream stream_VERIFICATION_ERROR_TYPE=new RewriteRuleTokenStream(adaptor,"token VERIFICATION_ERROR_TYPE"); 10536 RewriteRuleSubtreeStream stream_verification_error_reference=new RewriteRuleSubtreeStream(adaptor,"rule verification_error_reference"); 10537 10538 try { 10539 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:876:3: ( INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE COMMA verification_error_reference -> ^( I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE verification_error_reference ) ) 10540 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:877:5: INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE COMMA verification_error_reference 10541 { 10542 INSTRUCTION_FORMAT20bc299=(Token)match(input,INSTRUCTION_FORMAT20bc,FOLLOW_INSTRUCTION_FORMAT20bc_in_insn_format20bc4187); 10543 stream_INSTRUCTION_FORMAT20bc.add(INSTRUCTION_FORMAT20bc299); 10544 10545 VERIFICATION_ERROR_TYPE300=(Token)match(input,VERIFICATION_ERROR_TYPE,FOLLOW_VERIFICATION_ERROR_TYPE_in_insn_format20bc4189); 10546 stream_VERIFICATION_ERROR_TYPE.add(VERIFICATION_ERROR_TYPE300); 10547 10548 COMMA301=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format20bc4191); 10549 stream_COMMA.add(COMMA301); 10550 10551 pushFollow(FOLLOW_verification_error_reference_in_insn_format20bc4193); 10552 verification_error_reference302=verification_error_reference(); 10553 state._fsp--; 10554 10555 stream_verification_error_reference.add(verification_error_reference302.getTree()); 10556 10557 if (!allowOdex || opcodes.getOpcodeByName((INSTRUCTION_FORMAT20bc299!=null?INSTRUCTION_FORMAT20bc299.getText():null)) == null || apiLevel >= 14) { 10558 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT20bc299!=null?INSTRUCTION_FORMAT20bc299.getText():null)); 10559 } 10560 10561 // AST REWRITE 10562 // elements: INSTRUCTION_FORMAT20bc, verification_error_reference, VERIFICATION_ERROR_TYPE 10563 // token labels: 10564 // rule labels: retval 10565 // token list labels: 10566 // rule list labels: 10567 // wildcard labels: 10568 retval.tree = root_0; 10569 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10570 10571 root_0 = (CommonTree)adaptor.nil(); 10572 // 883:5: -> ^( I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE verification_error_reference ) 10573 { 10574 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:883:8: ^( I_STATEMENT_FORMAT20bc INSTRUCTION_FORMAT20bc VERIFICATION_ERROR_TYPE verification_error_reference ) 10575 { 10576 CommonTree root_1 = (CommonTree)adaptor.nil(); 10577 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT20bc, "I_STATEMENT_FORMAT20bc"), root_1); 10578 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT20bc.nextNode()); 10579 adaptor.addChild(root_1, stream_VERIFICATION_ERROR_TYPE.nextNode()); 10580 adaptor.addChild(root_1, stream_verification_error_reference.nextTree()); 10581 adaptor.addChild(root_0, root_1); 10582 } 10583 10584 } 10585 10586 10587 retval.tree = root_0; 10588 10589 } 10590 10591 retval.stop = input.LT(-1); 10592 10593 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10594 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10595 10596 } 10597 catch (RecognitionException re) { 10598 reportError(re); 10599 recover(input,re); 10600 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10601 } 10602 finally { 10603 // do for sure before leaving 10604 } 10605 return retval; 10606 } 10607 // $ANTLR end "insn_format20bc" 10608 10609 10610 public static class insn_format20t_return extends ParserRuleReturnScope { 10611 CommonTree tree; 10612 @Override 10613 public CommonTree getTree() { return tree; } 10614 }; 10615 10616 10617 // $ANTLR start "insn_format20t" 10618 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:885:1: insn_format20t : INSTRUCTION_FORMAT20t label_ref -> ^( I_STATEMENT_FORMAT20t[$start, \"I_STATEMENT_FORMAT20t\"] INSTRUCTION_FORMAT20t label_ref ) ; 10619 public final smaliParser.insn_format20t_return insn_format20t() throws RecognitionException { 10620 smaliParser.insn_format20t_return retval = new smaliParser.insn_format20t_return(); 10621 retval.start = input.LT(1); 10622 10623 CommonTree root_0 = null; 10624 10625 Token INSTRUCTION_FORMAT20t303=null; 10626 ParserRuleReturnScope label_ref304 =null; 10627 10628 CommonTree INSTRUCTION_FORMAT20t303_tree=null; 10629 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT20t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT20t"); 10630 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 10631 10632 try { 10633 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:886:3: ( INSTRUCTION_FORMAT20t label_ref -> ^( I_STATEMENT_FORMAT20t[$start, \"I_STATEMENT_FORMAT20t\"] INSTRUCTION_FORMAT20t label_ref ) ) 10634 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:887:5: INSTRUCTION_FORMAT20t label_ref 10635 { 10636 INSTRUCTION_FORMAT20t303=(Token)match(input,INSTRUCTION_FORMAT20t,FOLLOW_INSTRUCTION_FORMAT20t_in_insn_format20t4230); 10637 stream_INSTRUCTION_FORMAT20t.add(INSTRUCTION_FORMAT20t303); 10638 10639 pushFollow(FOLLOW_label_ref_in_insn_format20t4232); 10640 label_ref304=label_ref(); 10641 state._fsp--; 10642 10643 stream_label_ref.add(label_ref304.getTree()); 10644 // AST REWRITE 10645 // elements: INSTRUCTION_FORMAT20t, label_ref 10646 // token labels: 10647 // rule labels: retval 10648 // token list labels: 10649 // rule list labels: 10650 // wildcard labels: 10651 retval.tree = root_0; 10652 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10653 10654 root_0 = (CommonTree)adaptor.nil(); 10655 // 888:5: -> ^( I_STATEMENT_FORMAT20t[$start, \"I_STATEMENT_FORMAT20t\"] INSTRUCTION_FORMAT20t label_ref ) 10656 { 10657 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:888:8: ^( I_STATEMENT_FORMAT20t[$start, \"I_STATEMENT_FORMAT20t\"] INSTRUCTION_FORMAT20t label_ref ) 10658 { 10659 CommonTree root_1 = (CommonTree)adaptor.nil(); 10660 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT20t, (retval.start), "I_STATEMENT_FORMAT20t"), root_1); 10661 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT20t.nextNode()); 10662 adaptor.addChild(root_1, stream_label_ref.nextTree()); 10663 adaptor.addChild(root_0, root_1); 10664 } 10665 10666 } 10667 10668 10669 retval.tree = root_0; 10670 10671 } 10672 10673 retval.stop = input.LT(-1); 10674 10675 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10676 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10677 10678 } 10679 catch (RecognitionException re) { 10680 reportError(re); 10681 recover(input,re); 10682 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10683 } 10684 finally { 10685 // do for sure before leaving 10686 } 10687 return retval; 10688 } 10689 // $ANTLR end "insn_format20t" 10690 10691 10692 public static class insn_format21c_field_return extends ParserRuleReturnScope { 10693 CommonTree tree; 10694 @Override 10695 public CommonTree getTree() { return tree; } 10696 }; 10697 10698 10699 // $ANTLR start "insn_format21c_field" 10700 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:890:1: insn_format21c_field : INSTRUCTION_FORMAT21c_FIELD REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD REGISTER field_reference ) ; 10701 public final smaliParser.insn_format21c_field_return insn_format21c_field() throws RecognitionException { 10702 smaliParser.insn_format21c_field_return retval = new smaliParser.insn_format21c_field_return(); 10703 retval.start = input.LT(1); 10704 10705 CommonTree root_0 = null; 10706 10707 Token INSTRUCTION_FORMAT21c_FIELD305=null; 10708 Token REGISTER306=null; 10709 Token COMMA307=null; 10710 ParserRuleReturnScope field_reference308 =null; 10711 10712 CommonTree INSTRUCTION_FORMAT21c_FIELD305_tree=null; 10713 CommonTree REGISTER306_tree=null; 10714 CommonTree COMMA307_tree=null; 10715 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 10716 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_FIELD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_FIELD"); 10717 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 10718 RewriteRuleSubtreeStream stream_field_reference=new RewriteRuleSubtreeStream(adaptor,"rule field_reference"); 10719 10720 try { 10721 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:891:3: ( INSTRUCTION_FORMAT21c_FIELD REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD REGISTER field_reference ) ) 10722 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:892:5: INSTRUCTION_FORMAT21c_FIELD REGISTER COMMA field_reference 10723 { 10724 INSTRUCTION_FORMAT21c_FIELD305=(Token)match(input,INSTRUCTION_FORMAT21c_FIELD,FOLLOW_INSTRUCTION_FORMAT21c_FIELD_in_insn_format21c_field4262); 10725 stream_INSTRUCTION_FORMAT21c_FIELD.add(INSTRUCTION_FORMAT21c_FIELD305); 10726 10727 REGISTER306=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_field4264); 10728 stream_REGISTER.add(REGISTER306); 10729 10730 COMMA307=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21c_field4266); 10731 stream_COMMA.add(COMMA307); 10732 10733 pushFollow(FOLLOW_field_reference_in_insn_format21c_field4268); 10734 field_reference308=field_reference(); 10735 state._fsp--; 10736 10737 stream_field_reference.add(field_reference308.getTree()); 10738 // AST REWRITE 10739 // elements: field_reference, INSTRUCTION_FORMAT21c_FIELD, REGISTER 10740 // token labels: 10741 // rule labels: retval 10742 // token list labels: 10743 // rule list labels: 10744 // wildcard labels: 10745 retval.tree = root_0; 10746 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10747 10748 root_0 = (CommonTree)adaptor.nil(); 10749 // 893:5: -> ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD REGISTER field_reference ) 10750 { 10751 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:893:8: ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD REGISTER field_reference ) 10752 { 10753 CommonTree root_1 = (CommonTree)adaptor.nil(); 10754 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21c_FIELD, (retval.start), "I_STATEMENT_FORMAT21c_FIELD"), root_1); 10755 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21c_FIELD.nextNode()); 10756 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 10757 adaptor.addChild(root_1, stream_field_reference.nextTree()); 10758 adaptor.addChild(root_0, root_1); 10759 } 10760 10761 } 10762 10763 10764 retval.tree = root_0; 10765 10766 } 10767 10768 retval.stop = input.LT(-1); 10769 10770 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10771 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10772 10773 } 10774 catch (RecognitionException re) { 10775 reportError(re); 10776 recover(input,re); 10777 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10778 } 10779 finally { 10780 // do for sure before leaving 10781 } 10782 return retval; 10783 } 10784 // $ANTLR end "insn_format21c_field" 10785 10786 10787 public static class insn_format21c_field_odex_return extends ParserRuleReturnScope { 10788 CommonTree tree; 10789 @Override 10790 public CommonTree getTree() { return tree; } 10791 }; 10792 10793 10794 // $ANTLR start "insn_format21c_field_odex" 10795 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:895:1: insn_format21c_field_odex : INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER field_reference ) ; 10796 public final smaliParser.insn_format21c_field_odex_return insn_format21c_field_odex() throws RecognitionException { 10797 smaliParser.insn_format21c_field_odex_return retval = new smaliParser.insn_format21c_field_odex_return(); 10798 retval.start = input.LT(1); 10799 10800 CommonTree root_0 = null; 10801 10802 Token INSTRUCTION_FORMAT21c_FIELD_ODEX309=null; 10803 Token REGISTER310=null; 10804 Token COMMA311=null; 10805 ParserRuleReturnScope field_reference312 =null; 10806 10807 CommonTree INSTRUCTION_FORMAT21c_FIELD_ODEX309_tree=null; 10808 CommonTree REGISTER310_tree=null; 10809 CommonTree COMMA311_tree=null; 10810 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 10811 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 10812 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_FIELD_ODEX=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_FIELD_ODEX"); 10813 RewriteRuleSubtreeStream stream_field_reference=new RewriteRuleSubtreeStream(adaptor,"rule field_reference"); 10814 10815 try { 10816 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:896:3: ( INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER field_reference ) ) 10817 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:897:5: INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER COMMA field_reference 10818 { 10819 INSTRUCTION_FORMAT21c_FIELD_ODEX309=(Token)match(input,INSTRUCTION_FORMAT21c_FIELD_ODEX,FOLLOW_INSTRUCTION_FORMAT21c_FIELD_ODEX_in_insn_format21c_field_odex4300); 10820 stream_INSTRUCTION_FORMAT21c_FIELD_ODEX.add(INSTRUCTION_FORMAT21c_FIELD_ODEX309); 10821 10822 REGISTER310=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_field_odex4302); 10823 stream_REGISTER.add(REGISTER310); 10824 10825 COMMA311=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21c_field_odex4304); 10826 stream_COMMA.add(COMMA311); 10827 10828 pushFollow(FOLLOW_field_reference_in_insn_format21c_field_odex4306); 10829 field_reference312=field_reference(); 10830 state._fsp--; 10831 10832 stream_field_reference.add(field_reference312.getTree()); 10833 10834 if (!allowOdex || opcodes.getOpcodeByName((INSTRUCTION_FORMAT21c_FIELD_ODEX309!=null?INSTRUCTION_FORMAT21c_FIELD_ODEX309.getText():null)) == null || apiLevel >= 14) { 10835 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT21c_FIELD_ODEX309!=null?INSTRUCTION_FORMAT21c_FIELD_ODEX309.getText():null)); 10836 } 10837 10838 // AST REWRITE 10839 // elements: REGISTER, INSTRUCTION_FORMAT21c_FIELD_ODEX, field_reference 10840 // token labels: 10841 // rule labels: retval 10842 // token list labels: 10843 // rule list labels: 10844 // wildcard labels: 10845 retval.tree = root_0; 10846 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10847 10848 root_0 = (CommonTree)adaptor.nil(); 10849 // 903:5: -> ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER field_reference ) 10850 { 10851 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:903:8: ^( I_STATEMENT_FORMAT21c_FIELD[$start, \"I_STATEMENT_FORMAT21c_FIELD\"] INSTRUCTION_FORMAT21c_FIELD_ODEX REGISTER field_reference ) 10852 { 10853 CommonTree root_1 = (CommonTree)adaptor.nil(); 10854 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21c_FIELD, (retval.start), "I_STATEMENT_FORMAT21c_FIELD"), root_1); 10855 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21c_FIELD_ODEX.nextNode()); 10856 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 10857 adaptor.addChild(root_1, stream_field_reference.nextTree()); 10858 adaptor.addChild(root_0, root_1); 10859 } 10860 10861 } 10862 10863 10864 retval.tree = root_0; 10865 10866 } 10867 10868 retval.stop = input.LT(-1); 10869 10870 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10871 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10872 10873 } 10874 catch (RecognitionException re) { 10875 reportError(re); 10876 recover(input,re); 10877 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10878 } 10879 finally { 10880 // do for sure before leaving 10881 } 10882 return retval; 10883 } 10884 // $ANTLR end "insn_format21c_field_odex" 10885 10886 10887 public static class insn_format21c_string_return extends ParserRuleReturnScope { 10888 CommonTree tree; 10889 @Override 10890 public CommonTree getTree() { return tree; } 10891 }; 10892 10893 10894 // $ANTLR start "insn_format21c_string" 10895 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:905:1: insn_format21c_string : INSTRUCTION_FORMAT21c_STRING REGISTER COMMA STRING_LITERAL -> ^( I_STATEMENT_FORMAT21c_STRING[$start, \"I_STATEMENT_FORMAT21c_STRING\"] INSTRUCTION_FORMAT21c_STRING REGISTER STRING_LITERAL ) ; 10896 public final smaliParser.insn_format21c_string_return insn_format21c_string() throws RecognitionException { 10897 smaliParser.insn_format21c_string_return retval = new smaliParser.insn_format21c_string_return(); 10898 retval.start = input.LT(1); 10899 10900 CommonTree root_0 = null; 10901 10902 Token INSTRUCTION_FORMAT21c_STRING313=null; 10903 Token REGISTER314=null; 10904 Token COMMA315=null; 10905 Token STRING_LITERAL316=null; 10906 10907 CommonTree INSTRUCTION_FORMAT21c_STRING313_tree=null; 10908 CommonTree REGISTER314_tree=null; 10909 CommonTree COMMA315_tree=null; 10910 CommonTree STRING_LITERAL316_tree=null; 10911 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_STRING=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_STRING"); 10912 RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL"); 10913 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 10914 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 10915 10916 try { 10917 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:906:3: ( INSTRUCTION_FORMAT21c_STRING REGISTER COMMA STRING_LITERAL -> ^( I_STATEMENT_FORMAT21c_STRING[$start, \"I_STATEMENT_FORMAT21c_STRING\"] INSTRUCTION_FORMAT21c_STRING REGISTER STRING_LITERAL ) ) 10918 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:907:5: INSTRUCTION_FORMAT21c_STRING REGISTER COMMA STRING_LITERAL 10919 { 10920 INSTRUCTION_FORMAT21c_STRING313=(Token)match(input,INSTRUCTION_FORMAT21c_STRING,FOLLOW_INSTRUCTION_FORMAT21c_STRING_in_insn_format21c_string4344); 10921 stream_INSTRUCTION_FORMAT21c_STRING.add(INSTRUCTION_FORMAT21c_STRING313); 10922 10923 REGISTER314=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_string4346); 10924 stream_REGISTER.add(REGISTER314); 10925 10926 COMMA315=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21c_string4348); 10927 stream_COMMA.add(COMMA315); 10928 10929 STRING_LITERAL316=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_insn_format21c_string4350); 10930 stream_STRING_LITERAL.add(STRING_LITERAL316); 10931 10932 // AST REWRITE 10933 // elements: INSTRUCTION_FORMAT21c_STRING, REGISTER, STRING_LITERAL 10934 // token labels: 10935 // rule labels: retval 10936 // token list labels: 10937 // rule list labels: 10938 // wildcard labels: 10939 retval.tree = root_0; 10940 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 10941 10942 root_0 = (CommonTree)adaptor.nil(); 10943 // 908:5: -> ^( I_STATEMENT_FORMAT21c_STRING[$start, \"I_STATEMENT_FORMAT21c_STRING\"] INSTRUCTION_FORMAT21c_STRING REGISTER STRING_LITERAL ) 10944 { 10945 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:908:8: ^( I_STATEMENT_FORMAT21c_STRING[$start, \"I_STATEMENT_FORMAT21c_STRING\"] INSTRUCTION_FORMAT21c_STRING REGISTER STRING_LITERAL ) 10946 { 10947 CommonTree root_1 = (CommonTree)adaptor.nil(); 10948 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21c_STRING, (retval.start), "I_STATEMENT_FORMAT21c_STRING"), root_1); 10949 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21c_STRING.nextNode()); 10950 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 10951 adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode()); 10952 adaptor.addChild(root_0, root_1); 10953 } 10954 10955 } 10956 10957 10958 retval.tree = root_0; 10959 10960 } 10961 10962 retval.stop = input.LT(-1); 10963 10964 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 10965 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 10966 10967 } 10968 catch (RecognitionException re) { 10969 reportError(re); 10970 recover(input,re); 10971 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 10972 } 10973 finally { 10974 // do for sure before leaving 10975 } 10976 return retval; 10977 } 10978 // $ANTLR end "insn_format21c_string" 10979 10980 10981 public static class insn_format21c_type_return extends ParserRuleReturnScope { 10982 CommonTree tree; 10983 @Override 10984 public CommonTree getTree() { return tree; } 10985 }; 10986 10987 10988 // $ANTLR start "insn_format21c_type" 10989 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:910:1: insn_format21c_type : INSTRUCTION_FORMAT21c_TYPE REGISTER COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT21c_TYPE[$start, \"I_STATEMENT_FORMAT21c\"] INSTRUCTION_FORMAT21c_TYPE REGISTER nonvoid_type_descriptor ) ; 10990 public final smaliParser.insn_format21c_type_return insn_format21c_type() throws RecognitionException { 10991 smaliParser.insn_format21c_type_return retval = new smaliParser.insn_format21c_type_return(); 10992 retval.start = input.LT(1); 10993 10994 CommonTree root_0 = null; 10995 10996 Token INSTRUCTION_FORMAT21c_TYPE317=null; 10997 Token REGISTER318=null; 10998 Token COMMA319=null; 10999 ParserRuleReturnScope nonvoid_type_descriptor320 =null; 11000 11001 CommonTree INSTRUCTION_FORMAT21c_TYPE317_tree=null; 11002 CommonTree REGISTER318_tree=null; 11003 CommonTree COMMA319_tree=null; 11004 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11005 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21c_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21c_TYPE"); 11006 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11007 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 11008 11009 try { 11010 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:911:3: ( INSTRUCTION_FORMAT21c_TYPE REGISTER COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT21c_TYPE[$start, \"I_STATEMENT_FORMAT21c\"] INSTRUCTION_FORMAT21c_TYPE REGISTER nonvoid_type_descriptor ) ) 11011 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:912:5: INSTRUCTION_FORMAT21c_TYPE REGISTER COMMA nonvoid_type_descriptor 11012 { 11013 INSTRUCTION_FORMAT21c_TYPE317=(Token)match(input,INSTRUCTION_FORMAT21c_TYPE,FOLLOW_INSTRUCTION_FORMAT21c_TYPE_in_insn_format21c_type4382); 11014 stream_INSTRUCTION_FORMAT21c_TYPE.add(INSTRUCTION_FORMAT21c_TYPE317); 11015 11016 REGISTER318=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21c_type4384); 11017 stream_REGISTER.add(REGISTER318); 11018 11019 COMMA319=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21c_type4386); 11020 stream_COMMA.add(COMMA319); 11021 11022 pushFollow(FOLLOW_nonvoid_type_descriptor_in_insn_format21c_type4388); 11023 nonvoid_type_descriptor320=nonvoid_type_descriptor(); 11024 state._fsp--; 11025 11026 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor320.getTree()); 11027 // AST REWRITE 11028 // elements: nonvoid_type_descriptor, REGISTER, INSTRUCTION_FORMAT21c_TYPE 11029 // token labels: 11030 // rule labels: retval 11031 // token list labels: 11032 // rule list labels: 11033 // wildcard labels: 11034 retval.tree = root_0; 11035 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11036 11037 root_0 = (CommonTree)adaptor.nil(); 11038 // 913:5: -> ^( I_STATEMENT_FORMAT21c_TYPE[$start, \"I_STATEMENT_FORMAT21c\"] INSTRUCTION_FORMAT21c_TYPE REGISTER nonvoid_type_descriptor ) 11039 { 11040 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:913:8: ^( I_STATEMENT_FORMAT21c_TYPE[$start, \"I_STATEMENT_FORMAT21c\"] INSTRUCTION_FORMAT21c_TYPE REGISTER nonvoid_type_descriptor ) 11041 { 11042 CommonTree root_1 = (CommonTree)adaptor.nil(); 11043 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21c_TYPE, (retval.start), "I_STATEMENT_FORMAT21c"), root_1); 11044 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21c_TYPE.nextNode()); 11045 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11046 adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree()); 11047 adaptor.addChild(root_0, root_1); 11048 } 11049 11050 } 11051 11052 11053 retval.tree = root_0; 11054 11055 } 11056 11057 retval.stop = input.LT(-1); 11058 11059 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11060 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11061 11062 } 11063 catch (RecognitionException re) { 11064 reportError(re); 11065 recover(input,re); 11066 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11067 } 11068 finally { 11069 // do for sure before leaving 11070 } 11071 return retval; 11072 } 11073 // $ANTLR end "insn_format21c_type" 11074 11075 11076 public static class insn_format21ih_return extends ParserRuleReturnScope { 11077 CommonTree tree; 11078 @Override 11079 public CommonTree getTree() { return tree; } 11080 }; 11081 11082 11083 // $ANTLR start "insn_format21ih" 11084 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:915:1: insn_format21ih : INSTRUCTION_FORMAT21ih REGISTER COMMA fixed_32bit_literal -> ^( I_STATEMENT_FORMAT21ih[$start, \"I_STATEMENT_FORMAT21ih\"] INSTRUCTION_FORMAT21ih REGISTER fixed_32bit_literal ) ; 11085 public final smaliParser.insn_format21ih_return insn_format21ih() throws RecognitionException { 11086 smaliParser.insn_format21ih_return retval = new smaliParser.insn_format21ih_return(); 11087 retval.start = input.LT(1); 11088 11089 CommonTree root_0 = null; 11090 11091 Token INSTRUCTION_FORMAT21ih321=null; 11092 Token REGISTER322=null; 11093 Token COMMA323=null; 11094 ParserRuleReturnScope fixed_32bit_literal324 =null; 11095 11096 CommonTree INSTRUCTION_FORMAT21ih321_tree=null; 11097 CommonTree REGISTER322_tree=null; 11098 CommonTree COMMA323_tree=null; 11099 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21ih=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21ih"); 11100 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11101 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11102 RewriteRuleSubtreeStream stream_fixed_32bit_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_32bit_literal"); 11103 11104 try { 11105 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:916:3: ( INSTRUCTION_FORMAT21ih REGISTER COMMA fixed_32bit_literal -> ^( I_STATEMENT_FORMAT21ih[$start, \"I_STATEMENT_FORMAT21ih\"] INSTRUCTION_FORMAT21ih REGISTER fixed_32bit_literal ) ) 11106 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:917:5: INSTRUCTION_FORMAT21ih REGISTER COMMA fixed_32bit_literal 11107 { 11108 INSTRUCTION_FORMAT21ih321=(Token)match(input,INSTRUCTION_FORMAT21ih,FOLLOW_INSTRUCTION_FORMAT21ih_in_insn_format21ih4420); 11109 stream_INSTRUCTION_FORMAT21ih.add(INSTRUCTION_FORMAT21ih321); 11110 11111 REGISTER322=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21ih4422); 11112 stream_REGISTER.add(REGISTER322); 11113 11114 COMMA323=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21ih4424); 11115 stream_COMMA.add(COMMA323); 11116 11117 pushFollow(FOLLOW_fixed_32bit_literal_in_insn_format21ih4426); 11118 fixed_32bit_literal324=fixed_32bit_literal(); 11119 state._fsp--; 11120 11121 stream_fixed_32bit_literal.add(fixed_32bit_literal324.getTree()); 11122 // AST REWRITE 11123 // elements: REGISTER, INSTRUCTION_FORMAT21ih, fixed_32bit_literal 11124 // token labels: 11125 // rule labels: retval 11126 // token list labels: 11127 // rule list labels: 11128 // wildcard labels: 11129 retval.tree = root_0; 11130 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11131 11132 root_0 = (CommonTree)adaptor.nil(); 11133 // 918:5: -> ^( I_STATEMENT_FORMAT21ih[$start, \"I_STATEMENT_FORMAT21ih\"] INSTRUCTION_FORMAT21ih REGISTER fixed_32bit_literal ) 11134 { 11135 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:918:8: ^( I_STATEMENT_FORMAT21ih[$start, \"I_STATEMENT_FORMAT21ih\"] INSTRUCTION_FORMAT21ih REGISTER fixed_32bit_literal ) 11136 { 11137 CommonTree root_1 = (CommonTree)adaptor.nil(); 11138 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21ih, (retval.start), "I_STATEMENT_FORMAT21ih"), root_1); 11139 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21ih.nextNode()); 11140 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11141 adaptor.addChild(root_1, stream_fixed_32bit_literal.nextTree()); 11142 adaptor.addChild(root_0, root_1); 11143 } 11144 11145 } 11146 11147 11148 retval.tree = root_0; 11149 11150 } 11151 11152 retval.stop = input.LT(-1); 11153 11154 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11155 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11156 11157 } 11158 catch (RecognitionException re) { 11159 reportError(re); 11160 recover(input,re); 11161 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11162 } 11163 finally { 11164 // do for sure before leaving 11165 } 11166 return retval; 11167 } 11168 // $ANTLR end "insn_format21ih" 11169 11170 11171 public static class insn_format21lh_return extends ParserRuleReturnScope { 11172 CommonTree tree; 11173 @Override 11174 public CommonTree getTree() { return tree; } 11175 }; 11176 11177 11178 // $ANTLR start "insn_format21lh" 11179 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:920:1: insn_format21lh : INSTRUCTION_FORMAT21lh REGISTER COMMA fixed_32bit_literal -> ^( I_STATEMENT_FORMAT21lh[$start, \"I_STATEMENT_FORMAT21lh\"] INSTRUCTION_FORMAT21lh REGISTER fixed_32bit_literal ) ; 11180 public final smaliParser.insn_format21lh_return insn_format21lh() throws RecognitionException { 11181 smaliParser.insn_format21lh_return retval = new smaliParser.insn_format21lh_return(); 11182 retval.start = input.LT(1); 11183 11184 CommonTree root_0 = null; 11185 11186 Token INSTRUCTION_FORMAT21lh325=null; 11187 Token REGISTER326=null; 11188 Token COMMA327=null; 11189 ParserRuleReturnScope fixed_32bit_literal328 =null; 11190 11191 CommonTree INSTRUCTION_FORMAT21lh325_tree=null; 11192 CommonTree REGISTER326_tree=null; 11193 CommonTree COMMA327_tree=null; 11194 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21lh=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21lh"); 11195 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11196 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11197 RewriteRuleSubtreeStream stream_fixed_32bit_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_32bit_literal"); 11198 11199 try { 11200 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:921:3: ( INSTRUCTION_FORMAT21lh REGISTER COMMA fixed_32bit_literal -> ^( I_STATEMENT_FORMAT21lh[$start, \"I_STATEMENT_FORMAT21lh\"] INSTRUCTION_FORMAT21lh REGISTER fixed_32bit_literal ) ) 11201 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:922:5: INSTRUCTION_FORMAT21lh REGISTER COMMA fixed_32bit_literal 11202 { 11203 INSTRUCTION_FORMAT21lh325=(Token)match(input,INSTRUCTION_FORMAT21lh,FOLLOW_INSTRUCTION_FORMAT21lh_in_insn_format21lh4458); 11204 stream_INSTRUCTION_FORMAT21lh.add(INSTRUCTION_FORMAT21lh325); 11205 11206 REGISTER326=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21lh4460); 11207 stream_REGISTER.add(REGISTER326); 11208 11209 COMMA327=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21lh4462); 11210 stream_COMMA.add(COMMA327); 11211 11212 pushFollow(FOLLOW_fixed_32bit_literal_in_insn_format21lh4464); 11213 fixed_32bit_literal328=fixed_32bit_literal(); 11214 state._fsp--; 11215 11216 stream_fixed_32bit_literal.add(fixed_32bit_literal328.getTree()); 11217 // AST REWRITE 11218 // elements: INSTRUCTION_FORMAT21lh, fixed_32bit_literal, REGISTER 11219 // token labels: 11220 // rule labels: retval 11221 // token list labels: 11222 // rule list labels: 11223 // wildcard labels: 11224 retval.tree = root_0; 11225 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11226 11227 root_0 = (CommonTree)adaptor.nil(); 11228 // 923:5: -> ^( I_STATEMENT_FORMAT21lh[$start, \"I_STATEMENT_FORMAT21lh\"] INSTRUCTION_FORMAT21lh REGISTER fixed_32bit_literal ) 11229 { 11230 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:923:8: ^( I_STATEMENT_FORMAT21lh[$start, \"I_STATEMENT_FORMAT21lh\"] INSTRUCTION_FORMAT21lh REGISTER fixed_32bit_literal ) 11231 { 11232 CommonTree root_1 = (CommonTree)adaptor.nil(); 11233 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21lh, (retval.start), "I_STATEMENT_FORMAT21lh"), root_1); 11234 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21lh.nextNode()); 11235 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11236 adaptor.addChild(root_1, stream_fixed_32bit_literal.nextTree()); 11237 adaptor.addChild(root_0, root_1); 11238 } 11239 11240 } 11241 11242 11243 retval.tree = root_0; 11244 11245 } 11246 11247 retval.stop = input.LT(-1); 11248 11249 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11250 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11251 11252 } 11253 catch (RecognitionException re) { 11254 reportError(re); 11255 recover(input,re); 11256 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11257 } 11258 finally { 11259 // do for sure before leaving 11260 } 11261 return retval; 11262 } 11263 // $ANTLR end "insn_format21lh" 11264 11265 11266 public static class insn_format21s_return extends ParserRuleReturnScope { 11267 CommonTree tree; 11268 @Override 11269 public CommonTree getTree() { return tree; } 11270 }; 11271 11272 11273 // $ANTLR start "insn_format21s" 11274 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:925:1: insn_format21s : INSTRUCTION_FORMAT21s REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT21s[$start, \"I_STATEMENT_FORMAT21s\"] INSTRUCTION_FORMAT21s REGISTER integral_literal ) ; 11275 public final smaliParser.insn_format21s_return insn_format21s() throws RecognitionException { 11276 smaliParser.insn_format21s_return retval = new smaliParser.insn_format21s_return(); 11277 retval.start = input.LT(1); 11278 11279 CommonTree root_0 = null; 11280 11281 Token INSTRUCTION_FORMAT21s329=null; 11282 Token REGISTER330=null; 11283 Token COMMA331=null; 11284 ParserRuleReturnScope integral_literal332 =null; 11285 11286 CommonTree INSTRUCTION_FORMAT21s329_tree=null; 11287 CommonTree REGISTER330_tree=null; 11288 CommonTree COMMA331_tree=null; 11289 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21s=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21s"); 11290 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11291 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11292 RewriteRuleSubtreeStream stream_integral_literal=new RewriteRuleSubtreeStream(adaptor,"rule integral_literal"); 11293 11294 try { 11295 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:926:3: ( INSTRUCTION_FORMAT21s REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT21s[$start, \"I_STATEMENT_FORMAT21s\"] INSTRUCTION_FORMAT21s REGISTER integral_literal ) ) 11296 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:927:5: INSTRUCTION_FORMAT21s REGISTER COMMA integral_literal 11297 { 11298 INSTRUCTION_FORMAT21s329=(Token)match(input,INSTRUCTION_FORMAT21s,FOLLOW_INSTRUCTION_FORMAT21s_in_insn_format21s4496); 11299 stream_INSTRUCTION_FORMAT21s.add(INSTRUCTION_FORMAT21s329); 11300 11301 REGISTER330=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21s4498); 11302 stream_REGISTER.add(REGISTER330); 11303 11304 COMMA331=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21s4500); 11305 stream_COMMA.add(COMMA331); 11306 11307 pushFollow(FOLLOW_integral_literal_in_insn_format21s4502); 11308 integral_literal332=integral_literal(); 11309 state._fsp--; 11310 11311 stream_integral_literal.add(integral_literal332.getTree()); 11312 // AST REWRITE 11313 // elements: INSTRUCTION_FORMAT21s, integral_literal, REGISTER 11314 // token labels: 11315 // rule labels: retval 11316 // token list labels: 11317 // rule list labels: 11318 // wildcard labels: 11319 retval.tree = root_0; 11320 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11321 11322 root_0 = (CommonTree)adaptor.nil(); 11323 // 928:5: -> ^( I_STATEMENT_FORMAT21s[$start, \"I_STATEMENT_FORMAT21s\"] INSTRUCTION_FORMAT21s REGISTER integral_literal ) 11324 { 11325 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:928:8: ^( I_STATEMENT_FORMAT21s[$start, \"I_STATEMENT_FORMAT21s\"] INSTRUCTION_FORMAT21s REGISTER integral_literal ) 11326 { 11327 CommonTree root_1 = (CommonTree)adaptor.nil(); 11328 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21s, (retval.start), "I_STATEMENT_FORMAT21s"), root_1); 11329 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21s.nextNode()); 11330 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11331 adaptor.addChild(root_1, stream_integral_literal.nextTree()); 11332 adaptor.addChild(root_0, root_1); 11333 } 11334 11335 } 11336 11337 11338 retval.tree = root_0; 11339 11340 } 11341 11342 retval.stop = input.LT(-1); 11343 11344 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11345 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11346 11347 } 11348 catch (RecognitionException re) { 11349 reportError(re); 11350 recover(input,re); 11351 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11352 } 11353 finally { 11354 // do for sure before leaving 11355 } 11356 return retval; 11357 } 11358 // $ANTLR end "insn_format21s" 11359 11360 11361 public static class insn_format21t_return extends ParserRuleReturnScope { 11362 CommonTree tree; 11363 @Override 11364 public CommonTree getTree() { return tree; } 11365 }; 11366 11367 11368 // $ANTLR start "insn_format21t" 11369 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:930:1: insn_format21t : INSTRUCTION_FORMAT21t REGISTER COMMA label_ref -> ^( I_STATEMENT_FORMAT21t[$start, \"I_STATEMENT_FORMAT21t\"] INSTRUCTION_FORMAT21t REGISTER label_ref ) ; 11370 public final smaliParser.insn_format21t_return insn_format21t() throws RecognitionException { 11371 smaliParser.insn_format21t_return retval = new smaliParser.insn_format21t_return(); 11372 retval.start = input.LT(1); 11373 11374 CommonTree root_0 = null; 11375 11376 Token INSTRUCTION_FORMAT21t333=null; 11377 Token REGISTER334=null; 11378 Token COMMA335=null; 11379 ParserRuleReturnScope label_ref336 =null; 11380 11381 CommonTree INSTRUCTION_FORMAT21t333_tree=null; 11382 CommonTree REGISTER334_tree=null; 11383 CommonTree COMMA335_tree=null; 11384 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT21t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT21t"); 11385 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11386 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11387 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 11388 11389 try { 11390 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:931:3: ( INSTRUCTION_FORMAT21t REGISTER COMMA label_ref -> ^( I_STATEMENT_FORMAT21t[$start, \"I_STATEMENT_FORMAT21t\"] INSTRUCTION_FORMAT21t REGISTER label_ref ) ) 11391 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:932:5: INSTRUCTION_FORMAT21t REGISTER COMMA label_ref 11392 { 11393 INSTRUCTION_FORMAT21t333=(Token)match(input,INSTRUCTION_FORMAT21t,FOLLOW_INSTRUCTION_FORMAT21t_in_insn_format21t4534); 11394 stream_INSTRUCTION_FORMAT21t.add(INSTRUCTION_FORMAT21t333); 11395 11396 REGISTER334=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format21t4536); 11397 stream_REGISTER.add(REGISTER334); 11398 11399 COMMA335=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format21t4538); 11400 stream_COMMA.add(COMMA335); 11401 11402 pushFollow(FOLLOW_label_ref_in_insn_format21t4540); 11403 label_ref336=label_ref(); 11404 state._fsp--; 11405 11406 stream_label_ref.add(label_ref336.getTree()); 11407 // AST REWRITE 11408 // elements: label_ref, REGISTER, INSTRUCTION_FORMAT21t 11409 // token labels: 11410 // rule labels: retval 11411 // token list labels: 11412 // rule list labels: 11413 // wildcard labels: 11414 retval.tree = root_0; 11415 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11416 11417 root_0 = (CommonTree)adaptor.nil(); 11418 // 933:5: -> ^( I_STATEMENT_FORMAT21t[$start, \"I_STATEMENT_FORMAT21t\"] INSTRUCTION_FORMAT21t REGISTER label_ref ) 11419 { 11420 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:933:8: ^( I_STATEMENT_FORMAT21t[$start, \"I_STATEMENT_FORMAT21t\"] INSTRUCTION_FORMAT21t REGISTER label_ref ) 11421 { 11422 CommonTree root_1 = (CommonTree)adaptor.nil(); 11423 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT21t, (retval.start), "I_STATEMENT_FORMAT21t"), root_1); 11424 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT21t.nextNode()); 11425 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11426 adaptor.addChild(root_1, stream_label_ref.nextTree()); 11427 adaptor.addChild(root_0, root_1); 11428 } 11429 11430 } 11431 11432 11433 retval.tree = root_0; 11434 11435 } 11436 11437 retval.stop = input.LT(-1); 11438 11439 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11440 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11441 11442 } 11443 catch (RecognitionException re) { 11444 reportError(re); 11445 recover(input,re); 11446 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11447 } 11448 finally { 11449 // do for sure before leaving 11450 } 11451 return retval; 11452 } 11453 // $ANTLR end "insn_format21t" 11454 11455 11456 public static class insn_format22b_return extends ParserRuleReturnScope { 11457 CommonTree tree; 11458 @Override 11459 public CommonTree getTree() { return tree; } 11460 }; 11461 11462 11463 // $ANTLR start "insn_format22b" 11464 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:935:1: insn_format22b : INSTRUCTION_FORMAT22b REGISTER COMMA REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT22b[$start, \"I_STATEMENT_FORMAT22b\"] INSTRUCTION_FORMAT22b REGISTER REGISTER integral_literal ) ; 11465 public final smaliParser.insn_format22b_return insn_format22b() throws RecognitionException { 11466 smaliParser.insn_format22b_return retval = new smaliParser.insn_format22b_return(); 11467 retval.start = input.LT(1); 11468 11469 CommonTree root_0 = null; 11470 11471 Token INSTRUCTION_FORMAT22b337=null; 11472 Token REGISTER338=null; 11473 Token COMMA339=null; 11474 Token REGISTER340=null; 11475 Token COMMA341=null; 11476 ParserRuleReturnScope integral_literal342 =null; 11477 11478 CommonTree INSTRUCTION_FORMAT22b337_tree=null; 11479 CommonTree REGISTER338_tree=null; 11480 CommonTree COMMA339_tree=null; 11481 CommonTree REGISTER340_tree=null; 11482 CommonTree COMMA341_tree=null; 11483 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11484 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11485 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22b=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22b"); 11486 RewriteRuleSubtreeStream stream_integral_literal=new RewriteRuleSubtreeStream(adaptor,"rule integral_literal"); 11487 11488 try { 11489 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:936:3: ( INSTRUCTION_FORMAT22b REGISTER COMMA REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT22b[$start, \"I_STATEMENT_FORMAT22b\"] INSTRUCTION_FORMAT22b REGISTER REGISTER integral_literal ) ) 11490 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:937:5: INSTRUCTION_FORMAT22b REGISTER COMMA REGISTER COMMA integral_literal 11491 { 11492 INSTRUCTION_FORMAT22b337=(Token)match(input,INSTRUCTION_FORMAT22b,FOLLOW_INSTRUCTION_FORMAT22b_in_insn_format22b4572); 11493 stream_INSTRUCTION_FORMAT22b.add(INSTRUCTION_FORMAT22b337); 11494 11495 REGISTER338=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22b4574); 11496 stream_REGISTER.add(REGISTER338); 11497 11498 COMMA339=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22b4576); 11499 stream_COMMA.add(COMMA339); 11500 11501 REGISTER340=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22b4578); 11502 stream_REGISTER.add(REGISTER340); 11503 11504 COMMA341=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22b4580); 11505 stream_COMMA.add(COMMA341); 11506 11507 pushFollow(FOLLOW_integral_literal_in_insn_format22b4582); 11508 integral_literal342=integral_literal(); 11509 state._fsp--; 11510 11511 stream_integral_literal.add(integral_literal342.getTree()); 11512 // AST REWRITE 11513 // elements: integral_literal, REGISTER, INSTRUCTION_FORMAT22b, REGISTER 11514 // token labels: 11515 // rule labels: retval 11516 // token list labels: 11517 // rule list labels: 11518 // wildcard labels: 11519 retval.tree = root_0; 11520 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11521 11522 root_0 = (CommonTree)adaptor.nil(); 11523 // 938:5: -> ^( I_STATEMENT_FORMAT22b[$start, \"I_STATEMENT_FORMAT22b\"] INSTRUCTION_FORMAT22b REGISTER REGISTER integral_literal ) 11524 { 11525 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:938:8: ^( I_STATEMENT_FORMAT22b[$start, \"I_STATEMENT_FORMAT22b\"] INSTRUCTION_FORMAT22b REGISTER REGISTER integral_literal ) 11526 { 11527 CommonTree root_1 = (CommonTree)adaptor.nil(); 11528 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22b, (retval.start), "I_STATEMENT_FORMAT22b"), root_1); 11529 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22b.nextNode()); 11530 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11531 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11532 adaptor.addChild(root_1, stream_integral_literal.nextTree()); 11533 adaptor.addChild(root_0, root_1); 11534 } 11535 11536 } 11537 11538 11539 retval.tree = root_0; 11540 11541 } 11542 11543 retval.stop = input.LT(-1); 11544 11545 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11546 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11547 11548 } 11549 catch (RecognitionException re) { 11550 reportError(re); 11551 recover(input,re); 11552 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11553 } 11554 finally { 11555 // do for sure before leaving 11556 } 11557 return retval; 11558 } 11559 // $ANTLR end "insn_format22b" 11560 11561 11562 public static class insn_format22c_field_return extends ParserRuleReturnScope { 11563 CommonTree tree; 11564 @Override 11565 public CommonTree getTree() { return tree; } 11566 }; 11567 11568 11569 // $ANTLR start "insn_format22c_field" 11570 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:940:1: insn_format22c_field : INSTRUCTION_FORMAT22c_FIELD REGISTER COMMA REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD REGISTER REGISTER field_reference ) ; 11571 public final smaliParser.insn_format22c_field_return insn_format22c_field() throws RecognitionException { 11572 smaliParser.insn_format22c_field_return retval = new smaliParser.insn_format22c_field_return(); 11573 retval.start = input.LT(1); 11574 11575 CommonTree root_0 = null; 11576 11577 Token INSTRUCTION_FORMAT22c_FIELD343=null; 11578 Token REGISTER344=null; 11579 Token COMMA345=null; 11580 Token REGISTER346=null; 11581 Token COMMA347=null; 11582 ParserRuleReturnScope field_reference348 =null; 11583 11584 CommonTree INSTRUCTION_FORMAT22c_FIELD343_tree=null; 11585 CommonTree REGISTER344_tree=null; 11586 CommonTree COMMA345_tree=null; 11587 CommonTree REGISTER346_tree=null; 11588 CommonTree COMMA347_tree=null; 11589 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11590 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11591 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_FIELD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_FIELD"); 11592 RewriteRuleSubtreeStream stream_field_reference=new RewriteRuleSubtreeStream(adaptor,"rule field_reference"); 11593 11594 try { 11595 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:941:3: ( INSTRUCTION_FORMAT22c_FIELD REGISTER COMMA REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD REGISTER REGISTER field_reference ) ) 11596 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:942:5: INSTRUCTION_FORMAT22c_FIELD REGISTER COMMA REGISTER COMMA field_reference 11597 { 11598 INSTRUCTION_FORMAT22c_FIELD343=(Token)match(input,INSTRUCTION_FORMAT22c_FIELD,FOLLOW_INSTRUCTION_FORMAT22c_FIELD_in_insn_format22c_field4616); 11599 stream_INSTRUCTION_FORMAT22c_FIELD.add(INSTRUCTION_FORMAT22c_FIELD343); 11600 11601 REGISTER344=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_field4618); 11602 stream_REGISTER.add(REGISTER344); 11603 11604 COMMA345=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_field4620); 11605 stream_COMMA.add(COMMA345); 11606 11607 REGISTER346=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_field4622); 11608 stream_REGISTER.add(REGISTER346); 11609 11610 COMMA347=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_field4624); 11611 stream_COMMA.add(COMMA347); 11612 11613 pushFollow(FOLLOW_field_reference_in_insn_format22c_field4626); 11614 field_reference348=field_reference(); 11615 state._fsp--; 11616 11617 stream_field_reference.add(field_reference348.getTree()); 11618 // AST REWRITE 11619 // elements: REGISTER, field_reference, INSTRUCTION_FORMAT22c_FIELD, REGISTER 11620 // token labels: 11621 // rule labels: retval 11622 // token list labels: 11623 // rule list labels: 11624 // wildcard labels: 11625 retval.tree = root_0; 11626 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11627 11628 root_0 = (CommonTree)adaptor.nil(); 11629 // 943:5: -> ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD REGISTER REGISTER field_reference ) 11630 { 11631 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:943:8: ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD REGISTER REGISTER field_reference ) 11632 { 11633 CommonTree root_1 = (CommonTree)adaptor.nil(); 11634 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22c_FIELD, (retval.start), "I_STATEMENT_FORMAT22c_FIELD"), root_1); 11635 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22c_FIELD.nextNode()); 11636 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11637 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11638 adaptor.addChild(root_1, stream_field_reference.nextTree()); 11639 adaptor.addChild(root_0, root_1); 11640 } 11641 11642 } 11643 11644 11645 retval.tree = root_0; 11646 11647 } 11648 11649 retval.stop = input.LT(-1); 11650 11651 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11652 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11653 11654 } 11655 catch (RecognitionException re) { 11656 reportError(re); 11657 recover(input,re); 11658 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11659 } 11660 finally { 11661 // do for sure before leaving 11662 } 11663 return retval; 11664 } 11665 // $ANTLR end "insn_format22c_field" 11666 11667 11668 public static class insn_format22c_field_odex_return extends ParserRuleReturnScope { 11669 CommonTree tree; 11670 @Override 11671 public CommonTree getTree() { return tree; } 11672 }; 11673 11674 11675 // $ANTLR start "insn_format22c_field_odex" 11676 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:945:1: insn_format22c_field_odex : INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER COMMA REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER REGISTER field_reference ) ; 11677 public final smaliParser.insn_format22c_field_odex_return insn_format22c_field_odex() throws RecognitionException { 11678 smaliParser.insn_format22c_field_odex_return retval = new smaliParser.insn_format22c_field_odex_return(); 11679 retval.start = input.LT(1); 11680 11681 CommonTree root_0 = null; 11682 11683 Token INSTRUCTION_FORMAT22c_FIELD_ODEX349=null; 11684 Token REGISTER350=null; 11685 Token COMMA351=null; 11686 Token REGISTER352=null; 11687 Token COMMA353=null; 11688 ParserRuleReturnScope field_reference354 =null; 11689 11690 CommonTree INSTRUCTION_FORMAT22c_FIELD_ODEX349_tree=null; 11691 CommonTree REGISTER350_tree=null; 11692 CommonTree COMMA351_tree=null; 11693 CommonTree REGISTER352_tree=null; 11694 CommonTree COMMA353_tree=null; 11695 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_FIELD_ODEX=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_FIELD_ODEX"); 11696 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11697 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11698 RewriteRuleSubtreeStream stream_field_reference=new RewriteRuleSubtreeStream(adaptor,"rule field_reference"); 11699 11700 try { 11701 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:946:3: ( INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER COMMA REGISTER COMMA field_reference -> ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER REGISTER field_reference ) ) 11702 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:947:5: INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER COMMA REGISTER COMMA field_reference 11703 { 11704 INSTRUCTION_FORMAT22c_FIELD_ODEX349=(Token)match(input,INSTRUCTION_FORMAT22c_FIELD_ODEX,FOLLOW_INSTRUCTION_FORMAT22c_FIELD_ODEX_in_insn_format22c_field_odex4660); 11705 stream_INSTRUCTION_FORMAT22c_FIELD_ODEX.add(INSTRUCTION_FORMAT22c_FIELD_ODEX349); 11706 11707 REGISTER350=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_field_odex4662); 11708 stream_REGISTER.add(REGISTER350); 11709 11710 COMMA351=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_field_odex4664); 11711 stream_COMMA.add(COMMA351); 11712 11713 REGISTER352=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_field_odex4666); 11714 stream_REGISTER.add(REGISTER352); 11715 11716 COMMA353=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_field_odex4668); 11717 stream_COMMA.add(COMMA353); 11718 11719 pushFollow(FOLLOW_field_reference_in_insn_format22c_field_odex4670); 11720 field_reference354=field_reference(); 11721 state._fsp--; 11722 11723 stream_field_reference.add(field_reference354.getTree()); 11724 11725 if (!allowOdex || opcodes.getOpcodeByName((INSTRUCTION_FORMAT22c_FIELD_ODEX349!=null?INSTRUCTION_FORMAT22c_FIELD_ODEX349.getText():null)) == null || apiLevel >= 14) { 11726 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT22c_FIELD_ODEX349!=null?INSTRUCTION_FORMAT22c_FIELD_ODEX349.getText():null)); 11727 } 11728 11729 // AST REWRITE 11730 // elements: REGISTER, field_reference, REGISTER, INSTRUCTION_FORMAT22c_FIELD_ODEX 11731 // token labels: 11732 // rule labels: retval 11733 // token list labels: 11734 // rule list labels: 11735 // wildcard labels: 11736 retval.tree = root_0; 11737 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11738 11739 root_0 = (CommonTree)adaptor.nil(); 11740 // 953:5: -> ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER REGISTER field_reference ) 11741 { 11742 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:953:8: ^( I_STATEMENT_FORMAT22c_FIELD[$start, \"I_STATEMENT_FORMAT22c_FIELD\"] INSTRUCTION_FORMAT22c_FIELD_ODEX REGISTER REGISTER field_reference ) 11743 { 11744 CommonTree root_1 = (CommonTree)adaptor.nil(); 11745 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22c_FIELD, (retval.start), "I_STATEMENT_FORMAT22c_FIELD"), root_1); 11746 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22c_FIELD_ODEX.nextNode()); 11747 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11748 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11749 adaptor.addChild(root_1, stream_field_reference.nextTree()); 11750 adaptor.addChild(root_0, root_1); 11751 } 11752 11753 } 11754 11755 11756 retval.tree = root_0; 11757 11758 } 11759 11760 retval.stop = input.LT(-1); 11761 11762 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11763 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11764 11765 } 11766 catch (RecognitionException re) { 11767 reportError(re); 11768 recover(input,re); 11769 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11770 } 11771 finally { 11772 // do for sure before leaving 11773 } 11774 return retval; 11775 } 11776 // $ANTLR end "insn_format22c_field_odex" 11777 11778 11779 public static class insn_format22c_type_return extends ParserRuleReturnScope { 11780 CommonTree tree; 11781 @Override 11782 public CommonTree getTree() { return tree; } 11783 }; 11784 11785 11786 // $ANTLR start "insn_format22c_type" 11787 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:955:1: insn_format22c_type : INSTRUCTION_FORMAT22c_TYPE REGISTER COMMA REGISTER COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT22c_TYPE[$start, \"I_STATEMENT_FORMAT22c_TYPE\"] INSTRUCTION_FORMAT22c_TYPE REGISTER REGISTER nonvoid_type_descriptor ) ; 11788 public final smaliParser.insn_format22c_type_return insn_format22c_type() throws RecognitionException { 11789 smaliParser.insn_format22c_type_return retval = new smaliParser.insn_format22c_type_return(); 11790 retval.start = input.LT(1); 11791 11792 CommonTree root_0 = null; 11793 11794 Token INSTRUCTION_FORMAT22c_TYPE355=null; 11795 Token REGISTER356=null; 11796 Token COMMA357=null; 11797 Token REGISTER358=null; 11798 Token COMMA359=null; 11799 ParserRuleReturnScope nonvoid_type_descriptor360 =null; 11800 11801 CommonTree INSTRUCTION_FORMAT22c_TYPE355_tree=null; 11802 CommonTree REGISTER356_tree=null; 11803 CommonTree COMMA357_tree=null; 11804 CommonTree REGISTER358_tree=null; 11805 CommonTree COMMA359_tree=null; 11806 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22c_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22c_TYPE"); 11807 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11808 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11809 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 11810 11811 try { 11812 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:956:3: ( INSTRUCTION_FORMAT22c_TYPE REGISTER COMMA REGISTER COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT22c_TYPE[$start, \"I_STATEMENT_FORMAT22c_TYPE\"] INSTRUCTION_FORMAT22c_TYPE REGISTER REGISTER nonvoid_type_descriptor ) ) 11813 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:957:5: INSTRUCTION_FORMAT22c_TYPE REGISTER COMMA REGISTER COMMA nonvoid_type_descriptor 11814 { 11815 INSTRUCTION_FORMAT22c_TYPE355=(Token)match(input,INSTRUCTION_FORMAT22c_TYPE,FOLLOW_INSTRUCTION_FORMAT22c_TYPE_in_insn_format22c_type4710); 11816 stream_INSTRUCTION_FORMAT22c_TYPE.add(INSTRUCTION_FORMAT22c_TYPE355); 11817 11818 REGISTER356=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_type4712); 11819 stream_REGISTER.add(REGISTER356); 11820 11821 COMMA357=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_type4714); 11822 stream_COMMA.add(COMMA357); 11823 11824 REGISTER358=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22c_type4716); 11825 stream_REGISTER.add(REGISTER358); 11826 11827 COMMA359=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22c_type4718); 11828 stream_COMMA.add(COMMA359); 11829 11830 pushFollow(FOLLOW_nonvoid_type_descriptor_in_insn_format22c_type4720); 11831 nonvoid_type_descriptor360=nonvoid_type_descriptor(); 11832 state._fsp--; 11833 11834 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor360.getTree()); 11835 // AST REWRITE 11836 // elements: REGISTER, nonvoid_type_descriptor, REGISTER, INSTRUCTION_FORMAT22c_TYPE 11837 // token labels: 11838 // rule labels: retval 11839 // token list labels: 11840 // rule list labels: 11841 // wildcard labels: 11842 retval.tree = root_0; 11843 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 11844 11845 root_0 = (CommonTree)adaptor.nil(); 11846 // 958:5: -> ^( I_STATEMENT_FORMAT22c_TYPE[$start, \"I_STATEMENT_FORMAT22c_TYPE\"] INSTRUCTION_FORMAT22c_TYPE REGISTER REGISTER nonvoid_type_descriptor ) 11847 { 11848 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:958:8: ^( I_STATEMENT_FORMAT22c_TYPE[$start, \"I_STATEMENT_FORMAT22c_TYPE\"] INSTRUCTION_FORMAT22c_TYPE REGISTER REGISTER nonvoid_type_descriptor ) 11849 { 11850 CommonTree root_1 = (CommonTree)adaptor.nil(); 11851 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22c_TYPE, (retval.start), "I_STATEMENT_FORMAT22c_TYPE"), root_1); 11852 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22c_TYPE.nextNode()); 11853 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11854 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 11855 adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree()); 11856 adaptor.addChild(root_0, root_1); 11857 } 11858 11859 } 11860 11861 11862 retval.tree = root_0; 11863 11864 } 11865 11866 retval.stop = input.LT(-1); 11867 11868 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11869 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11870 11871 } 11872 catch (RecognitionException re) { 11873 reportError(re); 11874 recover(input,re); 11875 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11876 } 11877 finally { 11878 // do for sure before leaving 11879 } 11880 return retval; 11881 } 11882 // $ANTLR end "insn_format22c_type" 11883 11884 11885 public static class insn_format22cs_field_return extends ParserRuleReturnScope { 11886 CommonTree tree; 11887 @Override 11888 public CommonTree getTree() { return tree; } 11889 }; 11890 11891 11892 // $ANTLR start "insn_format22cs_field" 11893 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:960:1: insn_format22cs_field : INSTRUCTION_FORMAT22cs_FIELD REGISTER COMMA REGISTER COMMA FIELD_OFFSET ; 11894 public final smaliParser.insn_format22cs_field_return insn_format22cs_field() throws RecognitionException { 11895 smaliParser.insn_format22cs_field_return retval = new smaliParser.insn_format22cs_field_return(); 11896 retval.start = input.LT(1); 11897 11898 CommonTree root_0 = null; 11899 11900 Token INSTRUCTION_FORMAT22cs_FIELD361=null; 11901 Token REGISTER362=null; 11902 Token COMMA363=null; 11903 Token REGISTER364=null; 11904 Token COMMA365=null; 11905 Token FIELD_OFFSET366=null; 11906 11907 CommonTree INSTRUCTION_FORMAT22cs_FIELD361_tree=null; 11908 CommonTree REGISTER362_tree=null; 11909 CommonTree COMMA363_tree=null; 11910 CommonTree REGISTER364_tree=null; 11911 CommonTree COMMA365_tree=null; 11912 CommonTree FIELD_OFFSET366_tree=null; 11913 11914 try { 11915 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:961:3: ( INSTRUCTION_FORMAT22cs_FIELD REGISTER COMMA REGISTER COMMA FIELD_OFFSET ) 11916 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:962:5: INSTRUCTION_FORMAT22cs_FIELD REGISTER COMMA REGISTER COMMA FIELD_OFFSET 11917 { 11918 root_0 = (CommonTree)adaptor.nil(); 11919 11920 11921 INSTRUCTION_FORMAT22cs_FIELD361=(Token)match(input,INSTRUCTION_FORMAT22cs_FIELD,FOLLOW_INSTRUCTION_FORMAT22cs_FIELD_in_insn_format22cs_field4754); 11922 INSTRUCTION_FORMAT22cs_FIELD361_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT22cs_FIELD361); 11923 adaptor.addChild(root_0, INSTRUCTION_FORMAT22cs_FIELD361_tree); 11924 11925 REGISTER362=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22cs_field4756); 11926 REGISTER362_tree = (CommonTree)adaptor.create(REGISTER362); 11927 adaptor.addChild(root_0, REGISTER362_tree); 11928 11929 COMMA363=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22cs_field4758); 11930 COMMA363_tree = (CommonTree)adaptor.create(COMMA363); 11931 adaptor.addChild(root_0, COMMA363_tree); 11932 11933 REGISTER364=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22cs_field4760); 11934 REGISTER364_tree = (CommonTree)adaptor.create(REGISTER364); 11935 adaptor.addChild(root_0, REGISTER364_tree); 11936 11937 COMMA365=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22cs_field4762); 11938 COMMA365_tree = (CommonTree)adaptor.create(COMMA365); 11939 adaptor.addChild(root_0, COMMA365_tree); 11940 11941 FIELD_OFFSET366=(Token)match(input,FIELD_OFFSET,FOLLOW_FIELD_OFFSET_in_insn_format22cs_field4764); 11942 FIELD_OFFSET366_tree = (CommonTree)adaptor.create(FIELD_OFFSET366); 11943 adaptor.addChild(root_0, FIELD_OFFSET366_tree); 11944 11945 11946 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT22cs_FIELD361!=null?INSTRUCTION_FORMAT22cs_FIELD361.getText():null)); 11947 11948 } 11949 11950 retval.stop = input.LT(-1); 11951 11952 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 11953 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 11954 11955 } 11956 catch (RecognitionException re) { 11957 reportError(re); 11958 recover(input,re); 11959 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 11960 } 11961 finally { 11962 // do for sure before leaving 11963 } 11964 return retval; 11965 } 11966 // $ANTLR end "insn_format22cs_field" 11967 11968 11969 public static class insn_format22s_return extends ParserRuleReturnScope { 11970 CommonTree tree; 11971 @Override 11972 public CommonTree getTree() { return tree; } 11973 }; 11974 11975 11976 // $ANTLR start "insn_format22s" 11977 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:967:1: insn_format22s : instruction_format22s REGISTER COMMA REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT22s[$start, \"I_STATEMENT_FORMAT22s\"] instruction_format22s REGISTER REGISTER integral_literal ) ; 11978 public final smaliParser.insn_format22s_return insn_format22s() throws RecognitionException { 11979 smaliParser.insn_format22s_return retval = new smaliParser.insn_format22s_return(); 11980 retval.start = input.LT(1); 11981 11982 CommonTree root_0 = null; 11983 11984 Token REGISTER368=null; 11985 Token COMMA369=null; 11986 Token REGISTER370=null; 11987 Token COMMA371=null; 11988 ParserRuleReturnScope instruction_format22s367 =null; 11989 ParserRuleReturnScope integral_literal372 =null; 11990 11991 CommonTree REGISTER368_tree=null; 11992 CommonTree COMMA369_tree=null; 11993 CommonTree REGISTER370_tree=null; 11994 CommonTree COMMA371_tree=null; 11995 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 11996 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 11997 RewriteRuleSubtreeStream stream_integral_literal=new RewriteRuleSubtreeStream(adaptor,"rule integral_literal"); 11998 RewriteRuleSubtreeStream stream_instruction_format22s=new RewriteRuleSubtreeStream(adaptor,"rule instruction_format22s"); 11999 12000 try { 12001 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:968:3: ( instruction_format22s REGISTER COMMA REGISTER COMMA integral_literal -> ^( I_STATEMENT_FORMAT22s[$start, \"I_STATEMENT_FORMAT22s\"] instruction_format22s REGISTER REGISTER integral_literal ) ) 12002 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:969:5: instruction_format22s REGISTER COMMA REGISTER COMMA integral_literal 12003 { 12004 pushFollow(FOLLOW_instruction_format22s_in_insn_format22s4785); 12005 instruction_format22s367=instruction_format22s(); 12006 state._fsp--; 12007 12008 stream_instruction_format22s.add(instruction_format22s367.getTree()); 12009 REGISTER368=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22s4787); 12010 stream_REGISTER.add(REGISTER368); 12011 12012 COMMA369=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22s4789); 12013 stream_COMMA.add(COMMA369); 12014 12015 REGISTER370=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22s4791); 12016 stream_REGISTER.add(REGISTER370); 12017 12018 COMMA371=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22s4793); 12019 stream_COMMA.add(COMMA371); 12020 12021 pushFollow(FOLLOW_integral_literal_in_insn_format22s4795); 12022 integral_literal372=integral_literal(); 12023 state._fsp--; 12024 12025 stream_integral_literal.add(integral_literal372.getTree()); 12026 // AST REWRITE 12027 // elements: REGISTER, integral_literal, REGISTER, instruction_format22s 12028 // token labels: 12029 // rule labels: retval 12030 // token list labels: 12031 // rule list labels: 12032 // wildcard labels: 12033 retval.tree = root_0; 12034 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12035 12036 root_0 = (CommonTree)adaptor.nil(); 12037 // 970:5: -> ^( I_STATEMENT_FORMAT22s[$start, \"I_STATEMENT_FORMAT22s\"] instruction_format22s REGISTER REGISTER integral_literal ) 12038 { 12039 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:970:8: ^( I_STATEMENT_FORMAT22s[$start, \"I_STATEMENT_FORMAT22s\"] instruction_format22s REGISTER REGISTER integral_literal ) 12040 { 12041 CommonTree root_1 = (CommonTree)adaptor.nil(); 12042 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22s, (retval.start), "I_STATEMENT_FORMAT22s"), root_1); 12043 adaptor.addChild(root_1, stream_instruction_format22s.nextTree()); 12044 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12045 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12046 adaptor.addChild(root_1, stream_integral_literal.nextTree()); 12047 adaptor.addChild(root_0, root_1); 12048 } 12049 12050 } 12051 12052 12053 retval.tree = root_0; 12054 12055 } 12056 12057 retval.stop = input.LT(-1); 12058 12059 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12060 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12061 12062 } 12063 catch (RecognitionException re) { 12064 reportError(re); 12065 recover(input,re); 12066 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12067 } 12068 finally { 12069 // do for sure before leaving 12070 } 12071 return retval; 12072 } 12073 // $ANTLR end "insn_format22s" 12074 12075 12076 public static class insn_format22t_return extends ParserRuleReturnScope { 12077 CommonTree tree; 12078 @Override 12079 public CommonTree getTree() { return tree; } 12080 }; 12081 12082 12083 // $ANTLR start "insn_format22t" 12084 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:972:1: insn_format22t : INSTRUCTION_FORMAT22t REGISTER COMMA REGISTER COMMA label_ref -> ^( I_STATEMENT_FORMAT22t[$start, \"I_STATEMENT_FFORMAT22t\"] INSTRUCTION_FORMAT22t REGISTER REGISTER label_ref ) ; 12085 public final smaliParser.insn_format22t_return insn_format22t() throws RecognitionException { 12086 smaliParser.insn_format22t_return retval = new smaliParser.insn_format22t_return(); 12087 retval.start = input.LT(1); 12088 12089 CommonTree root_0 = null; 12090 12091 Token INSTRUCTION_FORMAT22t373=null; 12092 Token REGISTER374=null; 12093 Token COMMA375=null; 12094 Token REGISTER376=null; 12095 Token COMMA377=null; 12096 ParserRuleReturnScope label_ref378 =null; 12097 12098 CommonTree INSTRUCTION_FORMAT22t373_tree=null; 12099 CommonTree REGISTER374_tree=null; 12100 CommonTree COMMA375_tree=null; 12101 CommonTree REGISTER376_tree=null; 12102 CommonTree COMMA377_tree=null; 12103 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12104 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 12105 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22t"); 12106 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 12107 12108 try { 12109 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:973:3: ( INSTRUCTION_FORMAT22t REGISTER COMMA REGISTER COMMA label_ref -> ^( I_STATEMENT_FORMAT22t[$start, \"I_STATEMENT_FFORMAT22t\"] INSTRUCTION_FORMAT22t REGISTER REGISTER label_ref ) ) 12110 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:974:5: INSTRUCTION_FORMAT22t REGISTER COMMA REGISTER COMMA label_ref 12111 { 12112 INSTRUCTION_FORMAT22t373=(Token)match(input,INSTRUCTION_FORMAT22t,FOLLOW_INSTRUCTION_FORMAT22t_in_insn_format22t4829); 12113 stream_INSTRUCTION_FORMAT22t.add(INSTRUCTION_FORMAT22t373); 12114 12115 REGISTER374=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22t4831); 12116 stream_REGISTER.add(REGISTER374); 12117 12118 COMMA375=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22t4833); 12119 stream_COMMA.add(COMMA375); 12120 12121 REGISTER376=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22t4835); 12122 stream_REGISTER.add(REGISTER376); 12123 12124 COMMA377=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22t4837); 12125 stream_COMMA.add(COMMA377); 12126 12127 pushFollow(FOLLOW_label_ref_in_insn_format22t4839); 12128 label_ref378=label_ref(); 12129 state._fsp--; 12130 12131 stream_label_ref.add(label_ref378.getTree()); 12132 // AST REWRITE 12133 // elements: REGISTER, label_ref, INSTRUCTION_FORMAT22t, REGISTER 12134 // token labels: 12135 // rule labels: retval 12136 // token list labels: 12137 // rule list labels: 12138 // wildcard labels: 12139 retval.tree = root_0; 12140 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12141 12142 root_0 = (CommonTree)adaptor.nil(); 12143 // 975:5: -> ^( I_STATEMENT_FORMAT22t[$start, \"I_STATEMENT_FFORMAT22t\"] INSTRUCTION_FORMAT22t REGISTER REGISTER label_ref ) 12144 { 12145 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:975:8: ^( I_STATEMENT_FORMAT22t[$start, \"I_STATEMENT_FFORMAT22t\"] INSTRUCTION_FORMAT22t REGISTER REGISTER label_ref ) 12146 { 12147 CommonTree root_1 = (CommonTree)adaptor.nil(); 12148 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22t, (retval.start), "I_STATEMENT_FFORMAT22t"), root_1); 12149 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22t.nextNode()); 12150 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12151 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12152 adaptor.addChild(root_1, stream_label_ref.nextTree()); 12153 adaptor.addChild(root_0, root_1); 12154 } 12155 12156 } 12157 12158 12159 retval.tree = root_0; 12160 12161 } 12162 12163 retval.stop = input.LT(-1); 12164 12165 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12166 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12167 12168 } 12169 catch (RecognitionException re) { 12170 reportError(re); 12171 recover(input,re); 12172 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12173 } 12174 finally { 12175 // do for sure before leaving 12176 } 12177 return retval; 12178 } 12179 // $ANTLR end "insn_format22t" 12180 12181 12182 public static class insn_format22x_return extends ParserRuleReturnScope { 12183 CommonTree tree; 12184 @Override 12185 public CommonTree getTree() { return tree; } 12186 }; 12187 12188 12189 // $ANTLR start "insn_format22x" 12190 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:977:1: insn_format22x : INSTRUCTION_FORMAT22x REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT22x[$start, \"I_STATEMENT_FORMAT22x\"] INSTRUCTION_FORMAT22x REGISTER REGISTER ) ; 12191 public final smaliParser.insn_format22x_return insn_format22x() throws RecognitionException { 12192 smaliParser.insn_format22x_return retval = new smaliParser.insn_format22x_return(); 12193 retval.start = input.LT(1); 12194 12195 CommonTree root_0 = null; 12196 12197 Token INSTRUCTION_FORMAT22x379=null; 12198 Token REGISTER380=null; 12199 Token COMMA381=null; 12200 Token REGISTER382=null; 12201 12202 CommonTree INSTRUCTION_FORMAT22x379_tree=null; 12203 CommonTree REGISTER380_tree=null; 12204 CommonTree COMMA381_tree=null; 12205 CommonTree REGISTER382_tree=null; 12206 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT22x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT22x"); 12207 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12208 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 12209 12210 try { 12211 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:978:3: ( INSTRUCTION_FORMAT22x REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT22x[$start, \"I_STATEMENT_FORMAT22x\"] INSTRUCTION_FORMAT22x REGISTER REGISTER ) ) 12212 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:979:5: INSTRUCTION_FORMAT22x REGISTER COMMA REGISTER 12213 { 12214 INSTRUCTION_FORMAT22x379=(Token)match(input,INSTRUCTION_FORMAT22x,FOLLOW_INSTRUCTION_FORMAT22x_in_insn_format22x4873); 12215 stream_INSTRUCTION_FORMAT22x.add(INSTRUCTION_FORMAT22x379); 12216 12217 REGISTER380=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22x4875); 12218 stream_REGISTER.add(REGISTER380); 12219 12220 COMMA381=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format22x4877); 12221 stream_COMMA.add(COMMA381); 12222 12223 REGISTER382=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format22x4879); 12224 stream_REGISTER.add(REGISTER382); 12225 12226 // AST REWRITE 12227 // elements: REGISTER, REGISTER, INSTRUCTION_FORMAT22x 12228 // token labels: 12229 // rule labels: retval 12230 // token list labels: 12231 // rule list labels: 12232 // wildcard labels: 12233 retval.tree = root_0; 12234 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12235 12236 root_0 = (CommonTree)adaptor.nil(); 12237 // 980:5: -> ^( I_STATEMENT_FORMAT22x[$start, \"I_STATEMENT_FORMAT22x\"] INSTRUCTION_FORMAT22x REGISTER REGISTER ) 12238 { 12239 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:980:8: ^( I_STATEMENT_FORMAT22x[$start, \"I_STATEMENT_FORMAT22x\"] INSTRUCTION_FORMAT22x REGISTER REGISTER ) 12240 { 12241 CommonTree root_1 = (CommonTree)adaptor.nil(); 12242 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT22x, (retval.start), "I_STATEMENT_FORMAT22x"), root_1); 12243 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT22x.nextNode()); 12244 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12245 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12246 adaptor.addChild(root_0, root_1); 12247 } 12248 12249 } 12250 12251 12252 retval.tree = root_0; 12253 12254 } 12255 12256 retval.stop = input.LT(-1); 12257 12258 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12259 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12260 12261 } 12262 catch (RecognitionException re) { 12263 reportError(re); 12264 recover(input,re); 12265 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12266 } 12267 finally { 12268 // do for sure before leaving 12269 } 12270 return retval; 12271 } 12272 // $ANTLR end "insn_format22x" 12273 12274 12275 public static class insn_format23x_return extends ParserRuleReturnScope { 12276 CommonTree tree; 12277 @Override 12278 public CommonTree getTree() { return tree; } 12279 }; 12280 12281 12282 // $ANTLR start "insn_format23x" 12283 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:982:1: insn_format23x : INSTRUCTION_FORMAT23x REGISTER COMMA REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT23x[$start, \"I_STATEMENT_FORMAT23x\"] INSTRUCTION_FORMAT23x REGISTER REGISTER REGISTER ) ; 12284 public final smaliParser.insn_format23x_return insn_format23x() throws RecognitionException { 12285 smaliParser.insn_format23x_return retval = new smaliParser.insn_format23x_return(); 12286 retval.start = input.LT(1); 12287 12288 CommonTree root_0 = null; 12289 12290 Token INSTRUCTION_FORMAT23x383=null; 12291 Token REGISTER384=null; 12292 Token COMMA385=null; 12293 Token REGISTER386=null; 12294 Token COMMA387=null; 12295 Token REGISTER388=null; 12296 12297 CommonTree INSTRUCTION_FORMAT23x383_tree=null; 12298 CommonTree REGISTER384_tree=null; 12299 CommonTree COMMA385_tree=null; 12300 CommonTree REGISTER386_tree=null; 12301 CommonTree COMMA387_tree=null; 12302 CommonTree REGISTER388_tree=null; 12303 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12304 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 12305 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT23x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT23x"); 12306 12307 try { 12308 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:983:3: ( INSTRUCTION_FORMAT23x REGISTER COMMA REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT23x[$start, \"I_STATEMENT_FORMAT23x\"] INSTRUCTION_FORMAT23x REGISTER REGISTER REGISTER ) ) 12309 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:984:5: INSTRUCTION_FORMAT23x REGISTER COMMA REGISTER COMMA REGISTER 12310 { 12311 INSTRUCTION_FORMAT23x383=(Token)match(input,INSTRUCTION_FORMAT23x,FOLLOW_INSTRUCTION_FORMAT23x_in_insn_format23x4911); 12312 stream_INSTRUCTION_FORMAT23x.add(INSTRUCTION_FORMAT23x383); 12313 12314 REGISTER384=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format23x4913); 12315 stream_REGISTER.add(REGISTER384); 12316 12317 COMMA385=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format23x4915); 12318 stream_COMMA.add(COMMA385); 12319 12320 REGISTER386=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format23x4917); 12321 stream_REGISTER.add(REGISTER386); 12322 12323 COMMA387=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format23x4919); 12324 stream_COMMA.add(COMMA387); 12325 12326 REGISTER388=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format23x4921); 12327 stream_REGISTER.add(REGISTER388); 12328 12329 // AST REWRITE 12330 // elements: REGISTER, INSTRUCTION_FORMAT23x, REGISTER, REGISTER 12331 // token labels: 12332 // rule labels: retval 12333 // token list labels: 12334 // rule list labels: 12335 // wildcard labels: 12336 retval.tree = root_0; 12337 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12338 12339 root_0 = (CommonTree)adaptor.nil(); 12340 // 985:5: -> ^( I_STATEMENT_FORMAT23x[$start, \"I_STATEMENT_FORMAT23x\"] INSTRUCTION_FORMAT23x REGISTER REGISTER REGISTER ) 12341 { 12342 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:985:8: ^( I_STATEMENT_FORMAT23x[$start, \"I_STATEMENT_FORMAT23x\"] INSTRUCTION_FORMAT23x REGISTER REGISTER REGISTER ) 12343 { 12344 CommonTree root_1 = (CommonTree)adaptor.nil(); 12345 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT23x, (retval.start), "I_STATEMENT_FORMAT23x"), root_1); 12346 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT23x.nextNode()); 12347 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12348 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12349 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12350 adaptor.addChild(root_0, root_1); 12351 } 12352 12353 } 12354 12355 12356 retval.tree = root_0; 12357 12358 } 12359 12360 retval.stop = input.LT(-1); 12361 12362 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12363 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12364 12365 } 12366 catch (RecognitionException re) { 12367 reportError(re); 12368 recover(input,re); 12369 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12370 } 12371 finally { 12372 // do for sure before leaving 12373 } 12374 return retval; 12375 } 12376 // $ANTLR end "insn_format23x" 12377 12378 12379 public static class insn_format30t_return extends ParserRuleReturnScope { 12380 CommonTree tree; 12381 @Override 12382 public CommonTree getTree() { return tree; } 12383 }; 12384 12385 12386 // $ANTLR start "insn_format30t" 12387 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:987:1: insn_format30t : INSTRUCTION_FORMAT30t label_ref -> ^( I_STATEMENT_FORMAT30t[$start, \"I_STATEMENT_FORMAT30t\"] INSTRUCTION_FORMAT30t label_ref ) ; 12388 public final smaliParser.insn_format30t_return insn_format30t() throws RecognitionException { 12389 smaliParser.insn_format30t_return retval = new smaliParser.insn_format30t_return(); 12390 retval.start = input.LT(1); 12391 12392 CommonTree root_0 = null; 12393 12394 Token INSTRUCTION_FORMAT30t389=null; 12395 ParserRuleReturnScope label_ref390 =null; 12396 12397 CommonTree INSTRUCTION_FORMAT30t389_tree=null; 12398 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT30t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT30t"); 12399 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 12400 12401 try { 12402 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:988:3: ( INSTRUCTION_FORMAT30t label_ref -> ^( I_STATEMENT_FORMAT30t[$start, \"I_STATEMENT_FORMAT30t\"] INSTRUCTION_FORMAT30t label_ref ) ) 12403 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:989:5: INSTRUCTION_FORMAT30t label_ref 12404 { 12405 INSTRUCTION_FORMAT30t389=(Token)match(input,INSTRUCTION_FORMAT30t,FOLLOW_INSTRUCTION_FORMAT30t_in_insn_format30t4955); 12406 stream_INSTRUCTION_FORMAT30t.add(INSTRUCTION_FORMAT30t389); 12407 12408 pushFollow(FOLLOW_label_ref_in_insn_format30t4957); 12409 label_ref390=label_ref(); 12410 state._fsp--; 12411 12412 stream_label_ref.add(label_ref390.getTree()); 12413 // AST REWRITE 12414 // elements: label_ref, INSTRUCTION_FORMAT30t 12415 // token labels: 12416 // rule labels: retval 12417 // token list labels: 12418 // rule list labels: 12419 // wildcard labels: 12420 retval.tree = root_0; 12421 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12422 12423 root_0 = (CommonTree)adaptor.nil(); 12424 // 990:5: -> ^( I_STATEMENT_FORMAT30t[$start, \"I_STATEMENT_FORMAT30t\"] INSTRUCTION_FORMAT30t label_ref ) 12425 { 12426 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:990:8: ^( I_STATEMENT_FORMAT30t[$start, \"I_STATEMENT_FORMAT30t\"] INSTRUCTION_FORMAT30t label_ref ) 12427 { 12428 CommonTree root_1 = (CommonTree)adaptor.nil(); 12429 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT30t, (retval.start), "I_STATEMENT_FORMAT30t"), root_1); 12430 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT30t.nextNode()); 12431 adaptor.addChild(root_1, stream_label_ref.nextTree()); 12432 adaptor.addChild(root_0, root_1); 12433 } 12434 12435 } 12436 12437 12438 retval.tree = root_0; 12439 12440 } 12441 12442 retval.stop = input.LT(-1); 12443 12444 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12445 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12446 12447 } 12448 catch (RecognitionException re) { 12449 reportError(re); 12450 recover(input,re); 12451 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12452 } 12453 finally { 12454 // do for sure before leaving 12455 } 12456 return retval; 12457 } 12458 // $ANTLR end "insn_format30t" 12459 12460 12461 public static class insn_format31c_return extends ParserRuleReturnScope { 12462 CommonTree tree; 12463 @Override 12464 public CommonTree getTree() { return tree; } 12465 }; 12466 12467 12468 // $ANTLR start "insn_format31c" 12469 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:992:1: insn_format31c : INSTRUCTION_FORMAT31c REGISTER COMMA STRING_LITERAL -> ^( I_STATEMENT_FORMAT31c[$start, \"I_STATEMENT_FORMAT31c\"] INSTRUCTION_FORMAT31c REGISTER STRING_LITERAL ) ; 12470 public final smaliParser.insn_format31c_return insn_format31c() throws RecognitionException { 12471 smaliParser.insn_format31c_return retval = new smaliParser.insn_format31c_return(); 12472 retval.start = input.LT(1); 12473 12474 CommonTree root_0 = null; 12475 12476 Token INSTRUCTION_FORMAT31c391=null; 12477 Token REGISTER392=null; 12478 Token COMMA393=null; 12479 Token STRING_LITERAL394=null; 12480 12481 CommonTree INSTRUCTION_FORMAT31c391_tree=null; 12482 CommonTree REGISTER392_tree=null; 12483 CommonTree COMMA393_tree=null; 12484 CommonTree STRING_LITERAL394_tree=null; 12485 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT31c=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT31c"); 12486 RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL"); 12487 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12488 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 12489 12490 try { 12491 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:993:3: ( INSTRUCTION_FORMAT31c REGISTER COMMA STRING_LITERAL -> ^( I_STATEMENT_FORMAT31c[$start, \"I_STATEMENT_FORMAT31c\"] INSTRUCTION_FORMAT31c REGISTER STRING_LITERAL ) ) 12492 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:994:5: INSTRUCTION_FORMAT31c REGISTER COMMA STRING_LITERAL 12493 { 12494 INSTRUCTION_FORMAT31c391=(Token)match(input,INSTRUCTION_FORMAT31c,FOLLOW_INSTRUCTION_FORMAT31c_in_insn_format31c4987); 12495 stream_INSTRUCTION_FORMAT31c.add(INSTRUCTION_FORMAT31c391); 12496 12497 REGISTER392=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format31c4989); 12498 stream_REGISTER.add(REGISTER392); 12499 12500 COMMA393=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format31c4991); 12501 stream_COMMA.add(COMMA393); 12502 12503 STRING_LITERAL394=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_insn_format31c4993); 12504 stream_STRING_LITERAL.add(STRING_LITERAL394); 12505 12506 // AST REWRITE 12507 // elements: REGISTER, INSTRUCTION_FORMAT31c, STRING_LITERAL 12508 // token labels: 12509 // rule labels: retval 12510 // token list labels: 12511 // rule list labels: 12512 // wildcard labels: 12513 retval.tree = root_0; 12514 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12515 12516 root_0 = (CommonTree)adaptor.nil(); 12517 // 995:5: -> ^( I_STATEMENT_FORMAT31c[$start, \"I_STATEMENT_FORMAT31c\"] INSTRUCTION_FORMAT31c REGISTER STRING_LITERAL ) 12518 { 12519 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:995:7: ^( I_STATEMENT_FORMAT31c[$start, \"I_STATEMENT_FORMAT31c\"] INSTRUCTION_FORMAT31c REGISTER STRING_LITERAL ) 12520 { 12521 CommonTree root_1 = (CommonTree)adaptor.nil(); 12522 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT31c, (retval.start), "I_STATEMENT_FORMAT31c"), root_1); 12523 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT31c.nextNode()); 12524 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12525 adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode()); 12526 adaptor.addChild(root_0, root_1); 12527 } 12528 12529 } 12530 12531 12532 retval.tree = root_0; 12533 12534 } 12535 12536 retval.stop = input.LT(-1); 12537 12538 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12539 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12540 12541 } 12542 catch (RecognitionException re) { 12543 reportError(re); 12544 recover(input,re); 12545 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12546 } 12547 finally { 12548 // do for sure before leaving 12549 } 12550 return retval; 12551 } 12552 // $ANTLR end "insn_format31c" 12553 12554 12555 public static class insn_format31i_return extends ParserRuleReturnScope { 12556 CommonTree tree; 12557 @Override 12558 public CommonTree getTree() { return tree; } 12559 }; 12560 12561 12562 // $ANTLR start "insn_format31i" 12563 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:997:1: insn_format31i : instruction_format31i REGISTER COMMA fixed_32bit_literal -> ^( I_STATEMENT_FORMAT31i[$start, \"I_STATEMENT_FORMAT31i\"] instruction_format31i REGISTER fixed_32bit_literal ) ; 12564 public final smaliParser.insn_format31i_return insn_format31i() throws RecognitionException { 12565 smaliParser.insn_format31i_return retval = new smaliParser.insn_format31i_return(); 12566 retval.start = input.LT(1); 12567 12568 CommonTree root_0 = null; 12569 12570 Token REGISTER396=null; 12571 Token COMMA397=null; 12572 ParserRuleReturnScope instruction_format31i395 =null; 12573 ParserRuleReturnScope fixed_32bit_literal398 =null; 12574 12575 CommonTree REGISTER396_tree=null; 12576 CommonTree COMMA397_tree=null; 12577 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12578 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 12579 RewriteRuleSubtreeStream stream_instruction_format31i=new RewriteRuleSubtreeStream(adaptor,"rule instruction_format31i"); 12580 RewriteRuleSubtreeStream stream_fixed_32bit_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_32bit_literal"); 12581 12582 try { 12583 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:998:3: ( instruction_format31i REGISTER COMMA fixed_32bit_literal -> ^( I_STATEMENT_FORMAT31i[$start, \"I_STATEMENT_FORMAT31i\"] instruction_format31i REGISTER fixed_32bit_literal ) ) 12584 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:999:5: instruction_format31i REGISTER COMMA fixed_32bit_literal 12585 { 12586 pushFollow(FOLLOW_instruction_format31i_in_insn_format31i5024); 12587 instruction_format31i395=instruction_format31i(); 12588 state._fsp--; 12589 12590 stream_instruction_format31i.add(instruction_format31i395.getTree()); 12591 REGISTER396=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format31i5026); 12592 stream_REGISTER.add(REGISTER396); 12593 12594 COMMA397=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format31i5028); 12595 stream_COMMA.add(COMMA397); 12596 12597 pushFollow(FOLLOW_fixed_32bit_literal_in_insn_format31i5030); 12598 fixed_32bit_literal398=fixed_32bit_literal(); 12599 state._fsp--; 12600 12601 stream_fixed_32bit_literal.add(fixed_32bit_literal398.getTree()); 12602 // AST REWRITE 12603 // elements: instruction_format31i, fixed_32bit_literal, REGISTER 12604 // token labels: 12605 // rule labels: retval 12606 // token list labels: 12607 // rule list labels: 12608 // wildcard labels: 12609 retval.tree = root_0; 12610 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12611 12612 root_0 = (CommonTree)adaptor.nil(); 12613 // 1000:5: -> ^( I_STATEMENT_FORMAT31i[$start, \"I_STATEMENT_FORMAT31i\"] instruction_format31i REGISTER fixed_32bit_literal ) 12614 { 12615 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1000:8: ^( I_STATEMENT_FORMAT31i[$start, \"I_STATEMENT_FORMAT31i\"] instruction_format31i REGISTER fixed_32bit_literal ) 12616 { 12617 CommonTree root_1 = (CommonTree)adaptor.nil(); 12618 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT31i, (retval.start), "I_STATEMENT_FORMAT31i"), root_1); 12619 adaptor.addChild(root_1, stream_instruction_format31i.nextTree()); 12620 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12621 adaptor.addChild(root_1, stream_fixed_32bit_literal.nextTree()); 12622 adaptor.addChild(root_0, root_1); 12623 } 12624 12625 } 12626 12627 12628 retval.tree = root_0; 12629 12630 } 12631 12632 retval.stop = input.LT(-1); 12633 12634 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12635 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12636 12637 } 12638 catch (RecognitionException re) { 12639 reportError(re); 12640 recover(input,re); 12641 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12642 } 12643 finally { 12644 // do for sure before leaving 12645 } 12646 return retval; 12647 } 12648 // $ANTLR end "insn_format31i" 12649 12650 12651 public static class insn_format31t_return extends ParserRuleReturnScope { 12652 CommonTree tree; 12653 @Override 12654 public CommonTree getTree() { return tree; } 12655 }; 12656 12657 12658 // $ANTLR start "insn_format31t" 12659 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1002:1: insn_format31t : INSTRUCTION_FORMAT31t REGISTER COMMA label_ref -> ^( I_STATEMENT_FORMAT31t[$start, \"I_STATEMENT_FORMAT31t\"] INSTRUCTION_FORMAT31t REGISTER label_ref ) ; 12660 public final smaliParser.insn_format31t_return insn_format31t() throws RecognitionException { 12661 smaliParser.insn_format31t_return retval = new smaliParser.insn_format31t_return(); 12662 retval.start = input.LT(1); 12663 12664 CommonTree root_0 = null; 12665 12666 Token INSTRUCTION_FORMAT31t399=null; 12667 Token REGISTER400=null; 12668 Token COMMA401=null; 12669 ParserRuleReturnScope label_ref402 =null; 12670 12671 CommonTree INSTRUCTION_FORMAT31t399_tree=null; 12672 CommonTree REGISTER400_tree=null; 12673 CommonTree COMMA401_tree=null; 12674 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT31t=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT31t"); 12675 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12676 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 12677 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 12678 12679 try { 12680 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1003:3: ( INSTRUCTION_FORMAT31t REGISTER COMMA label_ref -> ^( I_STATEMENT_FORMAT31t[$start, \"I_STATEMENT_FORMAT31t\"] INSTRUCTION_FORMAT31t REGISTER label_ref ) ) 12681 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1004:5: INSTRUCTION_FORMAT31t REGISTER COMMA label_ref 12682 { 12683 INSTRUCTION_FORMAT31t399=(Token)match(input,INSTRUCTION_FORMAT31t,FOLLOW_INSTRUCTION_FORMAT31t_in_insn_format31t5062); 12684 stream_INSTRUCTION_FORMAT31t.add(INSTRUCTION_FORMAT31t399); 12685 12686 REGISTER400=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format31t5064); 12687 stream_REGISTER.add(REGISTER400); 12688 12689 COMMA401=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format31t5066); 12690 stream_COMMA.add(COMMA401); 12691 12692 pushFollow(FOLLOW_label_ref_in_insn_format31t5068); 12693 label_ref402=label_ref(); 12694 state._fsp--; 12695 12696 stream_label_ref.add(label_ref402.getTree()); 12697 // AST REWRITE 12698 // elements: REGISTER, INSTRUCTION_FORMAT31t, label_ref 12699 // token labels: 12700 // rule labels: retval 12701 // token list labels: 12702 // rule list labels: 12703 // wildcard labels: 12704 retval.tree = root_0; 12705 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12706 12707 root_0 = (CommonTree)adaptor.nil(); 12708 // 1005:5: -> ^( I_STATEMENT_FORMAT31t[$start, \"I_STATEMENT_FORMAT31t\"] INSTRUCTION_FORMAT31t REGISTER label_ref ) 12709 { 12710 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1005:8: ^( I_STATEMENT_FORMAT31t[$start, \"I_STATEMENT_FORMAT31t\"] INSTRUCTION_FORMAT31t REGISTER label_ref ) 12711 { 12712 CommonTree root_1 = (CommonTree)adaptor.nil(); 12713 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT31t, (retval.start), "I_STATEMENT_FORMAT31t"), root_1); 12714 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT31t.nextNode()); 12715 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12716 adaptor.addChild(root_1, stream_label_ref.nextTree()); 12717 adaptor.addChild(root_0, root_1); 12718 } 12719 12720 } 12721 12722 12723 retval.tree = root_0; 12724 12725 } 12726 12727 retval.stop = input.LT(-1); 12728 12729 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12730 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12731 12732 } 12733 catch (RecognitionException re) { 12734 reportError(re); 12735 recover(input,re); 12736 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12737 } 12738 finally { 12739 // do for sure before leaving 12740 } 12741 return retval; 12742 } 12743 // $ANTLR end "insn_format31t" 12744 12745 12746 public static class insn_format32x_return extends ParserRuleReturnScope { 12747 CommonTree tree; 12748 @Override 12749 public CommonTree getTree() { return tree; } 12750 }; 12751 12752 12753 // $ANTLR start "insn_format32x" 12754 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1007:1: insn_format32x : INSTRUCTION_FORMAT32x REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT32x[$start, \"I_STATEMENT_FORMAT32x\"] INSTRUCTION_FORMAT32x REGISTER REGISTER ) ; 12755 public final smaliParser.insn_format32x_return insn_format32x() throws RecognitionException { 12756 smaliParser.insn_format32x_return retval = new smaliParser.insn_format32x_return(); 12757 retval.start = input.LT(1); 12758 12759 CommonTree root_0 = null; 12760 12761 Token INSTRUCTION_FORMAT32x403=null; 12762 Token REGISTER404=null; 12763 Token COMMA405=null; 12764 Token REGISTER406=null; 12765 12766 CommonTree INSTRUCTION_FORMAT32x403_tree=null; 12767 CommonTree REGISTER404_tree=null; 12768 CommonTree COMMA405_tree=null; 12769 CommonTree REGISTER406_tree=null; 12770 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12771 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 12772 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT32x=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT32x"); 12773 12774 try { 12775 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1008:3: ( INSTRUCTION_FORMAT32x REGISTER COMMA REGISTER -> ^( I_STATEMENT_FORMAT32x[$start, \"I_STATEMENT_FORMAT32x\"] INSTRUCTION_FORMAT32x REGISTER REGISTER ) ) 12776 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1009:5: INSTRUCTION_FORMAT32x REGISTER COMMA REGISTER 12777 { 12778 INSTRUCTION_FORMAT32x403=(Token)match(input,INSTRUCTION_FORMAT32x,FOLLOW_INSTRUCTION_FORMAT32x_in_insn_format32x5100); 12779 stream_INSTRUCTION_FORMAT32x.add(INSTRUCTION_FORMAT32x403); 12780 12781 REGISTER404=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format32x5102); 12782 stream_REGISTER.add(REGISTER404); 12783 12784 COMMA405=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format32x5104); 12785 stream_COMMA.add(COMMA405); 12786 12787 REGISTER406=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format32x5106); 12788 stream_REGISTER.add(REGISTER406); 12789 12790 // AST REWRITE 12791 // elements: REGISTER, INSTRUCTION_FORMAT32x, REGISTER 12792 // token labels: 12793 // rule labels: retval 12794 // token list labels: 12795 // rule list labels: 12796 // wildcard labels: 12797 retval.tree = root_0; 12798 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12799 12800 root_0 = (CommonTree)adaptor.nil(); 12801 // 1010:5: -> ^( I_STATEMENT_FORMAT32x[$start, \"I_STATEMENT_FORMAT32x\"] INSTRUCTION_FORMAT32x REGISTER REGISTER ) 12802 { 12803 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1010:8: ^( I_STATEMENT_FORMAT32x[$start, \"I_STATEMENT_FORMAT32x\"] INSTRUCTION_FORMAT32x REGISTER REGISTER ) 12804 { 12805 CommonTree root_1 = (CommonTree)adaptor.nil(); 12806 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT32x, (retval.start), "I_STATEMENT_FORMAT32x"), root_1); 12807 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT32x.nextNode()); 12808 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12809 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 12810 adaptor.addChild(root_0, root_1); 12811 } 12812 12813 } 12814 12815 12816 retval.tree = root_0; 12817 12818 } 12819 12820 retval.stop = input.LT(-1); 12821 12822 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12823 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12824 12825 } 12826 catch (RecognitionException re) { 12827 reportError(re); 12828 recover(input,re); 12829 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12830 } 12831 finally { 12832 // do for sure before leaving 12833 } 12834 return retval; 12835 } 12836 // $ANTLR end "insn_format32x" 12837 12838 12839 public static class insn_format35c_method_return extends ParserRuleReturnScope { 12840 CommonTree tree; 12841 @Override 12842 public CommonTree getTree() { return tree; } 12843 }; 12844 12845 12846 // $ANTLR start "insn_format35c_method" 12847 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1012:1: insn_format35c_method : INSTRUCTION_FORMAT35c_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference -> ^( I_STATEMENT_FORMAT35c_METHOD[$start, \"I_STATEMENT_FORMAT35c_METHOD\"] INSTRUCTION_FORMAT35c_METHOD register_list method_reference ) ; 12848 public final smaliParser.insn_format35c_method_return insn_format35c_method() throws RecognitionException { 12849 smaliParser.insn_format35c_method_return retval = new smaliParser.insn_format35c_method_return(); 12850 retval.start = input.LT(1); 12851 12852 CommonTree root_0 = null; 12853 12854 Token INSTRUCTION_FORMAT35c_METHOD407=null; 12855 Token OPEN_BRACE408=null; 12856 Token CLOSE_BRACE410=null; 12857 Token COMMA411=null; 12858 ParserRuleReturnScope register_list409 =null; 12859 ParserRuleReturnScope method_reference412 =null; 12860 12861 CommonTree INSTRUCTION_FORMAT35c_METHOD407_tree=null; 12862 CommonTree OPEN_BRACE408_tree=null; 12863 CommonTree CLOSE_BRACE410_tree=null; 12864 CommonTree COMMA411_tree=null; 12865 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35c_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35c_METHOD"); 12866 RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE"); 12867 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12868 RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE"); 12869 RewriteRuleSubtreeStream stream_register_list=new RewriteRuleSubtreeStream(adaptor,"rule register_list"); 12870 RewriteRuleSubtreeStream stream_method_reference=new RewriteRuleSubtreeStream(adaptor,"rule method_reference"); 12871 12872 try { 12873 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1013:3: ( INSTRUCTION_FORMAT35c_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference -> ^( I_STATEMENT_FORMAT35c_METHOD[$start, \"I_STATEMENT_FORMAT35c_METHOD\"] INSTRUCTION_FORMAT35c_METHOD register_list method_reference ) ) 12874 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1014:5: INSTRUCTION_FORMAT35c_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference 12875 { 12876 INSTRUCTION_FORMAT35c_METHOD407=(Token)match(input,INSTRUCTION_FORMAT35c_METHOD,FOLLOW_INSTRUCTION_FORMAT35c_METHOD_in_insn_format35c_method5138); 12877 stream_INSTRUCTION_FORMAT35c_METHOD.add(INSTRUCTION_FORMAT35c_METHOD407); 12878 12879 OPEN_BRACE408=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format35c_method5140); 12880 stream_OPEN_BRACE.add(OPEN_BRACE408); 12881 12882 pushFollow(FOLLOW_register_list_in_insn_format35c_method5142); 12883 register_list409=register_list(); 12884 state._fsp--; 12885 12886 stream_register_list.add(register_list409.getTree()); 12887 CLOSE_BRACE410=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format35c_method5144); 12888 stream_CLOSE_BRACE.add(CLOSE_BRACE410); 12889 12890 COMMA411=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format35c_method5146); 12891 stream_COMMA.add(COMMA411); 12892 12893 pushFollow(FOLLOW_method_reference_in_insn_format35c_method5148); 12894 method_reference412=method_reference(); 12895 state._fsp--; 12896 12897 stream_method_reference.add(method_reference412.getTree()); 12898 // AST REWRITE 12899 // elements: method_reference, register_list, INSTRUCTION_FORMAT35c_METHOD 12900 // token labels: 12901 // rule labels: retval 12902 // token list labels: 12903 // rule list labels: 12904 // wildcard labels: 12905 retval.tree = root_0; 12906 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 12907 12908 root_0 = (CommonTree)adaptor.nil(); 12909 // 1015:5: -> ^( I_STATEMENT_FORMAT35c_METHOD[$start, \"I_STATEMENT_FORMAT35c_METHOD\"] INSTRUCTION_FORMAT35c_METHOD register_list method_reference ) 12910 { 12911 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1015:8: ^( I_STATEMENT_FORMAT35c_METHOD[$start, \"I_STATEMENT_FORMAT35c_METHOD\"] INSTRUCTION_FORMAT35c_METHOD register_list method_reference ) 12912 { 12913 CommonTree root_1 = (CommonTree)adaptor.nil(); 12914 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT35c_METHOD, (retval.start), "I_STATEMENT_FORMAT35c_METHOD"), root_1); 12915 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT35c_METHOD.nextNode()); 12916 adaptor.addChild(root_1, stream_register_list.nextTree()); 12917 adaptor.addChild(root_1, stream_method_reference.nextTree()); 12918 adaptor.addChild(root_0, root_1); 12919 } 12920 12921 } 12922 12923 12924 retval.tree = root_0; 12925 12926 } 12927 12928 retval.stop = input.LT(-1); 12929 12930 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 12931 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 12932 12933 } 12934 catch (RecognitionException re) { 12935 reportError(re); 12936 recover(input,re); 12937 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 12938 } 12939 finally { 12940 // do for sure before leaving 12941 } 12942 return retval; 12943 } 12944 // $ANTLR end "insn_format35c_method" 12945 12946 12947 public static class insn_format35c_type_return extends ParserRuleReturnScope { 12948 CommonTree tree; 12949 @Override 12950 public CommonTree getTree() { return tree; } 12951 }; 12952 12953 12954 // $ANTLR start "insn_format35c_type" 12955 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1017:1: insn_format35c_type : INSTRUCTION_FORMAT35c_TYPE OPEN_BRACE register_list CLOSE_BRACE COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT35c_TYPE[$start, \"I_STATEMENT_FORMAT35c_TYPE\"] INSTRUCTION_FORMAT35c_TYPE register_list nonvoid_type_descriptor ) ; 12956 public final smaliParser.insn_format35c_type_return insn_format35c_type() throws RecognitionException { 12957 smaliParser.insn_format35c_type_return retval = new smaliParser.insn_format35c_type_return(); 12958 retval.start = input.LT(1); 12959 12960 CommonTree root_0 = null; 12961 12962 Token INSTRUCTION_FORMAT35c_TYPE413=null; 12963 Token OPEN_BRACE414=null; 12964 Token CLOSE_BRACE416=null; 12965 Token COMMA417=null; 12966 ParserRuleReturnScope register_list415 =null; 12967 ParserRuleReturnScope nonvoid_type_descriptor418 =null; 12968 12969 CommonTree INSTRUCTION_FORMAT35c_TYPE413_tree=null; 12970 CommonTree OPEN_BRACE414_tree=null; 12971 CommonTree CLOSE_BRACE416_tree=null; 12972 CommonTree COMMA417_tree=null; 12973 RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE"); 12974 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 12975 RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE"); 12976 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT35c_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT35c_TYPE"); 12977 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 12978 RewriteRuleSubtreeStream stream_register_list=new RewriteRuleSubtreeStream(adaptor,"rule register_list"); 12979 12980 try { 12981 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1018:3: ( INSTRUCTION_FORMAT35c_TYPE OPEN_BRACE register_list CLOSE_BRACE COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT35c_TYPE[$start, \"I_STATEMENT_FORMAT35c_TYPE\"] INSTRUCTION_FORMAT35c_TYPE register_list nonvoid_type_descriptor ) ) 12982 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1019:5: INSTRUCTION_FORMAT35c_TYPE OPEN_BRACE register_list CLOSE_BRACE COMMA nonvoid_type_descriptor 12983 { 12984 INSTRUCTION_FORMAT35c_TYPE413=(Token)match(input,INSTRUCTION_FORMAT35c_TYPE,FOLLOW_INSTRUCTION_FORMAT35c_TYPE_in_insn_format35c_type5180); 12985 stream_INSTRUCTION_FORMAT35c_TYPE.add(INSTRUCTION_FORMAT35c_TYPE413); 12986 12987 OPEN_BRACE414=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format35c_type5182); 12988 stream_OPEN_BRACE.add(OPEN_BRACE414); 12989 12990 pushFollow(FOLLOW_register_list_in_insn_format35c_type5184); 12991 register_list415=register_list(); 12992 state._fsp--; 12993 12994 stream_register_list.add(register_list415.getTree()); 12995 CLOSE_BRACE416=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format35c_type5186); 12996 stream_CLOSE_BRACE.add(CLOSE_BRACE416); 12997 12998 COMMA417=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format35c_type5188); 12999 stream_COMMA.add(COMMA417); 13000 13001 pushFollow(FOLLOW_nonvoid_type_descriptor_in_insn_format35c_type5190); 13002 nonvoid_type_descriptor418=nonvoid_type_descriptor(); 13003 state._fsp--; 13004 13005 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor418.getTree()); 13006 // AST REWRITE 13007 // elements: register_list, nonvoid_type_descriptor, INSTRUCTION_FORMAT35c_TYPE 13008 // token labels: 13009 // rule labels: retval 13010 // token list labels: 13011 // rule list labels: 13012 // wildcard labels: 13013 retval.tree = root_0; 13014 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 13015 13016 root_0 = (CommonTree)adaptor.nil(); 13017 // 1020:5: -> ^( I_STATEMENT_FORMAT35c_TYPE[$start, \"I_STATEMENT_FORMAT35c_TYPE\"] INSTRUCTION_FORMAT35c_TYPE register_list nonvoid_type_descriptor ) 13018 { 13019 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1020:8: ^( I_STATEMENT_FORMAT35c_TYPE[$start, \"I_STATEMENT_FORMAT35c_TYPE\"] INSTRUCTION_FORMAT35c_TYPE register_list nonvoid_type_descriptor ) 13020 { 13021 CommonTree root_1 = (CommonTree)adaptor.nil(); 13022 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT35c_TYPE, (retval.start), "I_STATEMENT_FORMAT35c_TYPE"), root_1); 13023 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT35c_TYPE.nextNode()); 13024 adaptor.addChild(root_1, stream_register_list.nextTree()); 13025 adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree()); 13026 adaptor.addChild(root_0, root_1); 13027 } 13028 13029 } 13030 13031 13032 retval.tree = root_0; 13033 13034 } 13035 13036 retval.stop = input.LT(-1); 13037 13038 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13039 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13040 13041 } 13042 catch (RecognitionException re) { 13043 reportError(re); 13044 recover(input,re); 13045 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13046 } 13047 finally { 13048 // do for sure before leaving 13049 } 13050 return retval; 13051 } 13052 // $ANTLR end "insn_format35c_type" 13053 13054 13055 public static class insn_format35c_method_odex_return extends ParserRuleReturnScope { 13056 CommonTree tree; 13057 @Override 13058 public CommonTree getTree() { return tree; } 13059 }; 13060 13061 13062 // $ANTLR start "insn_format35c_method_odex" 13063 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1022:1: insn_format35c_method_odex : INSTRUCTION_FORMAT35c_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference ; 13064 public final smaliParser.insn_format35c_method_odex_return insn_format35c_method_odex() throws RecognitionException { 13065 smaliParser.insn_format35c_method_odex_return retval = new smaliParser.insn_format35c_method_odex_return(); 13066 retval.start = input.LT(1); 13067 13068 CommonTree root_0 = null; 13069 13070 Token INSTRUCTION_FORMAT35c_METHOD_ODEX419=null; 13071 Token OPEN_BRACE420=null; 13072 Token CLOSE_BRACE422=null; 13073 Token COMMA423=null; 13074 ParserRuleReturnScope register_list421 =null; 13075 ParserRuleReturnScope method_reference424 =null; 13076 13077 CommonTree INSTRUCTION_FORMAT35c_METHOD_ODEX419_tree=null; 13078 CommonTree OPEN_BRACE420_tree=null; 13079 CommonTree CLOSE_BRACE422_tree=null; 13080 CommonTree COMMA423_tree=null; 13081 13082 try { 13083 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1023:3: ( INSTRUCTION_FORMAT35c_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference ) 13084 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1024:5: INSTRUCTION_FORMAT35c_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference 13085 { 13086 root_0 = (CommonTree)adaptor.nil(); 13087 13088 13089 INSTRUCTION_FORMAT35c_METHOD_ODEX419=(Token)match(input,INSTRUCTION_FORMAT35c_METHOD_ODEX,FOLLOW_INSTRUCTION_FORMAT35c_METHOD_ODEX_in_insn_format35c_method_odex5222); 13090 INSTRUCTION_FORMAT35c_METHOD_ODEX419_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT35c_METHOD_ODEX419); 13091 adaptor.addChild(root_0, INSTRUCTION_FORMAT35c_METHOD_ODEX419_tree); 13092 13093 OPEN_BRACE420=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format35c_method_odex5224); 13094 OPEN_BRACE420_tree = (CommonTree)adaptor.create(OPEN_BRACE420); 13095 adaptor.addChild(root_0, OPEN_BRACE420_tree); 13096 13097 pushFollow(FOLLOW_register_list_in_insn_format35c_method_odex5226); 13098 register_list421=register_list(); 13099 state._fsp--; 13100 13101 adaptor.addChild(root_0, register_list421.getTree()); 13102 13103 CLOSE_BRACE422=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format35c_method_odex5228); 13104 CLOSE_BRACE422_tree = (CommonTree)adaptor.create(CLOSE_BRACE422); 13105 adaptor.addChild(root_0, CLOSE_BRACE422_tree); 13106 13107 COMMA423=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format35c_method_odex5230); 13108 COMMA423_tree = (CommonTree)adaptor.create(COMMA423); 13109 adaptor.addChild(root_0, COMMA423_tree); 13110 13111 pushFollow(FOLLOW_method_reference_in_insn_format35c_method_odex5232); 13112 method_reference424=method_reference(); 13113 state._fsp--; 13114 13115 adaptor.addChild(root_0, method_reference424.getTree()); 13116 13117 13118 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT35c_METHOD_ODEX419!=null?INSTRUCTION_FORMAT35c_METHOD_ODEX419.getText():null)); 13119 13120 } 13121 13122 retval.stop = input.LT(-1); 13123 13124 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13125 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13126 13127 } 13128 catch (RecognitionException re) { 13129 reportError(re); 13130 recover(input,re); 13131 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13132 } 13133 finally { 13134 // do for sure before leaving 13135 } 13136 return retval; 13137 } 13138 // $ANTLR end "insn_format35c_method_odex" 13139 13140 13141 public static class insn_format35mi_method_return extends ParserRuleReturnScope { 13142 CommonTree tree; 13143 @Override 13144 public CommonTree getTree() { return tree; } 13145 }; 13146 13147 13148 // $ANTLR start "insn_format35mi_method" 13149 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1029:1: insn_format35mi_method : INSTRUCTION_FORMAT35mi_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA INLINE_INDEX ; 13150 public final smaliParser.insn_format35mi_method_return insn_format35mi_method() throws RecognitionException { 13151 smaliParser.insn_format35mi_method_return retval = new smaliParser.insn_format35mi_method_return(); 13152 retval.start = input.LT(1); 13153 13154 CommonTree root_0 = null; 13155 13156 Token INSTRUCTION_FORMAT35mi_METHOD425=null; 13157 Token OPEN_BRACE426=null; 13158 Token CLOSE_BRACE428=null; 13159 Token COMMA429=null; 13160 Token INLINE_INDEX430=null; 13161 ParserRuleReturnScope register_list427 =null; 13162 13163 CommonTree INSTRUCTION_FORMAT35mi_METHOD425_tree=null; 13164 CommonTree OPEN_BRACE426_tree=null; 13165 CommonTree CLOSE_BRACE428_tree=null; 13166 CommonTree COMMA429_tree=null; 13167 CommonTree INLINE_INDEX430_tree=null; 13168 13169 try { 13170 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1030:3: ( INSTRUCTION_FORMAT35mi_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA INLINE_INDEX ) 13171 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1031:5: INSTRUCTION_FORMAT35mi_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA INLINE_INDEX 13172 { 13173 root_0 = (CommonTree)adaptor.nil(); 13174 13175 13176 INSTRUCTION_FORMAT35mi_METHOD425=(Token)match(input,INSTRUCTION_FORMAT35mi_METHOD,FOLLOW_INSTRUCTION_FORMAT35mi_METHOD_in_insn_format35mi_method5253); 13177 INSTRUCTION_FORMAT35mi_METHOD425_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT35mi_METHOD425); 13178 adaptor.addChild(root_0, INSTRUCTION_FORMAT35mi_METHOD425_tree); 13179 13180 OPEN_BRACE426=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format35mi_method5255); 13181 OPEN_BRACE426_tree = (CommonTree)adaptor.create(OPEN_BRACE426); 13182 adaptor.addChild(root_0, OPEN_BRACE426_tree); 13183 13184 pushFollow(FOLLOW_register_list_in_insn_format35mi_method5257); 13185 register_list427=register_list(); 13186 state._fsp--; 13187 13188 adaptor.addChild(root_0, register_list427.getTree()); 13189 13190 CLOSE_BRACE428=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format35mi_method5259); 13191 CLOSE_BRACE428_tree = (CommonTree)adaptor.create(CLOSE_BRACE428); 13192 adaptor.addChild(root_0, CLOSE_BRACE428_tree); 13193 13194 COMMA429=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format35mi_method5261); 13195 COMMA429_tree = (CommonTree)adaptor.create(COMMA429); 13196 adaptor.addChild(root_0, COMMA429_tree); 13197 13198 INLINE_INDEX430=(Token)match(input,INLINE_INDEX,FOLLOW_INLINE_INDEX_in_insn_format35mi_method5263); 13199 INLINE_INDEX430_tree = (CommonTree)adaptor.create(INLINE_INDEX430); 13200 adaptor.addChild(root_0, INLINE_INDEX430_tree); 13201 13202 13203 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT35mi_METHOD425!=null?INSTRUCTION_FORMAT35mi_METHOD425.getText():null)); 13204 13205 } 13206 13207 retval.stop = input.LT(-1); 13208 13209 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13210 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13211 13212 } 13213 catch (RecognitionException re) { 13214 reportError(re); 13215 recover(input,re); 13216 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13217 } 13218 finally { 13219 // do for sure before leaving 13220 } 13221 return retval; 13222 } 13223 // $ANTLR end "insn_format35mi_method" 13224 13225 13226 public static class insn_format35ms_method_return extends ParserRuleReturnScope { 13227 CommonTree tree; 13228 @Override 13229 public CommonTree getTree() { return tree; } 13230 }; 13231 13232 13233 // $ANTLR start "insn_format35ms_method" 13234 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1036:1: insn_format35ms_method : INSTRUCTION_FORMAT35ms_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA VTABLE_INDEX ; 13235 public final smaliParser.insn_format35ms_method_return insn_format35ms_method() throws RecognitionException { 13236 smaliParser.insn_format35ms_method_return retval = new smaliParser.insn_format35ms_method_return(); 13237 retval.start = input.LT(1); 13238 13239 CommonTree root_0 = null; 13240 13241 Token INSTRUCTION_FORMAT35ms_METHOD431=null; 13242 Token OPEN_BRACE432=null; 13243 Token CLOSE_BRACE434=null; 13244 Token COMMA435=null; 13245 Token VTABLE_INDEX436=null; 13246 ParserRuleReturnScope register_list433 =null; 13247 13248 CommonTree INSTRUCTION_FORMAT35ms_METHOD431_tree=null; 13249 CommonTree OPEN_BRACE432_tree=null; 13250 CommonTree CLOSE_BRACE434_tree=null; 13251 CommonTree COMMA435_tree=null; 13252 CommonTree VTABLE_INDEX436_tree=null; 13253 13254 try { 13255 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1037:3: ( INSTRUCTION_FORMAT35ms_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA VTABLE_INDEX ) 13256 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1038:5: INSTRUCTION_FORMAT35ms_METHOD OPEN_BRACE register_list CLOSE_BRACE COMMA VTABLE_INDEX 13257 { 13258 root_0 = (CommonTree)adaptor.nil(); 13259 13260 13261 INSTRUCTION_FORMAT35ms_METHOD431=(Token)match(input,INSTRUCTION_FORMAT35ms_METHOD,FOLLOW_INSTRUCTION_FORMAT35ms_METHOD_in_insn_format35ms_method5284); 13262 INSTRUCTION_FORMAT35ms_METHOD431_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT35ms_METHOD431); 13263 adaptor.addChild(root_0, INSTRUCTION_FORMAT35ms_METHOD431_tree); 13264 13265 OPEN_BRACE432=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format35ms_method5286); 13266 OPEN_BRACE432_tree = (CommonTree)adaptor.create(OPEN_BRACE432); 13267 adaptor.addChild(root_0, OPEN_BRACE432_tree); 13268 13269 pushFollow(FOLLOW_register_list_in_insn_format35ms_method5288); 13270 register_list433=register_list(); 13271 state._fsp--; 13272 13273 adaptor.addChild(root_0, register_list433.getTree()); 13274 13275 CLOSE_BRACE434=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format35ms_method5290); 13276 CLOSE_BRACE434_tree = (CommonTree)adaptor.create(CLOSE_BRACE434); 13277 adaptor.addChild(root_0, CLOSE_BRACE434_tree); 13278 13279 COMMA435=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format35ms_method5292); 13280 COMMA435_tree = (CommonTree)adaptor.create(COMMA435); 13281 adaptor.addChild(root_0, COMMA435_tree); 13282 13283 VTABLE_INDEX436=(Token)match(input,VTABLE_INDEX,FOLLOW_VTABLE_INDEX_in_insn_format35ms_method5294); 13284 VTABLE_INDEX436_tree = (CommonTree)adaptor.create(VTABLE_INDEX436); 13285 adaptor.addChild(root_0, VTABLE_INDEX436_tree); 13286 13287 13288 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT35ms_METHOD431!=null?INSTRUCTION_FORMAT35ms_METHOD431.getText():null)); 13289 13290 } 13291 13292 retval.stop = input.LT(-1); 13293 13294 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13295 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13296 13297 } 13298 catch (RecognitionException re) { 13299 reportError(re); 13300 recover(input,re); 13301 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13302 } 13303 finally { 13304 // do for sure before leaving 13305 } 13306 return retval; 13307 } 13308 // $ANTLR end "insn_format35ms_method" 13309 13310 13311 public static class insn_format3rc_method_return extends ParserRuleReturnScope { 13312 CommonTree tree; 13313 @Override 13314 public CommonTree getTree() { return tree; } 13315 }; 13316 13317 13318 // $ANTLR start "insn_format3rc_method" 13319 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1043:1: insn_format3rc_method : INSTRUCTION_FORMAT3rc_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA method_reference -> ^( I_STATEMENT_FORMAT3rc_METHOD[$start, \"I_STATEMENT_FORMAT3rc_METHOD\"] INSTRUCTION_FORMAT3rc_METHOD register_range method_reference ) ; 13320 public final smaliParser.insn_format3rc_method_return insn_format3rc_method() throws RecognitionException { 13321 smaliParser.insn_format3rc_method_return retval = new smaliParser.insn_format3rc_method_return(); 13322 retval.start = input.LT(1); 13323 13324 CommonTree root_0 = null; 13325 13326 Token INSTRUCTION_FORMAT3rc_METHOD437=null; 13327 Token OPEN_BRACE438=null; 13328 Token CLOSE_BRACE440=null; 13329 Token COMMA441=null; 13330 ParserRuleReturnScope register_range439 =null; 13331 ParserRuleReturnScope method_reference442 =null; 13332 13333 CommonTree INSTRUCTION_FORMAT3rc_METHOD437_tree=null; 13334 CommonTree OPEN_BRACE438_tree=null; 13335 CommonTree CLOSE_BRACE440_tree=null; 13336 CommonTree COMMA441_tree=null; 13337 RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE"); 13338 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT3rc_METHOD=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT3rc_METHOD"); 13339 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 13340 RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE"); 13341 RewriteRuleSubtreeStream stream_method_reference=new RewriteRuleSubtreeStream(adaptor,"rule method_reference"); 13342 RewriteRuleSubtreeStream stream_register_range=new RewriteRuleSubtreeStream(adaptor,"rule register_range"); 13343 13344 try { 13345 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1044:3: ( INSTRUCTION_FORMAT3rc_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA method_reference -> ^( I_STATEMENT_FORMAT3rc_METHOD[$start, \"I_STATEMENT_FORMAT3rc_METHOD\"] INSTRUCTION_FORMAT3rc_METHOD register_range method_reference ) ) 13346 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1045:5: INSTRUCTION_FORMAT3rc_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA method_reference 13347 { 13348 INSTRUCTION_FORMAT3rc_METHOD437=(Token)match(input,INSTRUCTION_FORMAT3rc_METHOD,FOLLOW_INSTRUCTION_FORMAT3rc_METHOD_in_insn_format3rc_method5315); 13349 stream_INSTRUCTION_FORMAT3rc_METHOD.add(INSTRUCTION_FORMAT3rc_METHOD437); 13350 13351 OPEN_BRACE438=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format3rc_method5317); 13352 stream_OPEN_BRACE.add(OPEN_BRACE438); 13353 13354 pushFollow(FOLLOW_register_range_in_insn_format3rc_method5319); 13355 register_range439=register_range(); 13356 state._fsp--; 13357 13358 stream_register_range.add(register_range439.getTree()); 13359 CLOSE_BRACE440=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format3rc_method5321); 13360 stream_CLOSE_BRACE.add(CLOSE_BRACE440); 13361 13362 COMMA441=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format3rc_method5323); 13363 stream_COMMA.add(COMMA441); 13364 13365 pushFollow(FOLLOW_method_reference_in_insn_format3rc_method5325); 13366 method_reference442=method_reference(); 13367 state._fsp--; 13368 13369 stream_method_reference.add(method_reference442.getTree()); 13370 // AST REWRITE 13371 // elements: INSTRUCTION_FORMAT3rc_METHOD, method_reference, register_range 13372 // token labels: 13373 // rule labels: retval 13374 // token list labels: 13375 // rule list labels: 13376 // wildcard labels: 13377 retval.tree = root_0; 13378 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 13379 13380 root_0 = (CommonTree)adaptor.nil(); 13381 // 1046:5: -> ^( I_STATEMENT_FORMAT3rc_METHOD[$start, \"I_STATEMENT_FORMAT3rc_METHOD\"] INSTRUCTION_FORMAT3rc_METHOD register_range method_reference ) 13382 { 13383 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1046:8: ^( I_STATEMENT_FORMAT3rc_METHOD[$start, \"I_STATEMENT_FORMAT3rc_METHOD\"] INSTRUCTION_FORMAT3rc_METHOD register_range method_reference ) 13384 { 13385 CommonTree root_1 = (CommonTree)adaptor.nil(); 13386 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT3rc_METHOD, (retval.start), "I_STATEMENT_FORMAT3rc_METHOD"), root_1); 13387 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT3rc_METHOD.nextNode()); 13388 adaptor.addChild(root_1, stream_register_range.nextTree()); 13389 adaptor.addChild(root_1, stream_method_reference.nextTree()); 13390 adaptor.addChild(root_0, root_1); 13391 } 13392 13393 } 13394 13395 13396 retval.tree = root_0; 13397 13398 } 13399 13400 retval.stop = input.LT(-1); 13401 13402 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13403 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13404 13405 } 13406 catch (RecognitionException re) { 13407 reportError(re); 13408 recover(input,re); 13409 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13410 } 13411 finally { 13412 // do for sure before leaving 13413 } 13414 return retval; 13415 } 13416 // $ANTLR end "insn_format3rc_method" 13417 13418 13419 public static class insn_format3rc_method_odex_return extends ParserRuleReturnScope { 13420 CommonTree tree; 13421 @Override 13422 public CommonTree getTree() { return tree; } 13423 }; 13424 13425 13426 // $ANTLR start "insn_format3rc_method_odex" 13427 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1048:1: insn_format3rc_method_odex : INSTRUCTION_FORMAT3rc_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference ; 13428 public final smaliParser.insn_format3rc_method_odex_return insn_format3rc_method_odex() throws RecognitionException { 13429 smaliParser.insn_format3rc_method_odex_return retval = new smaliParser.insn_format3rc_method_odex_return(); 13430 retval.start = input.LT(1); 13431 13432 CommonTree root_0 = null; 13433 13434 Token INSTRUCTION_FORMAT3rc_METHOD_ODEX443=null; 13435 Token OPEN_BRACE444=null; 13436 Token CLOSE_BRACE446=null; 13437 Token COMMA447=null; 13438 ParserRuleReturnScope register_list445 =null; 13439 ParserRuleReturnScope method_reference448 =null; 13440 13441 CommonTree INSTRUCTION_FORMAT3rc_METHOD_ODEX443_tree=null; 13442 CommonTree OPEN_BRACE444_tree=null; 13443 CommonTree CLOSE_BRACE446_tree=null; 13444 CommonTree COMMA447_tree=null; 13445 13446 try { 13447 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1049:3: ( INSTRUCTION_FORMAT3rc_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference ) 13448 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1050:5: INSTRUCTION_FORMAT3rc_METHOD_ODEX OPEN_BRACE register_list CLOSE_BRACE COMMA method_reference 13449 { 13450 root_0 = (CommonTree)adaptor.nil(); 13451 13452 13453 INSTRUCTION_FORMAT3rc_METHOD_ODEX443=(Token)match(input,INSTRUCTION_FORMAT3rc_METHOD_ODEX,FOLLOW_INSTRUCTION_FORMAT3rc_METHOD_ODEX_in_insn_format3rc_method_odex5357); 13454 INSTRUCTION_FORMAT3rc_METHOD_ODEX443_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT3rc_METHOD_ODEX443); 13455 adaptor.addChild(root_0, INSTRUCTION_FORMAT3rc_METHOD_ODEX443_tree); 13456 13457 OPEN_BRACE444=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format3rc_method_odex5359); 13458 OPEN_BRACE444_tree = (CommonTree)adaptor.create(OPEN_BRACE444); 13459 adaptor.addChild(root_0, OPEN_BRACE444_tree); 13460 13461 pushFollow(FOLLOW_register_list_in_insn_format3rc_method_odex5361); 13462 register_list445=register_list(); 13463 state._fsp--; 13464 13465 adaptor.addChild(root_0, register_list445.getTree()); 13466 13467 CLOSE_BRACE446=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format3rc_method_odex5363); 13468 CLOSE_BRACE446_tree = (CommonTree)adaptor.create(CLOSE_BRACE446); 13469 adaptor.addChild(root_0, CLOSE_BRACE446_tree); 13470 13471 COMMA447=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format3rc_method_odex5365); 13472 COMMA447_tree = (CommonTree)adaptor.create(COMMA447); 13473 adaptor.addChild(root_0, COMMA447_tree); 13474 13475 pushFollow(FOLLOW_method_reference_in_insn_format3rc_method_odex5367); 13476 method_reference448=method_reference(); 13477 state._fsp--; 13478 13479 adaptor.addChild(root_0, method_reference448.getTree()); 13480 13481 13482 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT3rc_METHOD_ODEX443!=null?INSTRUCTION_FORMAT3rc_METHOD_ODEX443.getText():null)); 13483 13484 } 13485 13486 retval.stop = input.LT(-1); 13487 13488 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13489 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13490 13491 } 13492 catch (RecognitionException re) { 13493 reportError(re); 13494 recover(input,re); 13495 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13496 } 13497 finally { 13498 // do for sure before leaving 13499 } 13500 return retval; 13501 } 13502 // $ANTLR end "insn_format3rc_method_odex" 13503 13504 13505 public static class insn_format3rc_type_return extends ParserRuleReturnScope { 13506 CommonTree tree; 13507 @Override 13508 public CommonTree getTree() { return tree; } 13509 }; 13510 13511 13512 // $ANTLR start "insn_format3rc_type" 13513 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1055:1: insn_format3rc_type : INSTRUCTION_FORMAT3rc_TYPE OPEN_BRACE register_range CLOSE_BRACE COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT3rc_TYPE[$start, \"I_STATEMENT_FORMAT3rc_TYPE\"] INSTRUCTION_FORMAT3rc_TYPE register_range nonvoid_type_descriptor ) ; 13514 public final smaliParser.insn_format3rc_type_return insn_format3rc_type() throws RecognitionException { 13515 smaliParser.insn_format3rc_type_return retval = new smaliParser.insn_format3rc_type_return(); 13516 retval.start = input.LT(1); 13517 13518 CommonTree root_0 = null; 13519 13520 Token INSTRUCTION_FORMAT3rc_TYPE449=null; 13521 Token OPEN_BRACE450=null; 13522 Token CLOSE_BRACE452=null; 13523 Token COMMA453=null; 13524 ParserRuleReturnScope register_range451 =null; 13525 ParserRuleReturnScope nonvoid_type_descriptor454 =null; 13526 13527 CommonTree INSTRUCTION_FORMAT3rc_TYPE449_tree=null; 13528 CommonTree OPEN_BRACE450_tree=null; 13529 CommonTree CLOSE_BRACE452_tree=null; 13530 CommonTree COMMA453_tree=null; 13531 RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE"); 13532 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT3rc_TYPE=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT3rc_TYPE"); 13533 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 13534 RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE"); 13535 RewriteRuleSubtreeStream stream_nonvoid_type_descriptor=new RewriteRuleSubtreeStream(adaptor,"rule nonvoid_type_descriptor"); 13536 RewriteRuleSubtreeStream stream_register_range=new RewriteRuleSubtreeStream(adaptor,"rule register_range"); 13537 13538 try { 13539 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1056:3: ( INSTRUCTION_FORMAT3rc_TYPE OPEN_BRACE register_range CLOSE_BRACE COMMA nonvoid_type_descriptor -> ^( I_STATEMENT_FORMAT3rc_TYPE[$start, \"I_STATEMENT_FORMAT3rc_TYPE\"] INSTRUCTION_FORMAT3rc_TYPE register_range nonvoid_type_descriptor ) ) 13540 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1057:5: INSTRUCTION_FORMAT3rc_TYPE OPEN_BRACE register_range CLOSE_BRACE COMMA nonvoid_type_descriptor 13541 { 13542 INSTRUCTION_FORMAT3rc_TYPE449=(Token)match(input,INSTRUCTION_FORMAT3rc_TYPE,FOLLOW_INSTRUCTION_FORMAT3rc_TYPE_in_insn_format3rc_type5388); 13543 stream_INSTRUCTION_FORMAT3rc_TYPE.add(INSTRUCTION_FORMAT3rc_TYPE449); 13544 13545 OPEN_BRACE450=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format3rc_type5390); 13546 stream_OPEN_BRACE.add(OPEN_BRACE450); 13547 13548 pushFollow(FOLLOW_register_range_in_insn_format3rc_type5392); 13549 register_range451=register_range(); 13550 state._fsp--; 13551 13552 stream_register_range.add(register_range451.getTree()); 13553 CLOSE_BRACE452=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format3rc_type5394); 13554 stream_CLOSE_BRACE.add(CLOSE_BRACE452); 13555 13556 COMMA453=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format3rc_type5396); 13557 stream_COMMA.add(COMMA453); 13558 13559 pushFollow(FOLLOW_nonvoid_type_descriptor_in_insn_format3rc_type5398); 13560 nonvoid_type_descriptor454=nonvoid_type_descriptor(); 13561 state._fsp--; 13562 13563 stream_nonvoid_type_descriptor.add(nonvoid_type_descriptor454.getTree()); 13564 // AST REWRITE 13565 // elements: nonvoid_type_descriptor, register_range, INSTRUCTION_FORMAT3rc_TYPE 13566 // token labels: 13567 // rule labels: retval 13568 // token list labels: 13569 // rule list labels: 13570 // wildcard labels: 13571 retval.tree = root_0; 13572 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 13573 13574 root_0 = (CommonTree)adaptor.nil(); 13575 // 1058:5: -> ^( I_STATEMENT_FORMAT3rc_TYPE[$start, \"I_STATEMENT_FORMAT3rc_TYPE\"] INSTRUCTION_FORMAT3rc_TYPE register_range nonvoid_type_descriptor ) 13576 { 13577 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1058:8: ^( I_STATEMENT_FORMAT3rc_TYPE[$start, \"I_STATEMENT_FORMAT3rc_TYPE\"] INSTRUCTION_FORMAT3rc_TYPE register_range nonvoid_type_descriptor ) 13578 { 13579 CommonTree root_1 = (CommonTree)adaptor.nil(); 13580 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT3rc_TYPE, (retval.start), "I_STATEMENT_FORMAT3rc_TYPE"), root_1); 13581 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT3rc_TYPE.nextNode()); 13582 adaptor.addChild(root_1, stream_register_range.nextTree()); 13583 adaptor.addChild(root_1, stream_nonvoid_type_descriptor.nextTree()); 13584 adaptor.addChild(root_0, root_1); 13585 } 13586 13587 } 13588 13589 13590 retval.tree = root_0; 13591 13592 } 13593 13594 retval.stop = input.LT(-1); 13595 13596 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13597 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13598 13599 } 13600 catch (RecognitionException re) { 13601 reportError(re); 13602 recover(input,re); 13603 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13604 } 13605 finally { 13606 // do for sure before leaving 13607 } 13608 return retval; 13609 } 13610 // $ANTLR end "insn_format3rc_type" 13611 13612 13613 public static class insn_format3rmi_method_return extends ParserRuleReturnScope { 13614 CommonTree tree; 13615 @Override 13616 public CommonTree getTree() { return tree; } 13617 }; 13618 13619 13620 // $ANTLR start "insn_format3rmi_method" 13621 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1060:1: insn_format3rmi_method : INSTRUCTION_FORMAT3rmi_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA INLINE_INDEX ; 13622 public final smaliParser.insn_format3rmi_method_return insn_format3rmi_method() throws RecognitionException { 13623 smaliParser.insn_format3rmi_method_return retval = new smaliParser.insn_format3rmi_method_return(); 13624 retval.start = input.LT(1); 13625 13626 CommonTree root_0 = null; 13627 13628 Token INSTRUCTION_FORMAT3rmi_METHOD455=null; 13629 Token OPEN_BRACE456=null; 13630 Token CLOSE_BRACE458=null; 13631 Token COMMA459=null; 13632 Token INLINE_INDEX460=null; 13633 ParserRuleReturnScope register_range457 =null; 13634 13635 CommonTree INSTRUCTION_FORMAT3rmi_METHOD455_tree=null; 13636 CommonTree OPEN_BRACE456_tree=null; 13637 CommonTree CLOSE_BRACE458_tree=null; 13638 CommonTree COMMA459_tree=null; 13639 CommonTree INLINE_INDEX460_tree=null; 13640 13641 try { 13642 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1061:3: ( INSTRUCTION_FORMAT3rmi_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA INLINE_INDEX ) 13643 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1062:5: INSTRUCTION_FORMAT3rmi_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA INLINE_INDEX 13644 { 13645 root_0 = (CommonTree)adaptor.nil(); 13646 13647 13648 INSTRUCTION_FORMAT3rmi_METHOD455=(Token)match(input,INSTRUCTION_FORMAT3rmi_METHOD,FOLLOW_INSTRUCTION_FORMAT3rmi_METHOD_in_insn_format3rmi_method5430); 13649 INSTRUCTION_FORMAT3rmi_METHOD455_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT3rmi_METHOD455); 13650 adaptor.addChild(root_0, INSTRUCTION_FORMAT3rmi_METHOD455_tree); 13651 13652 OPEN_BRACE456=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format3rmi_method5432); 13653 OPEN_BRACE456_tree = (CommonTree)adaptor.create(OPEN_BRACE456); 13654 adaptor.addChild(root_0, OPEN_BRACE456_tree); 13655 13656 pushFollow(FOLLOW_register_range_in_insn_format3rmi_method5434); 13657 register_range457=register_range(); 13658 state._fsp--; 13659 13660 adaptor.addChild(root_0, register_range457.getTree()); 13661 13662 CLOSE_BRACE458=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format3rmi_method5436); 13663 CLOSE_BRACE458_tree = (CommonTree)adaptor.create(CLOSE_BRACE458); 13664 adaptor.addChild(root_0, CLOSE_BRACE458_tree); 13665 13666 COMMA459=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format3rmi_method5438); 13667 COMMA459_tree = (CommonTree)adaptor.create(COMMA459); 13668 adaptor.addChild(root_0, COMMA459_tree); 13669 13670 INLINE_INDEX460=(Token)match(input,INLINE_INDEX,FOLLOW_INLINE_INDEX_in_insn_format3rmi_method5440); 13671 INLINE_INDEX460_tree = (CommonTree)adaptor.create(INLINE_INDEX460); 13672 adaptor.addChild(root_0, INLINE_INDEX460_tree); 13673 13674 13675 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT3rmi_METHOD455!=null?INSTRUCTION_FORMAT3rmi_METHOD455.getText():null)); 13676 13677 } 13678 13679 retval.stop = input.LT(-1); 13680 13681 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13682 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13683 13684 } 13685 catch (RecognitionException re) { 13686 reportError(re); 13687 recover(input,re); 13688 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13689 } 13690 finally { 13691 // do for sure before leaving 13692 } 13693 return retval; 13694 } 13695 // $ANTLR end "insn_format3rmi_method" 13696 13697 13698 public static class insn_format3rms_method_return extends ParserRuleReturnScope { 13699 CommonTree tree; 13700 @Override 13701 public CommonTree getTree() { return tree; } 13702 }; 13703 13704 13705 // $ANTLR start "insn_format3rms_method" 13706 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1067:1: insn_format3rms_method : INSTRUCTION_FORMAT3rms_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA VTABLE_INDEX ; 13707 public final smaliParser.insn_format3rms_method_return insn_format3rms_method() throws RecognitionException { 13708 smaliParser.insn_format3rms_method_return retval = new smaliParser.insn_format3rms_method_return(); 13709 retval.start = input.LT(1); 13710 13711 CommonTree root_0 = null; 13712 13713 Token INSTRUCTION_FORMAT3rms_METHOD461=null; 13714 Token OPEN_BRACE462=null; 13715 Token CLOSE_BRACE464=null; 13716 Token COMMA465=null; 13717 Token VTABLE_INDEX466=null; 13718 ParserRuleReturnScope register_range463 =null; 13719 13720 CommonTree INSTRUCTION_FORMAT3rms_METHOD461_tree=null; 13721 CommonTree OPEN_BRACE462_tree=null; 13722 CommonTree CLOSE_BRACE464_tree=null; 13723 CommonTree COMMA465_tree=null; 13724 CommonTree VTABLE_INDEX466_tree=null; 13725 13726 try { 13727 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1068:3: ( INSTRUCTION_FORMAT3rms_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA VTABLE_INDEX ) 13728 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1069:5: INSTRUCTION_FORMAT3rms_METHOD OPEN_BRACE register_range CLOSE_BRACE COMMA VTABLE_INDEX 13729 { 13730 root_0 = (CommonTree)adaptor.nil(); 13731 13732 13733 INSTRUCTION_FORMAT3rms_METHOD461=(Token)match(input,INSTRUCTION_FORMAT3rms_METHOD,FOLLOW_INSTRUCTION_FORMAT3rms_METHOD_in_insn_format3rms_method5461); 13734 INSTRUCTION_FORMAT3rms_METHOD461_tree = (CommonTree)adaptor.create(INSTRUCTION_FORMAT3rms_METHOD461); 13735 adaptor.addChild(root_0, INSTRUCTION_FORMAT3rms_METHOD461_tree); 13736 13737 OPEN_BRACE462=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_insn_format3rms_method5463); 13738 OPEN_BRACE462_tree = (CommonTree)adaptor.create(OPEN_BRACE462); 13739 adaptor.addChild(root_0, OPEN_BRACE462_tree); 13740 13741 pushFollow(FOLLOW_register_range_in_insn_format3rms_method5465); 13742 register_range463=register_range(); 13743 state._fsp--; 13744 13745 adaptor.addChild(root_0, register_range463.getTree()); 13746 13747 CLOSE_BRACE464=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_insn_format3rms_method5467); 13748 CLOSE_BRACE464_tree = (CommonTree)adaptor.create(CLOSE_BRACE464); 13749 adaptor.addChild(root_0, CLOSE_BRACE464_tree); 13750 13751 COMMA465=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format3rms_method5469); 13752 COMMA465_tree = (CommonTree)adaptor.create(COMMA465); 13753 adaptor.addChild(root_0, COMMA465_tree); 13754 13755 VTABLE_INDEX466=(Token)match(input,VTABLE_INDEX,FOLLOW_VTABLE_INDEX_in_insn_format3rms_method5471); 13756 VTABLE_INDEX466_tree = (CommonTree)adaptor.create(VTABLE_INDEX466); 13757 adaptor.addChild(root_0, VTABLE_INDEX466_tree); 13758 13759 13760 throwOdexedInstructionException(input, (INSTRUCTION_FORMAT3rms_METHOD461!=null?INSTRUCTION_FORMAT3rms_METHOD461.getText():null)); 13761 13762 } 13763 13764 retval.stop = input.LT(-1); 13765 13766 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13767 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13768 13769 } 13770 catch (RecognitionException re) { 13771 reportError(re); 13772 recover(input,re); 13773 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13774 } 13775 finally { 13776 // do for sure before leaving 13777 } 13778 return retval; 13779 } 13780 // $ANTLR end "insn_format3rms_method" 13781 13782 13783 public static class insn_format51l_return extends ParserRuleReturnScope { 13784 CommonTree tree; 13785 @Override 13786 public CommonTree getTree() { return tree; } 13787 }; 13788 13789 13790 // $ANTLR start "insn_format51l" 13791 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1074:1: insn_format51l : INSTRUCTION_FORMAT51l REGISTER COMMA fixed_literal -> ^( I_STATEMENT_FORMAT51l[$start, \"I_STATEMENT_FORMAT51l\"] INSTRUCTION_FORMAT51l REGISTER fixed_literal ) ; 13792 public final smaliParser.insn_format51l_return insn_format51l() throws RecognitionException { 13793 smaliParser.insn_format51l_return retval = new smaliParser.insn_format51l_return(); 13794 retval.start = input.LT(1); 13795 13796 CommonTree root_0 = null; 13797 13798 Token INSTRUCTION_FORMAT51l467=null; 13799 Token REGISTER468=null; 13800 Token COMMA469=null; 13801 ParserRuleReturnScope fixed_literal470 =null; 13802 13803 CommonTree INSTRUCTION_FORMAT51l467_tree=null; 13804 CommonTree REGISTER468_tree=null; 13805 CommonTree COMMA469_tree=null; 13806 RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA"); 13807 RewriteRuleTokenStream stream_REGISTER=new RewriteRuleTokenStream(adaptor,"token REGISTER"); 13808 RewriteRuleTokenStream stream_INSTRUCTION_FORMAT51l=new RewriteRuleTokenStream(adaptor,"token INSTRUCTION_FORMAT51l"); 13809 RewriteRuleSubtreeStream stream_fixed_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_literal"); 13810 13811 try { 13812 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1075:3: ( INSTRUCTION_FORMAT51l REGISTER COMMA fixed_literal -> ^( I_STATEMENT_FORMAT51l[$start, \"I_STATEMENT_FORMAT51l\"] INSTRUCTION_FORMAT51l REGISTER fixed_literal ) ) 13813 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1076:5: INSTRUCTION_FORMAT51l REGISTER COMMA fixed_literal 13814 { 13815 INSTRUCTION_FORMAT51l467=(Token)match(input,INSTRUCTION_FORMAT51l,FOLLOW_INSTRUCTION_FORMAT51l_in_insn_format51l5492); 13816 stream_INSTRUCTION_FORMAT51l.add(INSTRUCTION_FORMAT51l467); 13817 13818 REGISTER468=(Token)match(input,REGISTER,FOLLOW_REGISTER_in_insn_format51l5494); 13819 stream_REGISTER.add(REGISTER468); 13820 13821 COMMA469=(Token)match(input,COMMA,FOLLOW_COMMA_in_insn_format51l5496); 13822 stream_COMMA.add(COMMA469); 13823 13824 pushFollow(FOLLOW_fixed_literal_in_insn_format51l5498); 13825 fixed_literal470=fixed_literal(); 13826 state._fsp--; 13827 13828 stream_fixed_literal.add(fixed_literal470.getTree()); 13829 // AST REWRITE 13830 // elements: REGISTER, fixed_literal, INSTRUCTION_FORMAT51l 13831 // token labels: 13832 // rule labels: retval 13833 // token list labels: 13834 // rule list labels: 13835 // wildcard labels: 13836 retval.tree = root_0; 13837 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 13838 13839 root_0 = (CommonTree)adaptor.nil(); 13840 // 1077:5: -> ^( I_STATEMENT_FORMAT51l[$start, \"I_STATEMENT_FORMAT51l\"] INSTRUCTION_FORMAT51l REGISTER fixed_literal ) 13841 { 13842 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1077:8: ^( I_STATEMENT_FORMAT51l[$start, \"I_STATEMENT_FORMAT51l\"] INSTRUCTION_FORMAT51l REGISTER fixed_literal ) 13843 { 13844 CommonTree root_1 = (CommonTree)adaptor.nil(); 13845 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_FORMAT51l, (retval.start), "I_STATEMENT_FORMAT51l"), root_1); 13846 adaptor.addChild(root_1, stream_INSTRUCTION_FORMAT51l.nextNode()); 13847 adaptor.addChild(root_1, stream_REGISTER.nextNode()); 13848 adaptor.addChild(root_1, stream_fixed_literal.nextTree()); 13849 adaptor.addChild(root_0, root_1); 13850 } 13851 13852 } 13853 13854 13855 retval.tree = root_0; 13856 13857 } 13858 13859 retval.stop = input.LT(-1); 13860 13861 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 13862 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 13863 13864 } 13865 catch (RecognitionException re) { 13866 reportError(re); 13867 recover(input,re); 13868 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 13869 } 13870 finally { 13871 // do for sure before leaving 13872 } 13873 return retval; 13874 } 13875 // $ANTLR end "insn_format51l" 13876 13877 13878 public static class insn_array_data_directive_return extends ParserRuleReturnScope { 13879 CommonTree tree; 13880 @Override 13881 public CommonTree getTree() { return tree; } 13882 }; 13883 13884 13885 // $ANTLR start "insn_array_data_directive" 13886 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1079:1: insn_array_data_directive : ARRAY_DATA_DIRECTIVE parsed_integer_literal ( fixed_literal )* END_ARRAY_DATA_DIRECTIVE -> ^( I_STATEMENT_ARRAY_DATA[$start, \"I_STATEMENT_ARRAY_DATA\"] ^( I_ARRAY_ELEMENT_SIZE parsed_integer_literal ) ^( I_ARRAY_ELEMENTS ( fixed_literal )* ) ) ; 13887 public final smaliParser.insn_array_data_directive_return insn_array_data_directive() throws RecognitionException { 13888 smaliParser.insn_array_data_directive_return retval = new smaliParser.insn_array_data_directive_return(); 13889 retval.start = input.LT(1); 13890 13891 CommonTree root_0 = null; 13892 13893 Token ARRAY_DATA_DIRECTIVE471=null; 13894 Token END_ARRAY_DATA_DIRECTIVE474=null; 13895 ParserRuleReturnScope parsed_integer_literal472 =null; 13896 ParserRuleReturnScope fixed_literal473 =null; 13897 13898 CommonTree ARRAY_DATA_DIRECTIVE471_tree=null; 13899 CommonTree END_ARRAY_DATA_DIRECTIVE474_tree=null; 13900 RewriteRuleTokenStream stream_ARRAY_DATA_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token ARRAY_DATA_DIRECTIVE"); 13901 RewriteRuleTokenStream stream_END_ARRAY_DATA_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_ARRAY_DATA_DIRECTIVE"); 13902 RewriteRuleSubtreeStream stream_fixed_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_literal"); 13903 RewriteRuleSubtreeStream stream_parsed_integer_literal=new RewriteRuleSubtreeStream(adaptor,"rule parsed_integer_literal"); 13904 13905 try { 13906 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1080:3: ( ARRAY_DATA_DIRECTIVE parsed_integer_literal ( fixed_literal )* END_ARRAY_DATA_DIRECTIVE -> ^( I_STATEMENT_ARRAY_DATA[$start, \"I_STATEMENT_ARRAY_DATA\"] ^( I_ARRAY_ELEMENT_SIZE parsed_integer_literal ) ^( I_ARRAY_ELEMENTS ( fixed_literal )* ) ) ) 13907 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1080:5: ARRAY_DATA_DIRECTIVE parsed_integer_literal ( fixed_literal )* END_ARRAY_DATA_DIRECTIVE 13908 { 13909 ARRAY_DATA_DIRECTIVE471=(Token)match(input,ARRAY_DATA_DIRECTIVE,FOLLOW_ARRAY_DATA_DIRECTIVE_in_insn_array_data_directive5525); 13910 stream_ARRAY_DATA_DIRECTIVE.add(ARRAY_DATA_DIRECTIVE471); 13911 13912 pushFollow(FOLLOW_parsed_integer_literal_in_insn_array_data_directive5531); 13913 parsed_integer_literal472=parsed_integer_literal(); 13914 state._fsp--; 13915 13916 stream_parsed_integer_literal.add(parsed_integer_literal472.getTree()); 13917 13918 int elementWidth = (parsed_integer_literal472!=null?((smaliParser.parsed_integer_literal_return)parsed_integer_literal472).value:0); 13919 if (elementWidth != 4 && elementWidth != 8 && elementWidth != 1 && elementWidth != 2) { 13920 throw new SemanticException(input, (retval.start), "Invalid element width: %d. Must be 1, 2, 4 or 8", elementWidth); 13921 } 13922 13923 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1088:5: ( fixed_literal )* 13924 loop50: 13925 while (true) { 13926 int alt50=2; 13927 int LA50_0 = input.LA(1); 13928 if ( ((LA50_0 >= BOOL_LITERAL && LA50_0 <= BYTE_LITERAL)||LA50_0==CHAR_LITERAL||(LA50_0 >= DOUBLE_LITERAL && LA50_0 <= DOUBLE_LITERAL_OR_ID)||(LA50_0 >= FLOAT_LITERAL && LA50_0 <= FLOAT_LITERAL_OR_ID)||LA50_0==LONG_LITERAL||LA50_0==NEGATIVE_INTEGER_LITERAL||LA50_0==POSITIVE_INTEGER_LITERAL||LA50_0==SHORT_LITERAL) ) { 13929 alt50=1; 13930 } 13931 13932 switch (alt50) { 13933 case 1 : 13934 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1088:5: fixed_literal 13935 { 13936 pushFollow(FOLLOW_fixed_literal_in_insn_array_data_directive5543); 13937 fixed_literal473=fixed_literal(); 13938 state._fsp--; 13939 13940 stream_fixed_literal.add(fixed_literal473.getTree()); 13941 } 13942 break; 13943 13944 default : 13945 break loop50; 13946 } 13947 } 13948 13949 END_ARRAY_DATA_DIRECTIVE474=(Token)match(input,END_ARRAY_DATA_DIRECTIVE,FOLLOW_END_ARRAY_DATA_DIRECTIVE_in_insn_array_data_directive5546); 13950 stream_END_ARRAY_DATA_DIRECTIVE.add(END_ARRAY_DATA_DIRECTIVE474); 13951 13952 // AST REWRITE 13953 // elements: fixed_literal, parsed_integer_literal 13954 // token labels: 13955 // rule labels: retval 13956 // token list labels: 13957 // rule list labels: 13958 // wildcard labels: 13959 retval.tree = root_0; 13960 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 13961 13962 root_0 = (CommonTree)adaptor.nil(); 13963 // 1090:5: -> ^( I_STATEMENT_ARRAY_DATA[$start, \"I_STATEMENT_ARRAY_DATA\"] ^( I_ARRAY_ELEMENT_SIZE parsed_integer_literal ) ^( I_ARRAY_ELEMENTS ( fixed_literal )* ) ) 13964 { 13965 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1090:8: ^( I_STATEMENT_ARRAY_DATA[$start, \"I_STATEMENT_ARRAY_DATA\"] ^( I_ARRAY_ELEMENT_SIZE parsed_integer_literal ) ^( I_ARRAY_ELEMENTS ( fixed_literal )* ) ) 13966 { 13967 CommonTree root_1 = (CommonTree)adaptor.nil(); 13968 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_ARRAY_DATA, (retval.start), "I_STATEMENT_ARRAY_DATA"), root_1); 13969 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1090:67: ^( I_ARRAY_ELEMENT_SIZE parsed_integer_literal ) 13970 { 13971 CommonTree root_2 = (CommonTree)adaptor.nil(); 13972 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ARRAY_ELEMENT_SIZE, "I_ARRAY_ELEMENT_SIZE"), root_2); 13973 adaptor.addChild(root_2, stream_parsed_integer_literal.nextTree()); 13974 adaptor.addChild(root_1, root_2); 13975 } 13976 13977 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1091:8: ^( I_ARRAY_ELEMENTS ( fixed_literal )* ) 13978 { 13979 CommonTree root_2 = (CommonTree)adaptor.nil(); 13980 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_ARRAY_ELEMENTS, "I_ARRAY_ELEMENTS"), root_2); 13981 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1091:27: ( fixed_literal )* 13982 while ( stream_fixed_literal.hasNext() ) { 13983 adaptor.addChild(root_2, stream_fixed_literal.nextTree()); 13984 } 13985 stream_fixed_literal.reset(); 13986 13987 adaptor.addChild(root_1, root_2); 13988 } 13989 13990 adaptor.addChild(root_0, root_1); 13991 } 13992 13993 } 13994 13995 13996 retval.tree = root_0; 13997 13998 } 13999 14000 retval.stop = input.LT(-1); 14001 14002 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 14003 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 14004 14005 } 14006 catch (RecognitionException re) { 14007 reportError(re); 14008 recover(input,re); 14009 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 14010 } 14011 finally { 14012 // do for sure before leaving 14013 } 14014 return retval; 14015 } 14016 // $ANTLR end "insn_array_data_directive" 14017 14018 14019 public static class insn_packed_switch_directive_return extends ParserRuleReturnScope { 14020 CommonTree tree; 14021 @Override 14022 public CommonTree getTree() { return tree; } 14023 }; 14024 14025 14026 // $ANTLR start "insn_packed_switch_directive" 14027 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1093:1: insn_packed_switch_directive : PACKED_SWITCH_DIRECTIVE fixed_32bit_literal ( label_ref )* END_PACKED_SWITCH_DIRECTIVE -> ^( I_STATEMENT_PACKED_SWITCH[$start, \"I_STATEMENT_PACKED_SWITCH\"] ^( I_PACKED_SWITCH_START_KEY[$start, \"I_PACKED_SWITCH_START_KEY\"] fixed_32bit_literal ) ^( I_PACKED_SWITCH_ELEMENTS[$start, \"I_PACKED_SWITCH_ELEMENTS\"] ( label_ref )* ) ) ; 14028 public final smaliParser.insn_packed_switch_directive_return insn_packed_switch_directive() throws RecognitionException { 14029 smaliParser.insn_packed_switch_directive_return retval = new smaliParser.insn_packed_switch_directive_return(); 14030 retval.start = input.LT(1); 14031 14032 CommonTree root_0 = null; 14033 14034 Token PACKED_SWITCH_DIRECTIVE475=null; 14035 Token END_PACKED_SWITCH_DIRECTIVE478=null; 14036 ParserRuleReturnScope fixed_32bit_literal476 =null; 14037 ParserRuleReturnScope label_ref477 =null; 14038 14039 CommonTree PACKED_SWITCH_DIRECTIVE475_tree=null; 14040 CommonTree END_PACKED_SWITCH_DIRECTIVE478_tree=null; 14041 RewriteRuleTokenStream stream_PACKED_SWITCH_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token PACKED_SWITCH_DIRECTIVE"); 14042 RewriteRuleTokenStream stream_END_PACKED_SWITCH_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_PACKED_SWITCH_DIRECTIVE"); 14043 RewriteRuleSubtreeStream stream_fixed_32bit_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_32bit_literal"); 14044 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 14045 14046 try { 14047 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1094:5: ( PACKED_SWITCH_DIRECTIVE fixed_32bit_literal ( label_ref )* END_PACKED_SWITCH_DIRECTIVE -> ^( I_STATEMENT_PACKED_SWITCH[$start, \"I_STATEMENT_PACKED_SWITCH\"] ^( I_PACKED_SWITCH_START_KEY[$start, \"I_PACKED_SWITCH_START_KEY\"] fixed_32bit_literal ) ^( I_PACKED_SWITCH_ELEMENTS[$start, \"I_PACKED_SWITCH_ELEMENTS\"] ( label_ref )* ) ) ) 14048 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1094:9: PACKED_SWITCH_DIRECTIVE fixed_32bit_literal ( label_ref )* END_PACKED_SWITCH_DIRECTIVE 14049 { 14050 PACKED_SWITCH_DIRECTIVE475=(Token)match(input,PACKED_SWITCH_DIRECTIVE,FOLLOW_PACKED_SWITCH_DIRECTIVE_in_insn_packed_switch_directive5592); 14051 stream_PACKED_SWITCH_DIRECTIVE.add(PACKED_SWITCH_DIRECTIVE475); 14052 14053 pushFollow(FOLLOW_fixed_32bit_literal_in_insn_packed_switch_directive5598); 14054 fixed_32bit_literal476=fixed_32bit_literal(); 14055 state._fsp--; 14056 14057 stream_fixed_32bit_literal.add(fixed_32bit_literal476.getTree()); 14058 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1096:5: ( label_ref )* 14059 loop51: 14060 while (true) { 14061 int alt51=2; 14062 int LA51_0 = input.LA(1); 14063 if ( (LA51_0==COLON) ) { 14064 alt51=1; 14065 } 14066 14067 switch (alt51) { 14068 case 1 : 14069 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1096:5: label_ref 14070 { 14071 pushFollow(FOLLOW_label_ref_in_insn_packed_switch_directive5604); 14072 label_ref477=label_ref(); 14073 state._fsp--; 14074 14075 stream_label_ref.add(label_ref477.getTree()); 14076 } 14077 break; 14078 14079 default : 14080 break loop51; 14081 } 14082 } 14083 14084 END_PACKED_SWITCH_DIRECTIVE478=(Token)match(input,END_PACKED_SWITCH_DIRECTIVE,FOLLOW_END_PACKED_SWITCH_DIRECTIVE_in_insn_packed_switch_directive5611); 14085 stream_END_PACKED_SWITCH_DIRECTIVE.add(END_PACKED_SWITCH_DIRECTIVE478); 14086 14087 // AST REWRITE 14088 // elements: fixed_32bit_literal, label_ref 14089 // token labels: 14090 // rule labels: retval 14091 // token list labels: 14092 // rule list labels: 14093 // wildcard labels: 14094 retval.tree = root_0; 14095 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 14096 14097 root_0 = (CommonTree)adaptor.nil(); 14098 // 1098:5: -> ^( I_STATEMENT_PACKED_SWITCH[$start, \"I_STATEMENT_PACKED_SWITCH\"] ^( I_PACKED_SWITCH_START_KEY[$start, \"I_PACKED_SWITCH_START_KEY\"] fixed_32bit_literal ) ^( I_PACKED_SWITCH_ELEMENTS[$start, \"I_PACKED_SWITCH_ELEMENTS\"] ( label_ref )* ) ) 14099 { 14100 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1098:8: ^( I_STATEMENT_PACKED_SWITCH[$start, \"I_STATEMENT_PACKED_SWITCH\"] ^( I_PACKED_SWITCH_START_KEY[$start, \"I_PACKED_SWITCH_START_KEY\"] fixed_32bit_literal ) ^( I_PACKED_SWITCH_ELEMENTS[$start, \"I_PACKED_SWITCH_ELEMENTS\"] ( label_ref )* ) ) 14101 { 14102 CommonTree root_1 = (CommonTree)adaptor.nil(); 14103 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_PACKED_SWITCH, (retval.start), "I_STATEMENT_PACKED_SWITCH"), root_1); 14104 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1099:10: ^( I_PACKED_SWITCH_START_KEY[$start, \"I_PACKED_SWITCH_START_KEY\"] fixed_32bit_literal ) 14105 { 14106 CommonTree root_2 = (CommonTree)adaptor.nil(); 14107 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_PACKED_SWITCH_START_KEY, (retval.start), "I_PACKED_SWITCH_START_KEY"), root_2); 14108 adaptor.addChild(root_2, stream_fixed_32bit_literal.nextTree()); 14109 adaptor.addChild(root_1, root_2); 14110 } 14111 14112 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1100:10: ^( I_PACKED_SWITCH_ELEMENTS[$start, \"I_PACKED_SWITCH_ELEMENTS\"] ( label_ref )* ) 14113 { 14114 CommonTree root_2 = (CommonTree)adaptor.nil(); 14115 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_PACKED_SWITCH_ELEMENTS, (retval.start), "I_PACKED_SWITCH_ELEMENTS"), root_2); 14116 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1101:11: ( label_ref )* 14117 while ( stream_label_ref.hasNext() ) { 14118 adaptor.addChild(root_2, stream_label_ref.nextTree()); 14119 } 14120 stream_label_ref.reset(); 14121 14122 adaptor.addChild(root_1, root_2); 14123 } 14124 14125 adaptor.addChild(root_0, root_1); 14126 } 14127 14128 } 14129 14130 14131 retval.tree = root_0; 14132 14133 } 14134 14135 retval.stop = input.LT(-1); 14136 14137 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 14138 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 14139 14140 } 14141 catch (RecognitionException re) { 14142 reportError(re); 14143 recover(input,re); 14144 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 14145 } 14146 finally { 14147 // do for sure before leaving 14148 } 14149 return retval; 14150 } 14151 // $ANTLR end "insn_packed_switch_directive" 14152 14153 14154 public static class insn_sparse_switch_directive_return extends ParserRuleReturnScope { 14155 CommonTree tree; 14156 @Override 14157 public CommonTree getTree() { return tree; } 14158 }; 14159 14160 14161 // $ANTLR start "insn_sparse_switch_directive" 14162 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1104:1: insn_sparse_switch_directive : SPARSE_SWITCH_DIRECTIVE ( fixed_32bit_literal ARROW label_ref )* END_SPARSE_SWITCH_DIRECTIVE -> ^( I_STATEMENT_SPARSE_SWITCH[$start, \"I_STATEMENT_SPARSE_SWITCH\"] ^( I_SPARSE_SWITCH_ELEMENTS[$start, \"I_SPARSE_SWITCH_ELEMENTS\"] ( fixed_32bit_literal label_ref )* ) ) ; 14163 public final smaliParser.insn_sparse_switch_directive_return insn_sparse_switch_directive() throws RecognitionException { 14164 smaliParser.insn_sparse_switch_directive_return retval = new smaliParser.insn_sparse_switch_directive_return(); 14165 retval.start = input.LT(1); 14166 14167 CommonTree root_0 = null; 14168 14169 Token SPARSE_SWITCH_DIRECTIVE479=null; 14170 Token ARROW481=null; 14171 Token END_SPARSE_SWITCH_DIRECTIVE483=null; 14172 ParserRuleReturnScope fixed_32bit_literal480 =null; 14173 ParserRuleReturnScope label_ref482 =null; 14174 14175 CommonTree SPARSE_SWITCH_DIRECTIVE479_tree=null; 14176 CommonTree ARROW481_tree=null; 14177 CommonTree END_SPARSE_SWITCH_DIRECTIVE483_tree=null; 14178 RewriteRuleTokenStream stream_SPARSE_SWITCH_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token SPARSE_SWITCH_DIRECTIVE"); 14179 RewriteRuleTokenStream stream_ARROW=new RewriteRuleTokenStream(adaptor,"token ARROW"); 14180 RewriteRuleTokenStream stream_END_SPARSE_SWITCH_DIRECTIVE=new RewriteRuleTokenStream(adaptor,"token END_SPARSE_SWITCH_DIRECTIVE"); 14181 RewriteRuleSubtreeStream stream_fixed_32bit_literal=new RewriteRuleSubtreeStream(adaptor,"rule fixed_32bit_literal"); 14182 RewriteRuleSubtreeStream stream_label_ref=new RewriteRuleSubtreeStream(adaptor,"rule label_ref"); 14183 14184 try { 14185 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1105:3: ( SPARSE_SWITCH_DIRECTIVE ( fixed_32bit_literal ARROW label_ref )* END_SPARSE_SWITCH_DIRECTIVE -> ^( I_STATEMENT_SPARSE_SWITCH[$start, \"I_STATEMENT_SPARSE_SWITCH\"] ^( I_SPARSE_SWITCH_ELEMENTS[$start, \"I_SPARSE_SWITCH_ELEMENTS\"] ( fixed_32bit_literal label_ref )* ) ) ) 14186 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1105:7: SPARSE_SWITCH_DIRECTIVE ( fixed_32bit_literal ARROW label_ref )* END_SPARSE_SWITCH_DIRECTIVE 14187 { 14188 SPARSE_SWITCH_DIRECTIVE479=(Token)match(input,SPARSE_SWITCH_DIRECTIVE,FOLLOW_SPARSE_SWITCH_DIRECTIVE_in_insn_sparse_switch_directive5685); 14189 stream_SPARSE_SWITCH_DIRECTIVE.add(SPARSE_SWITCH_DIRECTIVE479); 14190 14191 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1106:5: ( fixed_32bit_literal ARROW label_ref )* 14192 loop52: 14193 while (true) { 14194 int alt52=2; 14195 int LA52_0 = input.LA(1); 14196 if ( ((LA52_0 >= BOOL_LITERAL && LA52_0 <= BYTE_LITERAL)||LA52_0==CHAR_LITERAL||(LA52_0 >= FLOAT_LITERAL && LA52_0 <= FLOAT_LITERAL_OR_ID)||LA52_0==LONG_LITERAL||LA52_0==NEGATIVE_INTEGER_LITERAL||LA52_0==POSITIVE_INTEGER_LITERAL||LA52_0==SHORT_LITERAL) ) { 14197 alt52=1; 14198 } 14199 14200 switch (alt52) { 14201 case 1 : 14202 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1106:6: fixed_32bit_literal ARROW label_ref 14203 { 14204 pushFollow(FOLLOW_fixed_32bit_literal_in_insn_sparse_switch_directive5692); 14205 fixed_32bit_literal480=fixed_32bit_literal(); 14206 state._fsp--; 14207 14208 stream_fixed_32bit_literal.add(fixed_32bit_literal480.getTree()); 14209 ARROW481=(Token)match(input,ARROW,FOLLOW_ARROW_in_insn_sparse_switch_directive5694); 14210 stream_ARROW.add(ARROW481); 14211 14212 pushFollow(FOLLOW_label_ref_in_insn_sparse_switch_directive5696); 14213 label_ref482=label_ref(); 14214 state._fsp--; 14215 14216 stream_label_ref.add(label_ref482.getTree()); 14217 } 14218 break; 14219 14220 default : 14221 break loop52; 14222 } 14223 } 14224 14225 END_SPARSE_SWITCH_DIRECTIVE483=(Token)match(input,END_SPARSE_SWITCH_DIRECTIVE,FOLLOW_END_SPARSE_SWITCH_DIRECTIVE_in_insn_sparse_switch_directive5704); 14226 stream_END_SPARSE_SWITCH_DIRECTIVE.add(END_SPARSE_SWITCH_DIRECTIVE483); 14227 14228 // AST REWRITE 14229 // elements: label_ref, fixed_32bit_literal 14230 // token labels: 14231 // rule labels: retval 14232 // token list labels: 14233 // rule list labels: 14234 // wildcard labels: 14235 retval.tree = root_0; 14236 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); 14237 14238 root_0 = (CommonTree)adaptor.nil(); 14239 // 1108:5: -> ^( I_STATEMENT_SPARSE_SWITCH[$start, \"I_STATEMENT_SPARSE_SWITCH\"] ^( I_SPARSE_SWITCH_ELEMENTS[$start, \"I_SPARSE_SWITCH_ELEMENTS\"] ( fixed_32bit_literal label_ref )* ) ) 14240 { 14241 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1108:8: ^( I_STATEMENT_SPARSE_SWITCH[$start, \"I_STATEMENT_SPARSE_SWITCH\"] ^( I_SPARSE_SWITCH_ELEMENTS[$start, \"I_SPARSE_SWITCH_ELEMENTS\"] ( fixed_32bit_literal label_ref )* ) ) 14242 { 14243 CommonTree root_1 = (CommonTree)adaptor.nil(); 14244 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_STATEMENT_SPARSE_SWITCH, (retval.start), "I_STATEMENT_SPARSE_SWITCH"), root_1); 14245 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1109:8: ^( I_SPARSE_SWITCH_ELEMENTS[$start, \"I_SPARSE_SWITCH_ELEMENTS\"] ( fixed_32bit_literal label_ref )* ) 14246 { 14247 CommonTree root_2 = (CommonTree)adaptor.nil(); 14248 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(I_SPARSE_SWITCH_ELEMENTS, (retval.start), "I_SPARSE_SWITCH_ELEMENTS"), root_2); 14249 // /mnt/ssd1/workspace/aosp_master/external/smali/smali/src/main/antlr3/smaliParser.g:1109:71: ( fixed_32bit_literal label_ref )* 14250 while ( stream_label_ref.hasNext()||stream_fixed_32bit_literal.hasNext() ) { 14251 adaptor.addChild(root_2, stream_fixed_32bit_literal.nextTree()); 14252 adaptor.addChild(root_2, stream_label_ref.nextTree()); 14253 } 14254 stream_label_ref.reset(); 14255 stream_fixed_32bit_literal.reset(); 14256 14257 adaptor.addChild(root_1, root_2); 14258 } 14259 14260 adaptor.addChild(root_0, root_1); 14261 } 14262 14263 } 14264 14265 14266 retval.tree = root_0; 14267 14268 } 14269 14270 retval.stop = input.LT(-1); 14271 14272 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0); 14273 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 14274 14275 } 14276 catch (RecognitionException re) { 14277 reportError(re); 14278 recover(input,re); 14279 retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re); 14280 } 14281 finally { 14282 // do for sure before leaving 14283 } 14284 return retval; 14285 } 14286 // $ANTLR end "insn_sparse_switch_directive" 14287 14288 // Delegated rules 14289 14290 14291 protected DFA28 dfa28 = new DFA28(this); 14292 protected DFA36 dfa36 = new DFA36(this); 14293 protected DFA38 dfa38 = new DFA38(this); 14294 static final String DFA28_eotS = 14295 "\55\uffff"; 14296 static final String DFA28_eofS = 14297 "\55\uffff"; 14298 static final String DFA28_minS = 14299 "\1\4\12\23\1\u00b8\35\23\2\uffff\1\u00b4\1\23"; 14300 static final String DFA28_maxS = 14301 "\1\u00c5\12\u00b0\1\u00b8\35\u00b0\2\uffff\1\u00b8\1\u00b0"; 14302 static final String DFA28_acceptS = 14303 "\51\uffff\1\1\1\2\2\uffff"; 14304 static final String DFA28_specialS = 14305 "\55\uffff}>"; 14306 static final String[] DFA28_transitionS = { 14307 "\1\2\1\uffff\1\16\3\uffff\1\10\14\uffff\1\7\17\uffff\1\6\2\uffff\1\17"+ 14308 "\1\20\1\21\1\uffff\1\22\1\uffff\1\23\2\uffff\1\24\1\25\1\26\1\27\3\uffff"+ 14309 "\1\30\1\uffff\1\31\1\32\1\33\1\34\1\uffff\1\35\1\36\1\uffff\1\37\3\uffff"+ 14310 "\1\40\1\41\1\uffff\1\42\1\43\1\44\1\45\1\46\5\uffff\1\47\125\uffff\1"+ 14311 "\50\1\uffff\1\5\1\11\6\uffff\1\13\1\uffff\1\4\1\14\1\uffff\1\12\3\uffff"+ 14312 "\1\1\5\uffff\1\3\1\15", 14313 "\1\51\u009c\uffff\1\52", 14314 "\1\51\u009c\uffff\1\52", 14315 "\1\51\u009c\uffff\1\52", 14316 "\1\51\u009c\uffff\1\52", 14317 "\1\51\u009c\uffff\1\52", 14318 "\1\51\u009c\uffff\1\52", 14319 "\1\51\u009c\uffff\1\52", 14320 "\1\51\u009c\uffff\1\52", 14321 "\1\51\u009c\uffff\1\52", 14322 "\1\51\u009c\uffff\1\52", 14323 "\1\53", 14324 "\1\51\u009c\uffff\1\52", 14325 "\1\51\u009c\uffff\1\52", 14326 "\1\51\u009c\uffff\1\52", 14327 "\1\51\u009c\uffff\1\52", 14328 "\1\51\u009c\uffff\1\52", 14329 "\1\51\u009c\uffff\1\52", 14330 "\1\51\u009c\uffff\1\52", 14331 "\1\51\u009c\uffff\1\52", 14332 "\1\51\u009c\uffff\1\52", 14333 "\1\51\u009c\uffff\1\52", 14334 "\1\51\u009c\uffff\1\52", 14335 "\1\51\u009c\uffff\1\52", 14336 "\1\51\u009c\uffff\1\52", 14337 "\1\51\u009c\uffff\1\52", 14338 "\1\51\u009c\uffff\1\52", 14339 "\1\51\u009c\uffff\1\52", 14340 "\1\51\u009c\uffff\1\52", 14341 "\1\51\u009c\uffff\1\52", 14342 "\1\51\u009c\uffff\1\52", 14343 "\1\51\u009c\uffff\1\52", 14344 "\1\51\u009c\uffff\1\52", 14345 "\1\51\u009c\uffff\1\52", 14346 "\1\51\u009c\uffff\1\52", 14347 "\1\51\u009c\uffff\1\52", 14348 "\1\51\u009c\uffff\1\52", 14349 "\1\51\u009c\uffff\1\52", 14350 "\1\51\u009c\uffff\1\52", 14351 "\1\51\u009c\uffff\1\52", 14352 "\1\51\u009c\uffff\1\52", 14353 "", 14354 "", 14355 "\1\54\3\uffff\1\53", 14356 "\1\51\u009c\uffff\1\52" 14357 }; 14358 14359 static final short[] DFA28_eot = DFA.unpackEncodedString(DFA28_eotS); 14360 static final short[] DFA28_eof = DFA.unpackEncodedString(DFA28_eofS); 14361 static final char[] DFA28_min = DFA.unpackEncodedStringToUnsignedChars(DFA28_minS); 14362 static final char[] DFA28_max = DFA.unpackEncodedStringToUnsignedChars(DFA28_maxS); 14363 static final short[] DFA28_accept = DFA.unpackEncodedString(DFA28_acceptS); 14364 static final short[] DFA28_special = DFA.unpackEncodedString(DFA28_specialS); 14365 static final short[][] DFA28_transition; 14366 14367 static { 14368 int numStates = DFA28_transitionS.length; 14369 DFA28_transition = new short[numStates][]; 14370 for (int i=0; i<numStates; i++) { 14371 DFA28_transition[i] = DFA.unpackEncodedString(DFA28_transitionS[i]); 14372 } 14373 } 14374 14375 protected class DFA28 extends DFA { 14376 14377 public DFA28(BaseRecognizer recognizer) { 14378 this.recognizer = recognizer; 14379 this.decisionNumber = 28; 14380 this.eot = DFA28_eot; 14381 this.eof = DFA28_eof; 14382 this.min = DFA28_min; 14383 this.max = DFA28_max; 14384 this.accept = DFA28_accept; 14385 this.special = DFA28_special; 14386 this.transition = DFA28_transition; 14387 } 14388 @Override 14389 public String getDescription() { 14390 return "690: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 ) )"; 14391 } 14392 } 14393 14394 static final String DFA36_eotS = 14395 "\61\uffff"; 14396 static final String DFA36_eofS = 14397 "\61\uffff"; 14398 static final String DFA36_minS = 14399 "\1\4\1\5\1\11\12\23\1\u00b8\35\23\1\uffff\1\4\2\uffff\1\u00b4\1\23"; 14400 static final String DFA36_maxS = 14401 "\1\u00c5\1\u00c0\1\11\12\u00b0\1\u00b8\35\u00b0\1\uffff\1\u00c5\2\uffff"+ 14402 "\1\u00b8\1\u00b0"; 14403 static final String DFA36_acceptS = 14404 "\53\uffff\1\1\1\uffff\1\2\1\3\2\uffff"; 14405 static final String DFA36_specialS = 14406 "\61\uffff}>"; 14407 static final String[] DFA36_transitionS = { 14408 "\1\4\1\uffff\1\20\1\uffff\1\2\1\uffff\1\12\4\uffff\1\1\7\uffff\1\11\17"+ 14409 "\uffff\1\10\2\uffff\1\21\1\22\1\23\1\uffff\1\24\1\uffff\1\25\2\uffff"+ 14410 "\1\26\1\27\1\30\1\31\3\uffff\1\32\1\uffff\1\33\1\34\1\35\1\36\1\uffff"+ 14411 "\1\37\1\40\1\uffff\1\41\3\uffff\1\42\1\43\1\uffff\1\44\1\45\1\46\1\47"+ 14412 "\1\50\5\uffff\1\51\125\uffff\1\52\1\uffff\1\7\1\13\6\uffff\1\15\1\uffff"+ 14413 "\1\6\1\16\1\uffff\1\14\3\uffff\1\3\5\uffff\1\5\1\17", 14414 "\1\53\1\uffff\1\53\1\uffff\1\54\2\uffff\2\53\5\uffff\1\53\7\uffff\2"+ 14415 "\53\5\uffff\1\53\7\uffff\54\53\121\uffff\3\53\7\uffff\2\53\6\uffff\1"+ 14416 "\53\1\uffff\2\53\2\uffff\2\53", 14417 "\1\54", 14418 "\1\55\u009c\uffff\1\56", 14419 "\1\55\u009c\uffff\1\56", 14420 "\1\55\u009c\uffff\1\56", 14421 "\1\55\u009c\uffff\1\56", 14422 "\1\55\u009c\uffff\1\56", 14423 "\1\55\u009c\uffff\1\56", 14424 "\1\55\u009c\uffff\1\56", 14425 "\1\55\u009c\uffff\1\56", 14426 "\1\55\u009c\uffff\1\56", 14427 "\1\55\u009c\uffff\1\56", 14428 "\1\57", 14429 "\1\55\u009c\uffff\1\56", 14430 "\1\55\u009c\uffff\1\56", 14431 "\1\55\u009c\uffff\1\56", 14432 "\1\55\u009c\uffff\1\56", 14433 "\1\55\u009c\uffff\1\56", 14434 "\1\55\u009c\uffff\1\56", 14435 "\1\55\u009c\uffff\1\56", 14436 "\1\55\u009c\uffff\1\56", 14437 "\1\55\u009c\uffff\1\56", 14438 "\1\55\u009c\uffff\1\56", 14439 "\1\55\u009c\uffff\1\56", 14440 "\1\55\u009c\uffff\1\56", 14441 "\1\55\u009c\uffff\1\56", 14442 "\1\55\u009c\uffff\1\56", 14443 "\1\55\u009c\uffff\1\56", 14444 "\1\55\u009c\uffff\1\56", 14445 "\1\55\u009c\uffff\1\56", 14446 "\1\55\u009c\uffff\1\56", 14447 "\1\55\u009c\uffff\1\56", 14448 "\1\55\u009c\uffff\1\56", 14449 "\1\55\u009c\uffff\1\56", 14450 "\1\55\u009c\uffff\1\56", 14451 "\1\55\u009c\uffff\1\56", 14452 "\1\55\u009c\uffff\1\56", 14453 "\1\55\u009c\uffff\1\56", 14454 "\1\55\u009c\uffff\1\56", 14455 "\1\55\u009c\uffff\1\56", 14456 "\1\55\u009c\uffff\1\56", 14457 "\1\55\u009c\uffff\1\56", 14458 "", 14459 "\1\4\1\uffff\1\20\3\uffff\1\12\14\uffff\1\11\17\uffff\1\10\2\uffff\1"+ 14460 "\21\1\22\1\23\1\uffff\1\24\1\uffff\1\25\2\uffff\1\26\1\27\1\30\1\31\3"+ 14461 "\uffff\1\32\1\uffff\1\33\1\34\1\35\1\36\1\uffff\1\37\1\40\1\uffff\1\41"+ 14462 "\3\uffff\1\42\1\43\1\uffff\1\44\1\45\1\46\1\47\1\50\5\uffff\1\51\125"+ 14463 "\uffff\1\52\1\uffff\1\7\1\13\6\uffff\1\15\1\uffff\1\6\1\16\1\uffff\1"+ 14464 "\14\3\uffff\1\3\5\uffff\1\5\1\17", 14465 "", 14466 "", 14467 "\1\60\3\uffff\1\57", 14468 "\1\55\u009c\uffff\1\56" 14469 }; 14470 14471 static final short[] DFA36_eot = DFA.unpackEncodedString(DFA36_eotS); 14472 static final short[] DFA36_eof = DFA.unpackEncodedString(DFA36_eofS); 14473 static final char[] DFA36_min = DFA.unpackEncodedStringToUnsignedChars(DFA36_minS); 14474 static final char[] DFA36_max = DFA.unpackEncodedStringToUnsignedChars(DFA36_maxS); 14475 static final short[] DFA36_accept = DFA.unpackEncodedString(DFA36_acceptS); 14476 static final short[] DFA36_special = DFA.unpackEncodedString(DFA36_specialS); 14477 static final short[][] DFA36_transition; 14478 14479 static { 14480 int numStates = DFA36_transitionS.length; 14481 DFA36_transition = new short[numStates][]; 14482 for (int i=0; i<numStates; i++) { 14483 DFA36_transition[i] = DFA.unpackEncodedString(DFA36_transitionS[i]); 14484 } 14485 } 14486 14487 protected class DFA36 extends DFA { 14488 14489 public DFA36(BaseRecognizer recognizer) { 14490 this.recognizer = recognizer; 14491 this.decisionNumber = 36; 14492 this.eot = DFA36_eot; 14493 this.eof = DFA36_eof; 14494 this.min = DFA36_min; 14495 this.max = DFA36_max; 14496 this.accept = DFA36_accept; 14497 this.special = DFA36_special; 14498 this.transition = DFA36_transition; 14499 } 14500 @Override 14501 public String getDescription() { 14502 return "718:1: verification_error_reference : ( CLASS_DESCRIPTOR | field_reference | method_reference );"; 14503 } 14504 } 14505 14506 static final String DFA38_eotS = 14507 "\101\uffff"; 14508 static final String DFA38_eofS = 14509 "\101\uffff"; 14510 static final String DFA38_minS = 14511 "\1\5\76\uffff\1\0\1\uffff"; 14512 static final String DFA38_maxS = 14513 "\1\u00c0\76\uffff\1\0\1\uffff"; 14514 static final String DFA38_acceptS = 14515 "\1\uffff\1\2\76\uffff\1\1"; 14516 static final String DFA38_specialS = 14517 "\77\uffff\1\0\1\uffff}>"; 14518 static final String[] DFA38_transitionS = { 14519 "\1\77\1\uffff\1\1\4\uffff\2\1\5\uffff\1\1\7\uffff\2\1\1\uffff\1\1\3\uffff"+ 14520 "\1\1\7\uffff\54\1\121\uffff\3\1\7\uffff\2\1\6\uffff\1\1\1\uffff\2\1\2"+ 14521 "\uffff\2\1", 14522 "", 14523 "", 14524 "", 14525 "", 14526 "", 14527 "", 14528 "", 14529 "", 14530 "", 14531 "", 14532 "", 14533 "", 14534 "", 14535 "", 14536 "", 14537 "", 14538 "", 14539 "", 14540 "", 14541 "", 14542 "", 14543 "", 14544 "", 14545 "", 14546 "", 14547 "", 14548 "", 14549 "", 14550 "", 14551 "", 14552 "", 14553 "", 14554 "", 14555 "", 14556 "", 14557 "", 14558 "", 14559 "", 14560 "", 14561 "", 14562 "", 14563 "", 14564 "", 14565 "", 14566 "", 14567 "", 14568 "", 14569 "", 14570 "", 14571 "", 14572 "", 14573 "", 14574 "", 14575 "", 14576 "", 14577 "", 14578 "", 14579 "", 14580 "", 14581 "", 14582 "", 14583 "", 14584 "\1\uffff", 14585 "" 14586 }; 14587 14588 static final short[] DFA38_eot = DFA.unpackEncodedString(DFA38_eotS); 14589 static final short[] DFA38_eof = DFA.unpackEncodedString(DFA38_eofS); 14590 static final char[] DFA38_min = DFA.unpackEncodedStringToUnsignedChars(DFA38_minS); 14591 static final char[] DFA38_max = DFA.unpackEncodedStringToUnsignedChars(DFA38_maxS); 14592 static final short[] DFA38_accept = DFA.unpackEncodedString(DFA38_acceptS); 14593 static final short[] DFA38_special = DFA.unpackEncodedString(DFA38_specialS); 14594 static final short[][] DFA38_transition; 14595 14596 static { 14597 int numStates = DFA38_transitionS.length; 14598 DFA38_transition = new short[numStates][]; 14599 for (int i=0; i<numStates; i++) { 14600 DFA38_transition[i] = DFA.unpackEncodedString(DFA38_transitionS[i]); 14601 } 14602 } 14603 14604 protected class DFA38 extends DFA { 14605 14606 public DFA38(BaseRecognizer recognizer) { 14607 this.recognizer = recognizer; 14608 this.decisionNumber = 38; 14609 this.eot = DFA38_eot; 14610 this.eof = DFA38_eof; 14611 this.min = DFA38_min; 14612 this.max = DFA38_max; 14613 this.accept = DFA38_accept; 14614 this.special = DFA38_special; 14615 this.transition = DFA38_transition; 14616 } 14617 @Override 14618 public String getDescription() { 14619 return "()* loopback of 736:5: ({...}? annotation )*"; 14620 } 14621 @Override 14622 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { 14623 TokenStream input = (TokenStream)_input; 14624 int _s = s; 14625 switch ( s ) { 14626 case 0 : 14627 int LA38_63 = input.LA(1); 14628 14629 int index38_63 = input.index(); 14630 input.rewind(); 14631 s = -1; 14632 if ( ((input.LA(1) == ANNOTATION_DIRECTIVE)) ) {s = 64;} 14633 else if ( (true) ) {s = 1;} 14634 14635 input.seek(index38_63); 14636 if ( s>=0 ) return s; 14637 break; 14638 } 14639 NoViableAltException nvae = 14640 new NoViableAltException(getDescription(), 38, _s, input); 14641 error(nvae); 14642 throw nvae; 14643 } 14644 } 14645 14646 public static final BitSet FOLLOW_class_spec_in_smali_file1070 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x8000100000000000L,0x0000000000000008L}); 14647 public static final BitSet FOLLOW_super_spec_in_smali_file1081 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x8000100000000000L,0x0000000000000008L}); 14648 public static final BitSet FOLLOW_implements_spec_in_smali_file1089 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x8000100000000000L,0x0000000000000008L}); 14649 public static final BitSet FOLLOW_source_spec_in_smali_file1098 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x8000100000000000L,0x0000000000000008L}); 14650 public static final BitSet FOLLOW_method_in_smali_file1106 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x8000100000000000L,0x0000000000000008L}); 14651 public static final BitSet FOLLOW_field_in_smali_file1112 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x8000100000000000L,0x0000000000000008L}); 14652 public static final BitSet FOLLOW_annotation_in_smali_file1118 = new BitSet(new long[]{0x0000011000010020L,0x0000000000000000L,0x8000100000000000L,0x0000000000000008L}); 14653 public static final BitSet FOLLOW_EOF_in_smali_file1129 = new BitSet(new long[]{0x0000000000000002L}); 14654 public static final BitSet FOLLOW_CLASS_DIRECTIVE_in_class_spec1216 = new BitSet(new long[]{0x0000000000008010L}); 14655 public static final BitSet FOLLOW_access_list_in_class_spec1218 = new BitSet(new long[]{0x0000000000008000L}); 14656 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_class_spec1220 = new BitSet(new long[]{0x0000000000000002L}); 14657 public static final BitSet FOLLOW_SUPER_DIRECTIVE_in_super_spec1238 = new BitSet(new long[]{0x0000000000008000L}); 14658 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_super_spec1240 = new BitSet(new long[]{0x0000000000000002L}); 14659 public static final BitSet FOLLOW_IMPLEMENTS_DIRECTIVE_in_implements_spec1259 = new BitSet(new long[]{0x0000000000008000L}); 14660 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_implements_spec1261 = new BitSet(new long[]{0x0000000000000002L}); 14661 public static final BitSet FOLLOW_SOURCE_DIRECTIVE_in_source_spec1280 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000002L}); 14662 public static final BitSet FOLLOW_STRING_LITERAL_in_source_spec1282 = new BitSet(new long[]{0x0000000000000002L}); 14663 public static final BitSet FOLLOW_ACCESS_SPEC_in_access_list1301 = new BitSet(new long[]{0x0000000000000012L}); 14664 public static final BitSet FOLLOW_FIELD_DIRECTIVE_in_field1332 = new BitSet(new long[]{0xF4795C8000800450L,0x000000000020FB16L,0x45A0680000000000L,0x0000000000000030L}); 14665 public static final BitSet FOLLOW_access_list_in_field1334 = new BitSet(new long[]{0xF4795C8000800450L,0x000000000020FB16L,0x45A0680000000000L,0x0000000000000030L}); 14666 public static final BitSet FOLLOW_member_name_in_field1336 = new BitSet(new long[]{0x0000000000080000L}); 14667 public static final BitSet FOLLOW_COLON_in_field1338 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0100000000000000L}); 14668 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_field1340 = new BitSet(new long[]{0x0000000804000022L}); 14669 public static final BitSet FOLLOW_EQUAL_in_field1343 = new BitSet(new long[]{0xF4795CC200C0CD50L,0x000000000020FB16L,0x65A0EC0000000000L,0x0000000000000036L}); 14670 public static final BitSet FOLLOW_literal_in_field1345 = new BitSet(new long[]{0x0000000004000022L}); 14671 public static final BitSet FOLLOW_annotation_in_field1358 = new BitSet(new long[]{0x0000000004000022L}); 14672 public static final BitSet FOLLOW_END_FIELD_DIRECTIVE_in_field1372 = new BitSet(new long[]{0x0000000000000002L}); 14673 public static final BitSet FOLLOW_METHOD_DIRECTIVE_in_method1483 = new BitSet(new long[]{0xF4795C8000800450L,0x000000000020FB16L,0x45A0680000000000L,0x0000000000000030L}); 14674 public static final BitSet FOLLOW_access_list_in_method1485 = new BitSet(new long[]{0xF4795C8000800450L,0x000000000020FB16L,0x45A0680000000000L,0x0000000000000030L}); 14675 public static final BitSet FOLLOW_member_name_in_method1487 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0001000000000000L}); 14676 public static final BitSet FOLLOW_method_prototype_in_method1489 = new BitSet(new long[]{0xFFFFFC04180830A0L,0x00000000003FFFFFL,0x9A06038000000000L,0x0000000000000001L}); 14677 public static final BitSet FOLLOW_statements_and_directives_in_method1491 = new BitSet(new long[]{0x0000000010000000L}); 14678 public static final BitSet FOLLOW_END_METHOD_DIRECTIVE_in_method1497 = new BitSet(new long[]{0x0000000000000002L}); 14679 public static final BitSet FOLLOW_ordered_method_item_in_statements_and_directives1542 = new BitSet(new long[]{0xFFFFFC04080830A2L,0x00000000003FFFFFL,0x9A06038000000000L,0x0000000000000001L}); 14680 public static final BitSet FOLLOW_registers_directive_in_statements_and_directives1550 = new BitSet(new long[]{0xFFFFFC04080830A2L,0x00000000003FFFFFL,0x9A06038000000000L,0x0000000000000001L}); 14681 public static final BitSet FOLLOW_catch_directive_in_statements_and_directives1558 = new BitSet(new long[]{0xFFFFFC04080830A2L,0x00000000003FFFFFL,0x9A06038000000000L,0x0000000000000001L}); 14682 public static final BitSet FOLLOW_catchall_directive_in_statements_and_directives1566 = new BitSet(new long[]{0xFFFFFC04080830A2L,0x00000000003FFFFFL,0x9A06038000000000L,0x0000000000000001L}); 14683 public static final BitSet FOLLOW_parameter_directive_in_statements_and_directives1574 = new BitSet(new long[]{0xFFFFFC04080830A2L,0x00000000003FFFFFL,0x9A06038000000000L,0x0000000000000001L}); 14684 public static final BitSet FOLLOW_annotation_in_statements_and_directives1582 = new BitSet(new long[]{0xFFFFFC04080830A2L,0x00000000003FFFFFL,0x9A06038000000000L,0x0000000000000001L}); 14685 public static final BitSet FOLLOW_label_in_ordered_method_item1667 = new BitSet(new long[]{0x0000000000000002L}); 14686 public static final BitSet FOLLOW_instruction_in_ordered_method_item1673 = new BitSet(new long[]{0x0000000000000002L}); 14687 public static final BitSet FOLLOW_debug_directive_in_ordered_method_item1679 = new BitSet(new long[]{0x0000000000000002L}); 14688 public static final BitSet FOLLOW_REGISTERS_DIRECTIVE_in_registers_directive1699 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x2080240000000000L}); 14689 public static final BitSet FOLLOW_integral_literal_in_registers_directive1703 = new BitSet(new long[]{0x0000000000000002L}); 14690 public static final BitSet FOLLOW_LOCALS_DIRECTIVE_in_registers_directive1723 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x2080240000000000L}); 14691 public static final BitSet FOLLOW_integral_literal_in_registers_directive1727 = new BitSet(new long[]{0x0000000000000002L}); 14692 public static final BitSet FOLLOW_PARAM_LIST_OR_ID_START_in_param_list_or_id1759 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0100000000000000L}); 14693 public static final BitSet FOLLOW_PRIMITIVE_TYPE_in_param_list_or_id1761 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0110000000000000L}); 14694 public static final BitSet FOLLOW_PARAM_LIST_OR_ID_END_in_param_list_or_id1764 = new BitSet(new long[]{0x0000000000000002L}); 14695 public static final BitSet FOLLOW_SIMPLE_NAME_in_simple_name1776 = new BitSet(new long[]{0x0000000000000002L}); 14696 public static final BitSet FOLLOW_ACCESS_SPEC_in_simple_name1782 = new BitSet(new long[]{0x0000000000000002L}); 14697 public static final BitSet FOLLOW_VERIFICATION_ERROR_TYPE_in_simple_name1793 = new BitSet(new long[]{0x0000000000000002L}); 14698 public static final BitSet FOLLOW_POSITIVE_INTEGER_LITERAL_in_simple_name1804 = new BitSet(new long[]{0x0000000000000002L}); 14699 public static final BitSet FOLLOW_NEGATIVE_INTEGER_LITERAL_in_simple_name1815 = new BitSet(new long[]{0x0000000000000002L}); 14700 public static final BitSet FOLLOW_FLOAT_LITERAL_OR_ID_in_simple_name1826 = new BitSet(new long[]{0x0000000000000002L}); 14701 public static final BitSet FOLLOW_DOUBLE_LITERAL_OR_ID_in_simple_name1837 = new BitSet(new long[]{0x0000000000000002L}); 14702 public static final BitSet FOLLOW_BOOL_LITERAL_in_simple_name1848 = new BitSet(new long[]{0x0000000000000002L}); 14703 public static final BitSet FOLLOW_NULL_LITERAL_in_simple_name1859 = new BitSet(new long[]{0x0000000000000002L}); 14704 public static final BitSet FOLLOW_REGISTER_in_simple_name1870 = new BitSet(new long[]{0x0000000000000002L}); 14705 public static final BitSet FOLLOW_param_list_or_id_in_simple_name1881 = new BitSet(new long[]{0x0000000000000002L}); 14706 public static final BitSet FOLLOW_PRIMITIVE_TYPE_in_simple_name1891 = new BitSet(new long[]{0x0000000000000002L}); 14707 public static final BitSet FOLLOW_VOID_TYPE_in_simple_name1902 = new BitSet(new long[]{0x0000000000000002L}); 14708 public static final BitSet FOLLOW_ANNOTATION_VISIBILITY_in_simple_name1913 = new BitSet(new long[]{0x0000000000000002L}); 14709 public static final BitSet FOLLOW_INSTRUCTION_FORMAT10t_in_simple_name1924 = new BitSet(new long[]{0x0000000000000002L}); 14710 public static final BitSet FOLLOW_INSTRUCTION_FORMAT10x_in_simple_name1935 = new BitSet(new long[]{0x0000000000000002L}); 14711 public static final BitSet FOLLOW_INSTRUCTION_FORMAT10x_ODEX_in_simple_name1946 = new BitSet(new long[]{0x0000000000000002L}); 14712 public static final BitSet FOLLOW_INSTRUCTION_FORMAT11x_in_simple_name1957 = new BitSet(new long[]{0x0000000000000002L}); 14713 public static final BitSet FOLLOW_INSTRUCTION_FORMAT12x_OR_ID_in_simple_name1968 = new BitSet(new long[]{0x0000000000000002L}); 14714 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_FIELD_in_simple_name1979 = new BitSet(new long[]{0x0000000000000002L}); 14715 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_FIELD_ODEX_in_simple_name1990 = new BitSet(new long[]{0x0000000000000002L}); 14716 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_STRING_in_simple_name2001 = new BitSet(new long[]{0x0000000000000002L}); 14717 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_TYPE_in_simple_name2012 = new BitSet(new long[]{0x0000000000000002L}); 14718 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21t_in_simple_name2023 = new BitSet(new long[]{0x0000000000000002L}); 14719 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_FIELD_in_simple_name2034 = new BitSet(new long[]{0x0000000000000002L}); 14720 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_FIELD_ODEX_in_simple_name2045 = new BitSet(new long[]{0x0000000000000002L}); 14721 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_TYPE_in_simple_name2056 = new BitSet(new long[]{0x0000000000000002L}); 14722 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22cs_FIELD_in_simple_name2067 = new BitSet(new long[]{0x0000000000000002L}); 14723 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22s_OR_ID_in_simple_name2078 = new BitSet(new long[]{0x0000000000000002L}); 14724 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22t_in_simple_name2089 = new BitSet(new long[]{0x0000000000000002L}); 14725 public static final BitSet FOLLOW_INSTRUCTION_FORMAT23x_in_simple_name2100 = new BitSet(new long[]{0x0000000000000002L}); 14726 public static final BitSet FOLLOW_INSTRUCTION_FORMAT31i_OR_ID_in_simple_name2111 = new BitSet(new long[]{0x0000000000000002L}); 14727 public static final BitSet FOLLOW_INSTRUCTION_FORMAT31t_in_simple_name2122 = new BitSet(new long[]{0x0000000000000002L}); 14728 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_METHOD_in_simple_name2133 = new BitSet(new long[]{0x0000000000000002L}); 14729 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_METHOD_ODEX_in_simple_name2144 = new BitSet(new long[]{0x0000000000000002L}); 14730 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_TYPE_in_simple_name2155 = new BitSet(new long[]{0x0000000000000002L}); 14731 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35mi_METHOD_in_simple_name2166 = new BitSet(new long[]{0x0000000000000002L}); 14732 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35ms_METHOD_in_simple_name2177 = new BitSet(new long[]{0x0000000000000002L}); 14733 public static final BitSet FOLLOW_INSTRUCTION_FORMAT51l_in_simple_name2188 = new BitSet(new long[]{0x0000000000000002L}); 14734 public static final BitSet FOLLOW_simple_name_in_member_name2203 = new BitSet(new long[]{0x0000000000000002L}); 14735 public static final BitSet FOLLOW_MEMBER_NAME_in_member_name2209 = new BitSet(new long[]{0x0000000000000002L}); 14736 public static final BitSet FOLLOW_OPEN_PAREN_in_method_prototype2224 = new BitSet(new long[]{0x0000000000048100L,0x0000000000000000L,0x0160000000000000L}); 14737 public static final BitSet FOLLOW_param_list_in_method_prototype2226 = new BitSet(new long[]{0x0000000000040000L}); 14738 public static final BitSet FOLLOW_CLOSE_PAREN_in_method_prototype2228 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0100000000000000L,0x0000000000000020L}); 14739 public static final BitSet FOLLOW_type_descriptor_in_method_prototype2230 = new BitSet(new long[]{0x0000000000000002L}); 14740 public static final BitSet FOLLOW_PARAM_LIST_START_in_param_list2260 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0108000000000000L}); 14741 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_param_list2262 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0108000000000000L}); 14742 public static final BitSet FOLLOW_PARAM_LIST_END_in_param_list2265 = new BitSet(new long[]{0x0000000000000002L}); 14743 public static final BitSet FOLLOW_PARAM_LIST_OR_ID_START_in_param_list2276 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0110000000000000L}); 14744 public static final BitSet FOLLOW_PRIMITIVE_TYPE_in_param_list2278 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0110000000000000L}); 14745 public static final BitSet FOLLOW_PARAM_LIST_OR_ID_END_in_param_list2281 = new BitSet(new long[]{0x0000000000000002L}); 14746 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_param_list2292 = new BitSet(new long[]{0x0000000000008102L,0x0000000000000000L,0x0100000000000000L}); 14747 public static final BitSet FOLLOW_POSITIVE_INTEGER_LITERAL_in_integer_literal2369 = new BitSet(new long[]{0x0000000000000002L}); 14748 public static final BitSet FOLLOW_NEGATIVE_INTEGER_LITERAL_in_integer_literal2380 = new BitSet(new long[]{0x0000000000000002L}); 14749 public static final BitSet FOLLOW_FLOAT_LITERAL_OR_ID_in_float_literal2395 = new BitSet(new long[]{0x0000000000000002L}); 14750 public static final BitSet FOLLOW_FLOAT_LITERAL_in_float_literal2406 = new BitSet(new long[]{0x0000000000000002L}); 14751 public static final BitSet FOLLOW_DOUBLE_LITERAL_OR_ID_in_double_literal2416 = new BitSet(new long[]{0x0000000000000002L}); 14752 public static final BitSet FOLLOW_DOUBLE_LITERAL_in_double_literal2427 = new BitSet(new long[]{0x0000000000000002L}); 14753 public static final BitSet FOLLOW_LONG_LITERAL_in_literal2437 = new BitSet(new long[]{0x0000000000000002L}); 14754 public static final BitSet FOLLOW_integer_literal_in_literal2443 = new BitSet(new long[]{0x0000000000000002L}); 14755 public static final BitSet FOLLOW_SHORT_LITERAL_in_literal2449 = new BitSet(new long[]{0x0000000000000002L}); 14756 public static final BitSet FOLLOW_BYTE_LITERAL_in_literal2455 = new BitSet(new long[]{0x0000000000000002L}); 14757 public static final BitSet FOLLOW_float_literal_in_literal2461 = new BitSet(new long[]{0x0000000000000002L}); 14758 public static final BitSet FOLLOW_double_literal_in_literal2467 = new BitSet(new long[]{0x0000000000000002L}); 14759 public static final BitSet FOLLOW_CHAR_LITERAL_in_literal2473 = new BitSet(new long[]{0x0000000000000002L}); 14760 public static final BitSet FOLLOW_STRING_LITERAL_in_literal2479 = new BitSet(new long[]{0x0000000000000002L}); 14761 public static final BitSet FOLLOW_BOOL_LITERAL_in_literal2485 = new BitSet(new long[]{0x0000000000000002L}); 14762 public static final BitSet FOLLOW_NULL_LITERAL_in_literal2491 = new BitSet(new long[]{0x0000000000000002L}); 14763 public static final BitSet FOLLOW_array_literal_in_literal2497 = new BitSet(new long[]{0x0000000000000002L}); 14764 public static final BitSet FOLLOW_subannotation_in_literal2503 = new BitSet(new long[]{0x0000000000000002L}); 14765 public static final BitSet FOLLOW_type_field_method_literal_in_literal2509 = new BitSet(new long[]{0x0000000000000002L}); 14766 public static final BitSet FOLLOW_enum_literal_in_literal2515 = new BitSet(new long[]{0x0000000000000002L}); 14767 public static final BitSet FOLLOW_integer_literal_in_parsed_integer_literal2528 = new BitSet(new long[]{0x0000000000000002L}); 14768 public static final BitSet FOLLOW_LONG_LITERAL_in_integral_literal2540 = new BitSet(new long[]{0x0000000000000002L}); 14769 public static final BitSet FOLLOW_integer_literal_in_integral_literal2546 = new BitSet(new long[]{0x0000000000000002L}); 14770 public static final BitSet FOLLOW_SHORT_LITERAL_in_integral_literal2552 = new BitSet(new long[]{0x0000000000000002L}); 14771 public static final BitSet FOLLOW_CHAR_LITERAL_in_integral_literal2558 = new BitSet(new long[]{0x0000000000000002L}); 14772 public static final BitSet FOLLOW_BYTE_LITERAL_in_integral_literal2564 = new BitSet(new long[]{0x0000000000000002L}); 14773 public static final BitSet FOLLOW_LONG_LITERAL_in_fixed_32bit_literal2574 = new BitSet(new long[]{0x0000000000000002L}); 14774 public static final BitSet FOLLOW_integer_literal_in_fixed_32bit_literal2580 = new BitSet(new long[]{0x0000000000000002L}); 14775 public static final BitSet FOLLOW_SHORT_LITERAL_in_fixed_32bit_literal2586 = new BitSet(new long[]{0x0000000000000002L}); 14776 public static final BitSet FOLLOW_BYTE_LITERAL_in_fixed_32bit_literal2592 = new BitSet(new long[]{0x0000000000000002L}); 14777 public static final BitSet FOLLOW_float_literal_in_fixed_32bit_literal2598 = new BitSet(new long[]{0x0000000000000002L}); 14778 public static final BitSet FOLLOW_CHAR_LITERAL_in_fixed_32bit_literal2604 = new BitSet(new long[]{0x0000000000000002L}); 14779 public static final BitSet FOLLOW_BOOL_LITERAL_in_fixed_32bit_literal2610 = new BitSet(new long[]{0x0000000000000002L}); 14780 public static final BitSet FOLLOW_integer_literal_in_fixed_literal2620 = new BitSet(new long[]{0x0000000000000002L}); 14781 public static final BitSet FOLLOW_LONG_LITERAL_in_fixed_literal2626 = new BitSet(new long[]{0x0000000000000002L}); 14782 public static final BitSet FOLLOW_SHORT_LITERAL_in_fixed_literal2632 = new BitSet(new long[]{0x0000000000000002L}); 14783 public static final BitSet FOLLOW_BYTE_LITERAL_in_fixed_literal2638 = new BitSet(new long[]{0x0000000000000002L}); 14784 public static final BitSet FOLLOW_float_literal_in_fixed_literal2644 = new BitSet(new long[]{0x0000000000000002L}); 14785 public static final BitSet FOLLOW_double_literal_in_fixed_literal2650 = new BitSet(new long[]{0x0000000000000002L}); 14786 public static final BitSet FOLLOW_CHAR_LITERAL_in_fixed_literal2656 = new BitSet(new long[]{0x0000000000000002L}); 14787 public static final BitSet FOLLOW_BOOL_LITERAL_in_fixed_literal2662 = new BitSet(new long[]{0x0000000000000002L}); 14788 public static final BitSet FOLLOW_OPEN_BRACE_in_array_literal2672 = new BitSet(new long[]{0xF4795CC200C2CD50L,0x000000000020FB16L,0x65A0EC0000000000L,0x0000000000000036L}); 14789 public static final BitSet FOLLOW_literal_in_array_literal2675 = new BitSet(new long[]{0x0000000000120000L}); 14790 public static final BitSet FOLLOW_COMMA_in_array_literal2678 = new BitSet(new long[]{0xF4795CC200C0CD50L,0x000000000020FB16L,0x65A0EC0000000000L,0x0000000000000036L}); 14791 public static final BitSet FOLLOW_literal_in_array_literal2680 = new BitSet(new long[]{0x0000000000120000L}); 14792 public static final BitSet FOLLOW_CLOSE_BRACE_in_array_literal2688 = new BitSet(new long[]{0x0000000000000002L}); 14793 public static final BitSet FOLLOW_simple_name_in_annotation_element2712 = new BitSet(new long[]{0x0000000800000000L}); 14794 public static final BitSet FOLLOW_EQUAL_in_annotation_element2714 = new BitSet(new long[]{0xF4795CC200C0CD50L,0x000000000020FB16L,0x65A0EC0000000000L,0x0000000000000036L}); 14795 public static final BitSet FOLLOW_literal_in_annotation_element2716 = new BitSet(new long[]{0x0000000000000002L}); 14796 public static final BitSet FOLLOW_ANNOTATION_DIRECTIVE_in_annotation2741 = new BitSet(new long[]{0x0000000000000040L}); 14797 public static final BitSet FOLLOW_ANNOTATION_VISIBILITY_in_annotation2743 = new BitSet(new long[]{0x0000000000008000L}); 14798 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_annotation2745 = new BitSet(new long[]{0xF4795C8001800450L,0x000000000020FB16L,0x45A0600000000000L,0x0000000000000030L}); 14799 public static final BitSet FOLLOW_annotation_element_in_annotation2751 = new BitSet(new long[]{0xF4795C8001800450L,0x000000000020FB16L,0x45A0600000000000L,0x0000000000000030L}); 14800 public static final BitSet FOLLOW_END_ANNOTATION_DIRECTIVE_in_annotation2754 = new BitSet(new long[]{0x0000000000000002L}); 14801 public static final BitSet FOLLOW_SUBANNOTATION_DIRECTIVE_in_subannotation2787 = new BitSet(new long[]{0x0000000000008000L}); 14802 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_subannotation2789 = new BitSet(new long[]{0xF4795C8100800450L,0x000000000020FB16L,0x45A0600000000000L,0x0000000000000030L}); 14803 public static final BitSet FOLLOW_annotation_element_in_subannotation2791 = new BitSet(new long[]{0xF4795C8100800450L,0x000000000020FB16L,0x45A0600000000000L,0x0000000000000030L}); 14804 public static final BitSet FOLLOW_END_SUBANNOTATION_DIRECTIVE_in_subannotation2794 = new BitSet(new long[]{0x0000000000000002L}); 14805 public static final BitSet FOLLOW_ENUM_DIRECTIVE_in_enum_literal2820 = new BitSet(new long[]{0x0000000000008100L}); 14806 public static final BitSet FOLLOW_reference_type_descriptor_in_enum_literal2822 = new BitSet(new long[]{0x0000000000000200L}); 14807 public static final BitSet FOLLOW_ARROW_in_enum_literal2824 = new BitSet(new long[]{0xF4795C8000800450L,0x000000000020FB16L,0x45A0600000000000L,0x0000000000000030L}); 14808 public static final BitSet FOLLOW_simple_name_in_enum_literal2826 = new BitSet(new long[]{0x0000000000080000L}); 14809 public static final BitSet FOLLOW_COLON_in_enum_literal2828 = new BitSet(new long[]{0x0000000000008100L}); 14810 public static final BitSet FOLLOW_reference_type_descriptor_in_enum_literal2830 = new BitSet(new long[]{0x0000000000000002L}); 14811 public static final BitSet FOLLOW_reference_type_descriptor_in_type_field_method_literal2854 = new BitSet(new long[]{0x0000000000000002L}); 14812 public static final BitSet FOLLOW_reference_type_descriptor_in_type_field_method_literal2863 = new BitSet(new long[]{0x0000000000000200L}); 14813 public static final BitSet FOLLOW_ARROW_in_type_field_method_literal2865 = new BitSet(new long[]{0xF4795C8000800450L,0x000000000020FB16L,0x45A0680000000000L,0x0000000000000030L}); 14814 public static final BitSet FOLLOW_member_name_in_type_field_method_literal2877 = new BitSet(new long[]{0x0000000000080000L}); 14815 public static final BitSet FOLLOW_COLON_in_type_field_method_literal2879 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0100000000000000L}); 14816 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_type_field_method_literal2881 = new BitSet(new long[]{0x0000000000000002L}); 14817 public static final BitSet FOLLOW_member_name_in_type_field_method_literal2904 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0001000000000000L}); 14818 public static final BitSet FOLLOW_method_prototype_in_type_field_method_literal2906 = new BitSet(new long[]{0x0000000000000002L}); 14819 public static final BitSet FOLLOW_PRIMITIVE_TYPE_in_type_field_method_literal2939 = new BitSet(new long[]{0x0000000000000002L}); 14820 public static final BitSet FOLLOW_VOID_TYPE_in_type_field_method_literal2945 = new BitSet(new long[]{0x0000000000000002L}); 14821 public static final BitSet FOLLOW_reference_type_descriptor_in_method_reference2956 = new BitSet(new long[]{0x0000000000000200L}); 14822 public static final BitSet FOLLOW_ARROW_in_method_reference2958 = new BitSet(new long[]{0xF4795C8000800450L,0x000000000020FB16L,0x45A0680000000000L,0x0000000000000030L}); 14823 public static final BitSet FOLLOW_member_name_in_method_reference2962 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0001000000000000L}); 14824 public static final BitSet FOLLOW_method_prototype_in_method_reference2964 = new BitSet(new long[]{0x0000000000000002L}); 14825 public static final BitSet FOLLOW_reference_type_descriptor_in_field_reference2986 = new BitSet(new long[]{0x0000000000000200L}); 14826 public static final BitSet FOLLOW_ARROW_in_field_reference2988 = new BitSet(new long[]{0xF4795C8000800450L,0x000000000020FB16L,0x45A0680000000000L,0x0000000000000030L}); 14827 public static final BitSet FOLLOW_member_name_in_field_reference2992 = new BitSet(new long[]{0x0000000000080000L}); 14828 public static final BitSet FOLLOW_COLON_in_field_reference2994 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0100000000000000L}); 14829 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_field_reference2996 = new BitSet(new long[]{0x0000000000000002L}); 14830 public static final BitSet FOLLOW_COLON_in_label3017 = new BitSet(new long[]{0xF4795C8000800450L,0x000000000020FB16L,0x45A0600000000000L,0x0000000000000030L}); 14831 public static final BitSet FOLLOW_simple_name_in_label3019 = new BitSet(new long[]{0x0000000000000002L}); 14832 public static final BitSet FOLLOW_COLON_in_label_ref3038 = new BitSet(new long[]{0xF4795C8000800450L,0x000000000020FB16L,0x45A0600000000000L,0x0000000000000030L}); 14833 public static final BitSet FOLLOW_simple_name_in_label_ref3040 = new BitSet(new long[]{0x0000000000000002L}); 14834 public static final BitSet FOLLOW_REGISTER_in_register_list3054 = new BitSet(new long[]{0x0000000000100002L}); 14835 public static final BitSet FOLLOW_COMMA_in_register_list3057 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 14836 public static final BitSet FOLLOW_REGISTER_in_register_list3059 = new BitSet(new long[]{0x0000000000100002L}); 14837 public static final BitSet FOLLOW_REGISTER_in_register_range3094 = new BitSet(new long[]{0x0000000000200002L}); 14838 public static final BitSet FOLLOW_DOTDOT_in_register_range3097 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 14839 public static final BitSet FOLLOW_REGISTER_in_register_range3101 = new BitSet(new long[]{0x0000000000000002L}); 14840 public static final BitSet FOLLOW_CLASS_DESCRIPTOR_in_verification_error_reference3130 = new BitSet(new long[]{0x0000000000000002L}); 14841 public static final BitSet FOLLOW_field_reference_in_verification_error_reference3134 = new BitSet(new long[]{0x0000000000000002L}); 14842 public static final BitSet FOLLOW_method_reference_in_verification_error_reference3138 = new BitSet(new long[]{0x0000000000000002L}); 14843 public static final BitSet FOLLOW_CATCH_DIRECTIVE_in_catch_directive3148 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0100000000000000L}); 14844 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_catch_directive3150 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000800000000000L}); 14845 public static final BitSet FOLLOW_OPEN_BRACE_in_catch_directive3152 = new BitSet(new long[]{0x0000000000080000L}); 14846 public static final BitSet FOLLOW_label_ref_in_catch_directive3156 = new BitSet(new long[]{0x0000000000200000L}); 14847 public static final BitSet FOLLOW_DOTDOT_in_catch_directive3158 = new BitSet(new long[]{0x0000000000080000L}); 14848 public static final BitSet FOLLOW_label_ref_in_catch_directive3162 = new BitSet(new long[]{0x0000000000020000L}); 14849 public static final BitSet FOLLOW_CLOSE_BRACE_in_catch_directive3164 = new BitSet(new long[]{0x0000000000080000L}); 14850 public static final BitSet FOLLOW_label_ref_in_catch_directive3168 = new BitSet(new long[]{0x0000000000000002L}); 14851 public static final BitSet FOLLOW_CATCHALL_DIRECTIVE_in_catchall_directive3200 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000800000000000L}); 14852 public static final BitSet FOLLOW_OPEN_BRACE_in_catchall_directive3202 = new BitSet(new long[]{0x0000000000080000L}); 14853 public static final BitSet FOLLOW_label_ref_in_catchall_directive3206 = new BitSet(new long[]{0x0000000000200000L}); 14854 public static final BitSet FOLLOW_DOTDOT_in_catchall_directive3208 = new BitSet(new long[]{0x0000000000080000L}); 14855 public static final BitSet FOLLOW_label_ref_in_catchall_directive3212 = new BitSet(new long[]{0x0000000000020000L}); 14856 public static final BitSet FOLLOW_CLOSE_BRACE_in_catchall_directive3214 = new BitSet(new long[]{0x0000000000080000L}); 14857 public static final BitSet FOLLOW_label_ref_in_catchall_directive3218 = new BitSet(new long[]{0x0000000000000002L}); 14858 public static final BitSet FOLLOW_PARAMETER_DIRECTIVE_in_parameter_directive3257 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 14859 public static final BitSet FOLLOW_REGISTER_in_parameter_directive3259 = new BitSet(new long[]{0x0000000040100022L}); 14860 public static final BitSet FOLLOW_COMMA_in_parameter_directive3262 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000002L}); 14861 public static final BitSet FOLLOW_STRING_LITERAL_in_parameter_directive3264 = new BitSet(new long[]{0x0000000040000022L}); 14862 public static final BitSet FOLLOW_annotation_in_parameter_directive3275 = new BitSet(new long[]{0x0000000040000022L}); 14863 public static final BitSet FOLLOW_END_PARAMETER_DIRECTIVE_in_parameter_directive3288 = new BitSet(new long[]{0x0000000000000002L}); 14864 public static final BitSet FOLLOW_line_directive_in_debug_directive3361 = new BitSet(new long[]{0x0000000000000002L}); 14865 public static final BitSet FOLLOW_local_directive_in_debug_directive3367 = new BitSet(new long[]{0x0000000000000002L}); 14866 public static final BitSet FOLLOW_end_local_directive_in_debug_directive3373 = new BitSet(new long[]{0x0000000000000002L}); 14867 public static final BitSet FOLLOW_restart_local_directive_in_debug_directive3379 = new BitSet(new long[]{0x0000000000000002L}); 14868 public static final BitSet FOLLOW_prologue_directive_in_debug_directive3385 = new BitSet(new long[]{0x0000000000000002L}); 14869 public static final BitSet FOLLOW_epilogue_directive_in_debug_directive3391 = new BitSet(new long[]{0x0000000000000002L}); 14870 public static final BitSet FOLLOW_source_directive_in_debug_directive3397 = new BitSet(new long[]{0x0000000000000002L}); 14871 public static final BitSet FOLLOW_LINE_DIRECTIVE_in_line_directive3407 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x2080240000000000L}); 14872 public static final BitSet FOLLOW_integral_literal_in_line_directive3409 = new BitSet(new long[]{0x0000000000000002L}); 14873 public static final BitSet FOLLOW_LOCAL_DIRECTIVE_in_local_directive3432 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 14874 public static final BitSet FOLLOW_REGISTER_in_local_directive3434 = new BitSet(new long[]{0x0000000000100002L}); 14875 public static final BitSet FOLLOW_COMMA_in_local_directive3437 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000400000000000L,0x0000000000000002L}); 14876 public static final BitSet FOLLOW_NULL_LITERAL_in_local_directive3440 = new BitSet(new long[]{0x0000000000080000L}); 14877 public static final BitSet FOLLOW_STRING_LITERAL_in_local_directive3446 = new BitSet(new long[]{0x0000000000080000L}); 14878 public static final BitSet FOLLOW_COLON_in_local_directive3449 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0100000000000000L,0x0000000000000020L}); 14879 public static final BitSet FOLLOW_VOID_TYPE_in_local_directive3452 = new BitSet(new long[]{0x0000000000100002L}); 14880 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_local_directive3456 = new BitSet(new long[]{0x0000000000100002L}); 14881 public static final BitSet FOLLOW_COMMA_in_local_directive3490 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000002L}); 14882 public static final BitSet FOLLOW_STRING_LITERAL_in_local_directive3494 = new BitSet(new long[]{0x0000000000000002L}); 14883 public static final BitSet FOLLOW_END_LOCAL_DIRECTIVE_in_end_local_directive3536 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 14884 public static final BitSet FOLLOW_REGISTER_in_end_local_directive3538 = new BitSet(new long[]{0x0000000000000002L}); 14885 public static final BitSet FOLLOW_RESTART_LOCAL_DIRECTIVE_in_restart_local_directive3561 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 14886 public static final BitSet FOLLOW_REGISTER_in_restart_local_directive3563 = new BitSet(new long[]{0x0000000000000002L}); 14887 public static final BitSet FOLLOW_PROLOGUE_DIRECTIVE_in_prologue_directive3586 = new BitSet(new long[]{0x0000000000000002L}); 14888 public static final BitSet FOLLOW_EPILOGUE_DIRECTIVE_in_epilogue_directive3607 = new BitSet(new long[]{0x0000000000000002L}); 14889 public static final BitSet FOLLOW_SOURCE_DIRECTIVE_in_source_directive3628 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000000002L}); 14890 public static final BitSet FOLLOW_STRING_LITERAL_in_source_directive3630 = new BitSet(new long[]{0x0000000000000002L}); 14891 public static final BitSet FOLLOW_INSTRUCTION_FORMAT12x_in_instruction_format12x3655 = new BitSet(new long[]{0x0000000000000002L}); 14892 public static final BitSet FOLLOW_INSTRUCTION_FORMAT12x_OR_ID_in_instruction_format12x3661 = new BitSet(new long[]{0x0000000000000002L}); 14893 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22s_in_instruction_format22s3676 = new BitSet(new long[]{0x0000000000000002L}); 14894 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22s_OR_ID_in_instruction_format22s3682 = new BitSet(new long[]{0x0000000000000002L}); 14895 public static final BitSet FOLLOW_INSTRUCTION_FORMAT31i_in_instruction_format31i3697 = new BitSet(new long[]{0x0000000000000002L}); 14896 public static final BitSet FOLLOW_INSTRUCTION_FORMAT31i_OR_ID_in_instruction_format31i3703 = new BitSet(new long[]{0x0000000000000002L}); 14897 public static final BitSet FOLLOW_insn_format10t_in_instruction3720 = new BitSet(new long[]{0x0000000000000002L}); 14898 public static final BitSet FOLLOW_insn_format10x_in_instruction3726 = new BitSet(new long[]{0x0000000000000002L}); 14899 public static final BitSet FOLLOW_insn_format10x_odex_in_instruction3732 = new BitSet(new long[]{0x0000000000000002L}); 14900 public static final BitSet FOLLOW_insn_format11n_in_instruction3738 = new BitSet(new long[]{0x0000000000000002L}); 14901 public static final BitSet FOLLOW_insn_format11x_in_instruction3744 = new BitSet(new long[]{0x0000000000000002L}); 14902 public static final BitSet FOLLOW_insn_format12x_in_instruction3750 = new BitSet(new long[]{0x0000000000000002L}); 14903 public static final BitSet FOLLOW_insn_format20bc_in_instruction3756 = new BitSet(new long[]{0x0000000000000002L}); 14904 public static final BitSet FOLLOW_insn_format20t_in_instruction3762 = new BitSet(new long[]{0x0000000000000002L}); 14905 public static final BitSet FOLLOW_insn_format21c_field_in_instruction3768 = new BitSet(new long[]{0x0000000000000002L}); 14906 public static final BitSet FOLLOW_insn_format21c_field_odex_in_instruction3774 = new BitSet(new long[]{0x0000000000000002L}); 14907 public static final BitSet FOLLOW_insn_format21c_string_in_instruction3780 = new BitSet(new long[]{0x0000000000000002L}); 14908 public static final BitSet FOLLOW_insn_format21c_type_in_instruction3786 = new BitSet(new long[]{0x0000000000000002L}); 14909 public static final BitSet FOLLOW_insn_format21ih_in_instruction3792 = new BitSet(new long[]{0x0000000000000002L}); 14910 public static final BitSet FOLLOW_insn_format21lh_in_instruction3798 = new BitSet(new long[]{0x0000000000000002L}); 14911 public static final BitSet FOLLOW_insn_format21s_in_instruction3804 = new BitSet(new long[]{0x0000000000000002L}); 14912 public static final BitSet FOLLOW_insn_format21t_in_instruction3810 = new BitSet(new long[]{0x0000000000000002L}); 14913 public static final BitSet FOLLOW_insn_format22b_in_instruction3816 = new BitSet(new long[]{0x0000000000000002L}); 14914 public static final BitSet FOLLOW_insn_format22c_field_in_instruction3822 = new BitSet(new long[]{0x0000000000000002L}); 14915 public static final BitSet FOLLOW_insn_format22c_field_odex_in_instruction3828 = new BitSet(new long[]{0x0000000000000002L}); 14916 public static final BitSet FOLLOW_insn_format22c_type_in_instruction3834 = new BitSet(new long[]{0x0000000000000002L}); 14917 public static final BitSet FOLLOW_insn_format22cs_field_in_instruction3840 = new BitSet(new long[]{0x0000000000000002L}); 14918 public static final BitSet FOLLOW_insn_format22s_in_instruction3846 = new BitSet(new long[]{0x0000000000000002L}); 14919 public static final BitSet FOLLOW_insn_format22t_in_instruction3852 = new BitSet(new long[]{0x0000000000000002L}); 14920 public static final BitSet FOLLOW_insn_format22x_in_instruction3858 = new BitSet(new long[]{0x0000000000000002L}); 14921 public static final BitSet FOLLOW_insn_format23x_in_instruction3864 = new BitSet(new long[]{0x0000000000000002L}); 14922 public static final BitSet FOLLOW_insn_format30t_in_instruction3870 = new BitSet(new long[]{0x0000000000000002L}); 14923 public static final BitSet FOLLOW_insn_format31c_in_instruction3876 = new BitSet(new long[]{0x0000000000000002L}); 14924 public static final BitSet FOLLOW_insn_format31i_in_instruction3882 = new BitSet(new long[]{0x0000000000000002L}); 14925 public static final BitSet FOLLOW_insn_format31t_in_instruction3888 = new BitSet(new long[]{0x0000000000000002L}); 14926 public static final BitSet FOLLOW_insn_format32x_in_instruction3894 = new BitSet(new long[]{0x0000000000000002L}); 14927 public static final BitSet FOLLOW_insn_format35c_method_in_instruction3900 = new BitSet(new long[]{0x0000000000000002L}); 14928 public static final BitSet FOLLOW_insn_format35c_type_in_instruction3906 = new BitSet(new long[]{0x0000000000000002L}); 14929 public static final BitSet FOLLOW_insn_format35c_method_odex_in_instruction3912 = new BitSet(new long[]{0x0000000000000002L}); 14930 public static final BitSet FOLLOW_insn_format35mi_method_in_instruction3918 = new BitSet(new long[]{0x0000000000000002L}); 14931 public static final BitSet FOLLOW_insn_format35ms_method_in_instruction3924 = new BitSet(new long[]{0x0000000000000002L}); 14932 public static final BitSet FOLLOW_insn_format3rc_method_in_instruction3930 = new BitSet(new long[]{0x0000000000000002L}); 14933 public static final BitSet FOLLOW_insn_format3rc_method_odex_in_instruction3936 = new BitSet(new long[]{0x0000000000000002L}); 14934 public static final BitSet FOLLOW_insn_format3rc_type_in_instruction3942 = new BitSet(new long[]{0x0000000000000002L}); 14935 public static final BitSet FOLLOW_insn_format3rmi_method_in_instruction3948 = new BitSet(new long[]{0x0000000000000002L}); 14936 public static final BitSet FOLLOW_insn_format3rms_method_in_instruction3954 = new BitSet(new long[]{0x0000000000000002L}); 14937 public static final BitSet FOLLOW_insn_format51l_in_instruction3960 = new BitSet(new long[]{0x0000000000000002L}); 14938 public static final BitSet FOLLOW_insn_array_data_directive_in_instruction3966 = new BitSet(new long[]{0x0000000000000002L}); 14939 public static final BitSet FOLLOW_insn_packed_switch_directive_in_instruction3972 = new BitSet(new long[]{0x0000000000000002L}); 14940 public static final BitSet FOLLOW_insn_sparse_switch_directive_in_instruction3978 = new BitSet(new long[]{0x0000000000000002L}); 14941 public static final BitSet FOLLOW_INSTRUCTION_FORMAT10t_in_insn_format10t3998 = new BitSet(new long[]{0x0000000000080000L}); 14942 public static final BitSet FOLLOW_label_ref_in_insn_format10t4000 = new BitSet(new long[]{0x0000000000000002L}); 14943 public static final BitSet FOLLOW_INSTRUCTION_FORMAT10x_in_insn_format10x4030 = new BitSet(new long[]{0x0000000000000002L}); 14944 public static final BitSet FOLLOW_INSTRUCTION_FORMAT10x_ODEX_in_insn_format10x_odex4058 = new BitSet(new long[]{0x0000000000000002L}); 14945 public static final BitSet FOLLOW_INSTRUCTION_FORMAT11n_in_insn_format11n4079 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 14946 public static final BitSet FOLLOW_REGISTER_in_insn_format11n4081 = new BitSet(new long[]{0x0000000000100000L}); 14947 public static final BitSet FOLLOW_COMMA_in_insn_format11n4083 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x2080240000000000L}); 14948 public static final BitSet FOLLOW_integral_literal_in_insn_format11n4085 = new BitSet(new long[]{0x0000000000000002L}); 14949 public static final BitSet FOLLOW_INSTRUCTION_FORMAT11x_in_insn_format11x4117 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 14950 public static final BitSet FOLLOW_REGISTER_in_insn_format11x4119 = new BitSet(new long[]{0x0000000000000002L}); 14951 public static final BitSet FOLLOW_instruction_format12x_in_insn_format12x4149 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 14952 public static final BitSet FOLLOW_REGISTER_in_insn_format12x4151 = new BitSet(new long[]{0x0000000000100000L}); 14953 public static final BitSet FOLLOW_COMMA_in_insn_format12x4153 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 14954 public static final BitSet FOLLOW_REGISTER_in_insn_format12x4155 = new BitSet(new long[]{0x0000000000000002L}); 14955 public static final BitSet FOLLOW_INSTRUCTION_FORMAT20bc_in_insn_format20bc4187 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000010L}); 14956 public static final BitSet FOLLOW_VERIFICATION_ERROR_TYPE_in_insn_format20bc4189 = new BitSet(new long[]{0x0000000000100000L}); 14957 public static final BitSet FOLLOW_COMMA_in_insn_format20bc4191 = new BitSet(new long[]{0xF4795C8000808550L,0x000000000020FB16L,0x45A0680000000000L,0x0000000000000030L}); 14958 public static final BitSet FOLLOW_verification_error_reference_in_insn_format20bc4193 = new BitSet(new long[]{0x0000000000000002L}); 14959 public static final BitSet FOLLOW_INSTRUCTION_FORMAT20t_in_insn_format20t4230 = new BitSet(new long[]{0x0000000000080000L}); 14960 public static final BitSet FOLLOW_label_ref_in_insn_format20t4232 = new BitSet(new long[]{0x0000000000000002L}); 14961 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_FIELD_in_insn_format21c_field4262 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 14962 public static final BitSet FOLLOW_REGISTER_in_insn_format21c_field4264 = new BitSet(new long[]{0x0000000000100000L}); 14963 public static final BitSet FOLLOW_COMMA_in_insn_format21c_field4266 = new BitSet(new long[]{0xF4795C8000808550L,0x000000000020FB16L,0x45A0680000000000L,0x0000000000000030L}); 14964 public static final BitSet FOLLOW_field_reference_in_insn_format21c_field4268 = new BitSet(new long[]{0x0000000000000002L}); 14965 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_FIELD_ODEX_in_insn_format21c_field_odex4300 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 14966 public static final BitSet FOLLOW_REGISTER_in_insn_format21c_field_odex4302 = new BitSet(new long[]{0x0000000000100000L}); 14967 public static final BitSet FOLLOW_COMMA_in_insn_format21c_field_odex4304 = new BitSet(new long[]{0xF4795C8000808550L,0x000000000020FB16L,0x45A0680000000000L,0x0000000000000030L}); 14968 public static final BitSet FOLLOW_field_reference_in_insn_format21c_field_odex4306 = new BitSet(new long[]{0x0000000000000002L}); 14969 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_STRING_in_insn_format21c_string4344 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 14970 public static final BitSet FOLLOW_REGISTER_in_insn_format21c_string4346 = new BitSet(new long[]{0x0000000000100000L}); 14971 public static final BitSet FOLLOW_COMMA_in_insn_format21c_string4348 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000002L}); 14972 public static final BitSet FOLLOW_STRING_LITERAL_in_insn_format21c_string4350 = new BitSet(new long[]{0x0000000000000002L}); 14973 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21c_TYPE_in_insn_format21c_type4382 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 14974 public static final BitSet FOLLOW_REGISTER_in_insn_format21c_type4384 = new BitSet(new long[]{0x0000000000100000L}); 14975 public static final BitSet FOLLOW_COMMA_in_insn_format21c_type4386 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0100000000000000L}); 14976 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_insn_format21c_type4388 = new BitSet(new long[]{0x0000000000000002L}); 14977 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21ih_in_insn_format21ih4420 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 14978 public static final BitSet FOLLOW_REGISTER_in_insn_format21ih4422 = new BitSet(new long[]{0x0000000000100000L}); 14979 public static final BitSet FOLLOW_COMMA_in_insn_format21ih4424 = new BitSet(new long[]{0x000000C000004C00L,0x0000000000000000L,0x2080240000000000L}); 14980 public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_format21ih4426 = new BitSet(new long[]{0x0000000000000002L}); 14981 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21lh_in_insn_format21lh4458 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 14982 public static final BitSet FOLLOW_REGISTER_in_insn_format21lh4460 = new BitSet(new long[]{0x0000000000100000L}); 14983 public static final BitSet FOLLOW_COMMA_in_insn_format21lh4462 = new BitSet(new long[]{0x000000C000004C00L,0x0000000000000000L,0x2080240000000000L}); 14984 public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_format21lh4464 = new BitSet(new long[]{0x0000000000000002L}); 14985 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21s_in_insn_format21s4496 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 14986 public static final BitSet FOLLOW_REGISTER_in_insn_format21s4498 = new BitSet(new long[]{0x0000000000100000L}); 14987 public static final BitSet FOLLOW_COMMA_in_insn_format21s4500 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x2080240000000000L}); 14988 public static final BitSet FOLLOW_integral_literal_in_insn_format21s4502 = new BitSet(new long[]{0x0000000000000002L}); 14989 public static final BitSet FOLLOW_INSTRUCTION_FORMAT21t_in_insn_format21t4534 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 14990 public static final BitSet FOLLOW_REGISTER_in_insn_format21t4536 = new BitSet(new long[]{0x0000000000100000L}); 14991 public static final BitSet FOLLOW_COMMA_in_insn_format21t4538 = new BitSet(new long[]{0x0000000000080000L}); 14992 public static final BitSet FOLLOW_label_ref_in_insn_format21t4540 = new BitSet(new long[]{0x0000000000000002L}); 14993 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22b_in_insn_format22b4572 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 14994 public static final BitSet FOLLOW_REGISTER_in_insn_format22b4574 = new BitSet(new long[]{0x0000000000100000L}); 14995 public static final BitSet FOLLOW_COMMA_in_insn_format22b4576 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 14996 public static final BitSet FOLLOW_REGISTER_in_insn_format22b4578 = new BitSet(new long[]{0x0000000000100000L}); 14997 public static final BitSet FOLLOW_COMMA_in_insn_format22b4580 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x2080240000000000L}); 14998 public static final BitSet FOLLOW_integral_literal_in_insn_format22b4582 = new BitSet(new long[]{0x0000000000000002L}); 14999 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_FIELD_in_insn_format22c_field4616 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 15000 public static final BitSet FOLLOW_REGISTER_in_insn_format22c_field4618 = new BitSet(new long[]{0x0000000000100000L}); 15001 public static final BitSet FOLLOW_COMMA_in_insn_format22c_field4620 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 15002 public static final BitSet FOLLOW_REGISTER_in_insn_format22c_field4622 = new BitSet(new long[]{0x0000000000100000L}); 15003 public static final BitSet FOLLOW_COMMA_in_insn_format22c_field4624 = new BitSet(new long[]{0xF4795C8000808550L,0x000000000020FB16L,0x45A0680000000000L,0x0000000000000030L}); 15004 public static final BitSet FOLLOW_field_reference_in_insn_format22c_field4626 = new BitSet(new long[]{0x0000000000000002L}); 15005 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_FIELD_ODEX_in_insn_format22c_field_odex4660 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 15006 public static final BitSet FOLLOW_REGISTER_in_insn_format22c_field_odex4662 = new BitSet(new long[]{0x0000000000100000L}); 15007 public static final BitSet FOLLOW_COMMA_in_insn_format22c_field_odex4664 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 15008 public static final BitSet FOLLOW_REGISTER_in_insn_format22c_field_odex4666 = new BitSet(new long[]{0x0000000000100000L}); 15009 public static final BitSet FOLLOW_COMMA_in_insn_format22c_field_odex4668 = new BitSet(new long[]{0xF4795C8000808550L,0x000000000020FB16L,0x45A0680000000000L,0x0000000000000030L}); 15010 public static final BitSet FOLLOW_field_reference_in_insn_format22c_field_odex4670 = new BitSet(new long[]{0x0000000000000002L}); 15011 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22c_TYPE_in_insn_format22c_type4710 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 15012 public static final BitSet FOLLOW_REGISTER_in_insn_format22c_type4712 = new BitSet(new long[]{0x0000000000100000L}); 15013 public static final BitSet FOLLOW_COMMA_in_insn_format22c_type4714 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 15014 public static final BitSet FOLLOW_REGISTER_in_insn_format22c_type4716 = new BitSet(new long[]{0x0000000000100000L}); 15015 public static final BitSet FOLLOW_COMMA_in_insn_format22c_type4718 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0100000000000000L}); 15016 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_insn_format22c_type4720 = new BitSet(new long[]{0x0000000000000002L}); 15017 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22cs_FIELD_in_insn_format22cs_field4754 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 15018 public static final BitSet FOLLOW_REGISTER_in_insn_format22cs_field4756 = new BitSet(new long[]{0x0000000000100000L}); 15019 public static final BitSet FOLLOW_COMMA_in_insn_format22cs_field4758 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 15020 public static final BitSet FOLLOW_REGISTER_in_insn_format22cs_field4760 = new BitSet(new long[]{0x0000000000100000L}); 15021 public static final BitSet FOLLOW_COMMA_in_insn_format22cs_field4762 = new BitSet(new long[]{0x0000002000000000L}); 15022 public static final BitSet FOLLOW_FIELD_OFFSET_in_insn_format22cs_field4764 = new BitSet(new long[]{0x0000000000000002L}); 15023 public static final BitSet FOLLOW_instruction_format22s_in_insn_format22s4785 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 15024 public static final BitSet FOLLOW_REGISTER_in_insn_format22s4787 = new BitSet(new long[]{0x0000000000100000L}); 15025 public static final BitSet FOLLOW_COMMA_in_insn_format22s4789 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 15026 public static final BitSet FOLLOW_REGISTER_in_insn_format22s4791 = new BitSet(new long[]{0x0000000000100000L}); 15027 public static final BitSet FOLLOW_COMMA_in_insn_format22s4793 = new BitSet(new long[]{0x0000000000004800L,0x0000000000000000L,0x2080240000000000L}); 15028 public static final BitSet FOLLOW_integral_literal_in_insn_format22s4795 = new BitSet(new long[]{0x0000000000000002L}); 15029 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22t_in_insn_format22t4829 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 15030 public static final BitSet FOLLOW_REGISTER_in_insn_format22t4831 = new BitSet(new long[]{0x0000000000100000L}); 15031 public static final BitSet FOLLOW_COMMA_in_insn_format22t4833 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 15032 public static final BitSet FOLLOW_REGISTER_in_insn_format22t4835 = new BitSet(new long[]{0x0000000000100000L}); 15033 public static final BitSet FOLLOW_COMMA_in_insn_format22t4837 = new BitSet(new long[]{0x0000000000080000L}); 15034 public static final BitSet FOLLOW_label_ref_in_insn_format22t4839 = new BitSet(new long[]{0x0000000000000002L}); 15035 public static final BitSet FOLLOW_INSTRUCTION_FORMAT22x_in_insn_format22x4873 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 15036 public static final BitSet FOLLOW_REGISTER_in_insn_format22x4875 = new BitSet(new long[]{0x0000000000100000L}); 15037 public static final BitSet FOLLOW_COMMA_in_insn_format22x4877 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 15038 public static final BitSet FOLLOW_REGISTER_in_insn_format22x4879 = new BitSet(new long[]{0x0000000000000002L}); 15039 public static final BitSet FOLLOW_INSTRUCTION_FORMAT23x_in_insn_format23x4911 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 15040 public static final BitSet FOLLOW_REGISTER_in_insn_format23x4913 = new BitSet(new long[]{0x0000000000100000L}); 15041 public static final BitSet FOLLOW_COMMA_in_insn_format23x4915 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 15042 public static final BitSet FOLLOW_REGISTER_in_insn_format23x4917 = new BitSet(new long[]{0x0000000000100000L}); 15043 public static final BitSet FOLLOW_COMMA_in_insn_format23x4919 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 15044 public static final BitSet FOLLOW_REGISTER_in_insn_format23x4921 = new BitSet(new long[]{0x0000000000000002L}); 15045 public static final BitSet FOLLOW_INSTRUCTION_FORMAT30t_in_insn_format30t4955 = new BitSet(new long[]{0x0000000000080000L}); 15046 public static final BitSet FOLLOW_label_ref_in_insn_format30t4957 = new BitSet(new long[]{0x0000000000000002L}); 15047 public static final BitSet FOLLOW_INSTRUCTION_FORMAT31c_in_insn_format31c4987 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 15048 public static final BitSet FOLLOW_REGISTER_in_insn_format31c4989 = new BitSet(new long[]{0x0000000000100000L}); 15049 public static final BitSet FOLLOW_COMMA_in_insn_format31c4991 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000002L}); 15050 public static final BitSet FOLLOW_STRING_LITERAL_in_insn_format31c4993 = new BitSet(new long[]{0x0000000000000002L}); 15051 public static final BitSet FOLLOW_instruction_format31i_in_insn_format31i5024 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 15052 public static final BitSet FOLLOW_REGISTER_in_insn_format31i5026 = new BitSet(new long[]{0x0000000000100000L}); 15053 public static final BitSet FOLLOW_COMMA_in_insn_format31i5028 = new BitSet(new long[]{0x000000C000004C00L,0x0000000000000000L,0x2080240000000000L}); 15054 public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_format31i5030 = new BitSet(new long[]{0x0000000000000002L}); 15055 public static final BitSet FOLLOW_INSTRUCTION_FORMAT31t_in_insn_format31t5062 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 15056 public static final BitSet FOLLOW_REGISTER_in_insn_format31t5064 = new BitSet(new long[]{0x0000000000100000L}); 15057 public static final BitSet FOLLOW_COMMA_in_insn_format31t5066 = new BitSet(new long[]{0x0000000000080000L}); 15058 public static final BitSet FOLLOW_label_ref_in_insn_format31t5068 = new BitSet(new long[]{0x0000000000000002L}); 15059 public static final BitSet FOLLOW_INSTRUCTION_FORMAT32x_in_insn_format32x5100 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 15060 public static final BitSet FOLLOW_REGISTER_in_insn_format32x5102 = new BitSet(new long[]{0x0000000000100000L}); 15061 public static final BitSet FOLLOW_COMMA_in_insn_format32x5104 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 15062 public static final BitSet FOLLOW_REGISTER_in_insn_format32x5106 = new BitSet(new long[]{0x0000000000000002L}); 15063 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_METHOD_in_insn_format35c_method5138 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000800000000000L}); 15064 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format35c_method5140 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0400000000000000L}); 15065 public static final BitSet FOLLOW_register_list_in_insn_format35c_method5142 = new BitSet(new long[]{0x0000000000020000L}); 15066 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format35c_method5144 = new BitSet(new long[]{0x0000000000100000L}); 15067 public static final BitSet FOLLOW_COMMA_in_insn_format35c_method5146 = new BitSet(new long[]{0xF4795C8000808550L,0x000000000020FB16L,0x45A0680000000000L,0x0000000000000030L}); 15068 public static final BitSet FOLLOW_method_reference_in_insn_format35c_method5148 = new BitSet(new long[]{0x0000000000000002L}); 15069 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_TYPE_in_insn_format35c_type5180 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000800000000000L}); 15070 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format35c_type5182 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0400000000000000L}); 15071 public static final BitSet FOLLOW_register_list_in_insn_format35c_type5184 = new BitSet(new long[]{0x0000000000020000L}); 15072 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format35c_type5186 = new BitSet(new long[]{0x0000000000100000L}); 15073 public static final BitSet FOLLOW_COMMA_in_insn_format35c_type5188 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0100000000000000L}); 15074 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_insn_format35c_type5190 = new BitSet(new long[]{0x0000000000000002L}); 15075 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35c_METHOD_ODEX_in_insn_format35c_method_odex5222 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000800000000000L}); 15076 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format35c_method_odex5224 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0400000000000000L}); 15077 public static final BitSet FOLLOW_register_list_in_insn_format35c_method_odex5226 = new BitSet(new long[]{0x0000000000020000L}); 15078 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format35c_method_odex5228 = new BitSet(new long[]{0x0000000000100000L}); 15079 public static final BitSet FOLLOW_COMMA_in_insn_format35c_method_odex5230 = new BitSet(new long[]{0xF4795C8000808550L,0x000000000020FB16L,0x45A0680000000000L,0x0000000000000030L}); 15080 public static final BitSet FOLLOW_method_reference_in_insn_format35c_method_odex5232 = new BitSet(new long[]{0x0000000000000002L}); 15081 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35mi_METHOD_in_insn_format35mi_method5253 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000800000000000L}); 15082 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format35mi_method5255 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0400000000000000L}); 15083 public static final BitSet FOLLOW_register_list_in_insn_format35mi_method5257 = new BitSet(new long[]{0x0000000000020000L}); 15084 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format35mi_method5259 = new BitSet(new long[]{0x0000000000100000L}); 15085 public static final BitSet FOLLOW_COMMA_in_insn_format35mi_method5261 = new BitSet(new long[]{0x0000020000000000L}); 15086 public static final BitSet FOLLOW_INLINE_INDEX_in_insn_format35mi_method5263 = new BitSet(new long[]{0x0000000000000002L}); 15087 public static final BitSet FOLLOW_INSTRUCTION_FORMAT35ms_METHOD_in_insn_format35ms_method5284 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000800000000000L}); 15088 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format35ms_method5286 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0400000000000000L}); 15089 public static final BitSet FOLLOW_register_list_in_insn_format35ms_method5288 = new BitSet(new long[]{0x0000000000020000L}); 15090 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format35ms_method5290 = new BitSet(new long[]{0x0000000000100000L}); 15091 public static final BitSet FOLLOW_COMMA_in_insn_format35ms_method5292 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000040L}); 15092 public static final BitSet FOLLOW_VTABLE_INDEX_in_insn_format35ms_method5294 = new BitSet(new long[]{0x0000000000000002L}); 15093 public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rc_METHOD_in_insn_format3rc_method5315 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000800000000000L}); 15094 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format3rc_method5317 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0400000000000000L}); 15095 public static final BitSet FOLLOW_register_range_in_insn_format3rc_method5319 = new BitSet(new long[]{0x0000000000020000L}); 15096 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format3rc_method5321 = new BitSet(new long[]{0x0000000000100000L}); 15097 public static final BitSet FOLLOW_COMMA_in_insn_format3rc_method5323 = new BitSet(new long[]{0xF4795C8000808550L,0x000000000020FB16L,0x45A0680000000000L,0x0000000000000030L}); 15098 public static final BitSet FOLLOW_method_reference_in_insn_format3rc_method5325 = new BitSet(new long[]{0x0000000000000002L}); 15099 public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rc_METHOD_ODEX_in_insn_format3rc_method_odex5357 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000800000000000L}); 15100 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format3rc_method_odex5359 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0400000000000000L}); 15101 public static final BitSet FOLLOW_register_list_in_insn_format3rc_method_odex5361 = new BitSet(new long[]{0x0000000000020000L}); 15102 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format3rc_method_odex5363 = new BitSet(new long[]{0x0000000000100000L}); 15103 public static final BitSet FOLLOW_COMMA_in_insn_format3rc_method_odex5365 = new BitSet(new long[]{0xF4795C8000808550L,0x000000000020FB16L,0x45A0680000000000L,0x0000000000000030L}); 15104 public static final BitSet FOLLOW_method_reference_in_insn_format3rc_method_odex5367 = new BitSet(new long[]{0x0000000000000002L}); 15105 public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rc_TYPE_in_insn_format3rc_type5388 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000800000000000L}); 15106 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format3rc_type5390 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0400000000000000L}); 15107 public static final BitSet FOLLOW_register_range_in_insn_format3rc_type5392 = new BitSet(new long[]{0x0000000000020000L}); 15108 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format3rc_type5394 = new BitSet(new long[]{0x0000000000100000L}); 15109 public static final BitSet FOLLOW_COMMA_in_insn_format3rc_type5396 = new BitSet(new long[]{0x0000000000008100L,0x0000000000000000L,0x0100000000000000L}); 15110 public static final BitSet FOLLOW_nonvoid_type_descriptor_in_insn_format3rc_type5398 = new BitSet(new long[]{0x0000000000000002L}); 15111 public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rmi_METHOD_in_insn_format3rmi_method5430 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000800000000000L}); 15112 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format3rmi_method5432 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0400000000000000L}); 15113 public static final BitSet FOLLOW_register_range_in_insn_format3rmi_method5434 = new BitSet(new long[]{0x0000000000020000L}); 15114 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format3rmi_method5436 = new BitSet(new long[]{0x0000000000100000L}); 15115 public static final BitSet FOLLOW_COMMA_in_insn_format3rmi_method5438 = new BitSet(new long[]{0x0000020000000000L}); 15116 public static final BitSet FOLLOW_INLINE_INDEX_in_insn_format3rmi_method5440 = new BitSet(new long[]{0x0000000000000002L}); 15117 public static final BitSet FOLLOW_INSTRUCTION_FORMAT3rms_METHOD_in_insn_format3rms_method5461 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000800000000000L}); 15118 public static final BitSet FOLLOW_OPEN_BRACE_in_insn_format3rms_method5463 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000000L,0x0400000000000000L}); 15119 public static final BitSet FOLLOW_register_range_in_insn_format3rms_method5465 = new BitSet(new long[]{0x0000000000020000L}); 15120 public static final BitSet FOLLOW_CLOSE_BRACE_in_insn_format3rms_method5467 = new BitSet(new long[]{0x0000000000100000L}); 15121 public static final BitSet FOLLOW_COMMA_in_insn_format3rms_method5469 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000040L}); 15122 public static final BitSet FOLLOW_VTABLE_INDEX_in_insn_format3rms_method5471 = new BitSet(new long[]{0x0000000000000002L}); 15123 public static final BitSet FOLLOW_INSTRUCTION_FORMAT51l_in_insn_format51l5492 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L}); 15124 public static final BitSet FOLLOW_REGISTER_in_insn_format51l5494 = new BitSet(new long[]{0x0000000000100000L}); 15125 public static final BitSet FOLLOW_COMMA_in_insn_format51l5496 = new BitSet(new long[]{0x000000C000C04C00L,0x0000000000000000L,0x2080240000000000L}); 15126 public static final BitSet FOLLOW_fixed_literal_in_insn_format51l5498 = new BitSet(new long[]{0x0000000000000002L}); 15127 public static final BitSet FOLLOW_ARRAY_DATA_DIRECTIVE_in_insn_array_data_directive5525 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0080200000000000L}); 15128 public static final BitSet FOLLOW_parsed_integer_literal_in_insn_array_data_directive5531 = new BitSet(new long[]{0x000000C002C04C00L,0x0000000000000000L,0x2080240000000000L}); 15129 public static final BitSet FOLLOW_fixed_literal_in_insn_array_data_directive5543 = new BitSet(new long[]{0x000000C002C04C00L,0x0000000000000000L,0x2080240000000000L}); 15130 public static final BitSet FOLLOW_END_ARRAY_DATA_DIRECTIVE_in_insn_array_data_directive5546 = new BitSet(new long[]{0x0000000000000002L}); 15131 public static final BitSet FOLLOW_PACKED_SWITCH_DIRECTIVE_in_insn_packed_switch_directive5592 = new BitSet(new long[]{0x000000C000004C00L,0x0000000000000000L,0x2080240000000000L}); 15132 public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_packed_switch_directive5598 = new BitSet(new long[]{0x0000000020080000L}); 15133 public static final BitSet FOLLOW_label_ref_in_insn_packed_switch_directive5604 = new BitSet(new long[]{0x0000000020080000L}); 15134 public static final BitSet FOLLOW_END_PACKED_SWITCH_DIRECTIVE_in_insn_packed_switch_directive5611 = new BitSet(new long[]{0x0000000000000002L}); 15135 public static final BitSet FOLLOW_SPARSE_SWITCH_DIRECTIVE_in_insn_sparse_switch_directive5685 = new BitSet(new long[]{0x000000C080004C00L,0x0000000000000000L,0x2080240000000000L}); 15136 public static final BitSet FOLLOW_fixed_32bit_literal_in_insn_sparse_switch_directive5692 = new BitSet(new long[]{0x0000000000000200L}); 15137 public static final BitSet FOLLOW_ARROW_in_insn_sparse_switch_directive5694 = new BitSet(new long[]{0x0000000000080000L}); 15138 public static final BitSet FOLLOW_label_ref_in_insn_sparse_switch_directive5696 = new BitSet(new long[]{0x000000C080004C00L,0x0000000000000000L,0x2080240000000000L}); 15139 public static final BitSet FOLLOW_END_SPARSE_SWITCH_DIRECTIVE_in_insn_sparse_switch_directive5704 = new BitSet(new long[]{0x0000000000000002L}); 15140} 15141